# Agent Automation — Use Aerostack MCP with Any AI Agent

> Give any AI agent full infrastructure access with one MCP URL. Build functions, deploy MCPs, create bots, compose workspaces, and wire up workflows — all via tool calls.

Give any AI agent full infrastructure access with a single MCP URL. Build functions, deploy MCPs, create bots, compose workspaces, and wire up workflows — all through natural tool calls.

**One config, any agent.** The Aerostack MCP works with Claude Code, Cursor, Windsurf, OpenClaw, CrewAI, AutoGPT, LangChain, and any MCP-compatible client.

---

## Quick Start

1. **Get your API key**

   Sign up at [app.aerostack.dev](https://app.aerostack.dev/register) and copy your project API key from **Settings → API Keys**.

2. **Add the MCP config**

   Paste this into your agent's MCP configuration:

   
     
       Add to `~/.claude/mcp.json`:

       ```json
       {
         "mcpServers": {
           "aerostack": {
             "url": "https://mcp.aerostack.dev",
             "headers": {
               "Authorization": "Bearer YOUR_API_KEY"
             }
           }
         }
       }
       ```
     
     
       Add to `.cursor/mcp.json` in your project:

       ```json
       {
         "mcpServers": {
           "aerostack": {
             "url": "https://mcp.aerostack.dev",
             "headers": {
               "Authorization": "Bearer YOUR_API_KEY"
             }
           }
         }
       }
       ```
     
     
       Add to `~/.codeium/windsurf/mcp_config.json`:

       ```json
       {
         "mcpServers": {
           "aerostack": {
             "url": "https://mcp.aerostack.dev",
             "headers": {
               "Authorization": "Bearer YOUR_API_KEY"
             }
           }
         }
       }
       ```
     
     
       Any MCP-compatible client can connect using Streamable HTTP transport:

       ```
       URL:     https://mcp.aerostack.dev
       Header:  Authorization: Bearer YOUR_API_KEY
       ```
     
   

3. **Start building**

   Your agent now has 16 tools. Try asking it:

   - *"Connect my Notion to Slack with daily summaries"*
   - *"Build a Telegram bot that answers questions from my docs"*
   - *"Create an MCP server for the Ocoya API"*
   - *"Set up a webhook that enriches leads from Typeform"*

---

## What Your Agent Gets: 16 Tools

Once connected, your agent has full access to Aerostack's infrastructure through these tools:

### Discover & Plan

| Tool | What it does |
|------|-------------|
| `plan()` | Analyze any integration request — find available MCPs on the marketplace, detect gaps, return a credential checklist and execution plan |
| `capabilities()` | Inspect any MCP or service — list all tools grouped by read/write/search, auth requirements, config schema |
| `guide()` | Get context-aware help — setup instructions, credential status, node type docs, platform configuration |
| `sdk_docs()` | Get SDK documentation and code patterns for building MCP servers or functions |

### Build & Deploy

| Tool | What it does |
|------|-------------|
| `scaffold()` | Describe what you want in plain English → get a ready-to-create config with missing credential warnings |
| `create()` | Create bots, workflows, functions, endpoints, or webhooks — function code auto-deploys to the edge |
| `update()` | Partial updates to any resource — only send changed fields, functions auto-redeploy |
| `deploy()` | Push to live — register bot webhooks with platforms, activate workflows, push functions to 300+ cities |
| `delete()` | Remove resources with reference checks (e.g., a workflow used by a bot can't be deleted) |

### Integrate & Compose

| Tool | What it does |
|------|-------------|
| `setup_integration()` | One call: create workspace, add MCP servers, store encrypted secrets, verify health |
| `generate_workflow()` | Auto-discover tools in a workspace, build a trigger → source → transform → destination workflow graph |
| `build_spec()` | Generate a complete MCP server template for any external API — boilerplate, tool stubs, marketplace metadata |
| `publish()` | Ship to the Aerostack marketplace — quality-checked, discoverable by other agents and users |

### Test & Validate

| Tool | What it does |
|------|-------------|
| `test()` | Test-run any resource with a payload — workflows return per-node execution logs |
| `validate()` | Pre-flight config validation — catch disconnected nodes, missing fields, syntax errors before deploying |
| `list()` / `get()` | List all resources or get full details of a specific one — config, status, workflow graph, credential status |

---

## Use Case Examples

### 1. Instant Integrations

**You say:** *"Connect Notion to Slack — post a summary of new pages every morning at 9am"*

**Agent does:**
1. `plan("Connect Notion to Slack, daily at 9am")` — finds both MCPs, returns credential checklist
2. `setup_integration(...)` — creates workspace, adds mcp-notion + mcp-slack, stores encrypted tokens
3. `generate_workflow(...)` — builds cron trigger → Notion search → LLM summarize → Slack post
4. `deploy(...)` — activates the workflow

**Result:** Production pipeline running on Cloudflare's edge. Every morning at 9am, Slack gets a summary.

---

### 2. Build a Bot in One Conversation

**You say:** *"Build a Telegram support bot that answers from our knowledge base"*

**Agent does:**
1. `scaffold("Telegram bot, answers from knowledge base")` — generates full bot config
2. `create({ type: "bot", ... })` — creates the bot with RAG pipeline
3. `test(...)` — sends test messages, verifies responses
4. `deploy(...)` — registers webhook with Telegram

**Result:** Live Telegram bot answering customer questions using your docs.

---

### 3. No MCP? Build One.

**You say:** *"I need to integrate with Ocoya's API for social media scheduling"*

**Agent does:**
1. `plan("Ocoya integration")` — searches marketplace, finds no existing MCP
2. `build_spec({ service: "ocoya", tools: ["create_post", "schedule_post", "get_analytics"] })` — generates server template
3. `create({ type: "function", ... })` — implements and deploys the MCP server
4. `test(...)` — validates against Ocoya's API
5. `publish(...)` — ships to marketplace (optional)

**Result:** Custom MCP server running on the edge, available in your workspace and optionally on the marketplace for others.

---

### 4. Compose Workspaces On-the-Fly

**You say:** *"Set up a workspace with GitHub, Notion, Slack, and a custom escalation function"*

**Agent does:**
1. `capabilities("github")`, `capabilities("notion")`, `capabilities("slack")` — checks available tools
2. `create({ type: "function", ... })` — builds the custom escalation handler
3. `setup_integration({ name: "Support Team", servers: [...] })` — composes everything

**Result:** One URL your whole team connects to. All four services namespaced under a single workspace.

---

### 5. Automate Business Processes

**You say:** *"When a new lead comes in from Typeform, enrich with Clearbit, score them, add to HubSpot. If high score, alert sales on Slack."*

**Agent does:**
1. `plan(...)` — maps the pipeline, identifies available MCPs and gaps
2. `create({ type: "function", ... })` — builds Clearbit enrichment + lead scoring function
3. `create({ type: "webhook", ... })` — webhook that orchestrates the entire pipeline
4. `generate_workflow(...)` — conditional routing: high score → Slack alert

**Result:** End-to-end lead pipeline. Paste the webhook URL into Typeform and it's live.

---

## How It Works Under the Hood

%%{'{'}init: {'{'}'theme': 'dark', 'themeVariables': {'{'} 'primaryColor': '#3b82f6', 'lineColor': '#6b7280' {'}'}{'}'}{'}'}%%
flowchart LR
    A[AI Agent] -->|MCP protocol| B[Aerostack MCP]
    B -->|tool calls| C[Aerostack API]
    C --> D[Functions]
    C --> E[MCP Servers]
    C --> F[Bots]
    C --> G[Workflows]
    C --> H[Workspaces]
    C --> I[Marketplace]

1. Your agent connects via MCP protocol (Streamable HTTP)
2. Each tool call maps to Aerostack's API with your project credentials
3. Resources are created, deployed, and managed on Cloudflare's edge network
4. Everything is scoped to your project — secrets encrypted, resources isolated

---

## Compatible Agents & Frameworks

The Aerostack MCP works with any client that supports the MCP protocol:

| Agent / Framework | How to connect |
|-------------------|---------------|
| **Claude Code** | Add to `~/.claude/mcp.json` |
| **Cursor** | Add to `.cursor/mcp.json` |
| **Windsurf** | Add to `~/.codeium/windsurf/mcp_config.json` |
| **VS Code Copilot** | Add to `.vscode/mcp.json` |
| **OpenClaw** | MCP server configuration |
| **CrewAI** | MCP tool integration |
| **AutoGPT** | MCP plugin |
| **LangChain / LangGraph** | MCP tool wrapper |
| **Custom agents** | Any Streamable HTTP MCP client |

---

## Agent-to-Agent: Agents Building for Agents

The most powerful pattern: agents that build infrastructure for other agents.

- **Agent A** creates a lead-scoring function → publishes to marketplace
- **Agent B** discovers it via `plan()` → installs into workspace
- **Agent C** wraps it in a workflow with Slack alerts → deploys for their team

This creates a **network effect**: every agent that builds and publishes makes the platform more valuable for every other agent.

---

## Security & Isolation

- **Project scoping** — each API key is scoped to one project. Agents can only access their own resources.
- **Encrypted secrets** — all credentials (API keys, tokens) encrypted at rest with AES-256-GCM. Never exposed in tool responses.
- **Audit trail** — every tool call is logged with timestamp, resource ID, and action type.
- **Validation before deploy** — `validate()` catches issues before anything goes live.

**API key security:** Treat your Aerostack API key like a database password. It grants full infrastructure access to your project. Use environment variables, never hardcode it.

---

## What's Next

- **Scoped permissions** — fine-grained API keys (read-only, deploy-only, specific resource types)
- **Spending caps** — per-key budget limits so autonomous agents can't exceed your budget
- **Agent identity** — distinguish which agent created which resource in the audit log
- **Template snapshots** — agents can export a full workspace as a reusable template
- **Semantic discovery** — `plan()` uses vector search to find the most relevant MCPs and functions

---

## Get Started

1. [Sign up for free](https://app.aerostack.dev/register)
2. Copy your API key from Settings
3. Paste the MCP config into your agent
4. Ask it to build something

That's it. Your agent is now a full-stack developer.