Aerostack
Aerostack
psychology Aerostack MCP for AI Agents

The AI automation platform —
one MCP URL,
any agent.

Copy the Aerostack MCP into Claude Code, Cursor, OpenClaw, CrewAI, or any MCP-compatible agent. Your agent gets 16 tools to build functions, deploy MCPs, create bots, compose workspaces, and wire up workflows — without ever leaving the conversation.

mcp-config.json 
{
  "mcpServers": {
    "aerostack": {
      "url": "https://mcp.aerostack.dev",
      "headers": {
        "Authorization": "Bearer your_api_key"
      }
    }
  }
}

That's it. Your agent now has full infrastructure access.

Get Your MCP Key smart_toy Read the Guide
Claude Code Cursor Windsurf OpenClaw CrewAI AutoGPT LangChain Any MCP Client

What is an AI automation platform?

An AI automation platform is infrastructure an agent controls directly — not a visual builder a human operates. Aerostack exposes 16 MCP tools so any LLM-based agent can build, deploy, and orchestrate edge functions, MCP servers, bots, and workflows from a single URL. No dashboard, no CLI, no deployment pipeline — one conversation, from idea to a live production URL.

The difference from a no-code tool is who does the work. A visual builder waits for a person to drag nodes onto a canvas. An agent automation platform hands the agent the same primitives a developer would use — create, deploy, test, validate — so it can compose real infrastructure on your behalf.

AI agent orchestration, not just task execution

Aerostack is an AI agent orchestration layer: agents coordinate across functions, bots, and MCP servers rather than running in isolation. One agent can scaffold a function, hand it to another agent to test, and publish the result to the marketplace for a third to discover — all within a single platform, without switching tools.

// 16 Tools

Everything your agent needs. Built in.

Your agent gets a complete infrastructure toolkit. No SDKs, no API docs, no boilerplate — just tool calls.

Discover & Plan
terminal
plan()

Analyze any integration request — find MCPs, detect gaps, get a credential checklist

terminal
capabilities()

Inspect any MCP or service — tools, auth requirements, schemas

terminal
guide()

Context-aware help on setup, credentials, node types, platform config

terminal
sdk_docs()

SDK reference and code patterns for building MCP servers or edge functions

Build & Deploy
terminal
scaffold()

Describe what you want in plain English → get a ready-to-create config

terminal
create()

Create bots, workflows, functions, endpoints, webhooks — code auto-deployed to edge

terminal
deploy()

Push to live — register bot webhooks, activate workflows, push functions to 300+ cities

Integrate & Compose
terminal
setup_integration()

One call: create workspace, add MCPs, store encrypted secrets, verify health

terminal
generate_workflow()

Auto-discover tools in workspace, build trigger → source → transform → destination graph

terminal
build_spec()

Generate MCP server templates for any API — boilerplate, tool stubs, marketplace metadata

Test & Iterate
terminal
test()

Test-run any resource with a payload — get per-node execution logs back

terminal
validate()

Validate configs before deploying — catch disconnected nodes, missing fields, syntax errors

terminal
publish()

Ship to the Aerostack marketplace — auto-checked for quality, discoverable by other agents

Manage
terminal
update()

Partial updates to any resource — functions auto-redeploy on change

terminal
delete()

Remove resources with reference checks so nothing breaks downstream

terminal
list() / get()

List every resource in a workspace or get the full details of one

code_blocks In-function SDK

The edge functions your agent deploys are more than HTTP handlers. Each one gets a scoped Aerostack SDK, so a single function can query a database, send email, enqueue a job, and call an AI model — without leaving the worker.

electrical_services sdk.db

Query and write to a database

electrical_services sdk.cache

Read/write edge cache

electrical_services sdk.queue

Enqueue background jobs

electrical_services sdk.ai

Call AI models inline

electrical_services sdk.email

Send transactional email

electrical_services sdk.storage

Read/write object storage

electrical_services sdk.secrets

Access encrypted secrets

// How It Works

From idea to production. One conversation.

Your agent handles every step — from discovery to deployment. No dashboards, no config files, no manual wiring.

bolt
01

Describe what you need

Tell your agent in natural language. "Connect my Notion to Slack." "Build a support bot." "Deploy a webhook that enriches leads."

bolt
02

Agent plans the architecture

Searches the marketplace, detects gaps, identifies missing integrations, and returns a structured execution plan with credential requirements.

bolt
03

Agent builds what's missing

No MCP for the API you need? Agent generates one from scratch — boilerplate, tool stubs, tests. Deploys custom functions to the edge.

bolt
04

Agent composes & deploys

Creates workspace, adds MCPs, stores encrypted secrets, generates workflow, validates, tests, and pushes to live — all in one conversation.

bolt
05

You get a production URL

One workspace URL with everything composed. Share with your team, connect to other agents, or embed in your product.

// Agent-to-Agent

Agents build infrastructure for other agents.

When an agent publishes a function or MCP server, it becomes discoverable by every other agent. The platform compounds — each thing one agent ships makes the next agent more capable.

robot_2
Agent A

Builds a lead-scoring edge function and publishes it to the marketplace

create() → publish()
robot_2
Agent B

Discovers the published function via plan() and installs it into its workspace

plan()
robot_2
Agent C

Wraps that function into a workflow that runs on a schedule

generate_workflow()

The same loop provisions runtimes: an agent can call create() to spin up a persistent, managed agent that other agents — or you — can hand work to. No no-code tool-picker exposes a build, publish, and discover loop like this.

// Beyond MCP Config

Use in your code.

Already building with OpenAI, LangChain, or Vercel AI? Drop in our SDK — same workspace tools, native integration.

agent.ts — Vercel AI SDK 
import { openai } from '@ai-sdk/openai';
import { generateText } from 'ai';
import { getTools } from '@aerostack/sdk-vercel-ai';

const { tools } = await getTools({
  workspace: 'my-workspace',
  token: 'mwt_...',
});

// Tools auto-execute — no manual handling needed
const { text } = await generateText({
  model: openai('gpt-4o'),
  tools,
  maxSteps: 5,
  prompt: 'Deploy mcp-stripe and create a payment webhook',
});

npm install

@aerostack/sdk-vercel-ai

npm install

@aerostack/sdk-langchain

npm install

@aerostack/sdk-openai
// Zero Gaps

No MCP? No problem. Agent builds it.

If an integration doesn't exist on the marketplace, your agent creates one on the fly. Build, deploy, and compose — all in the same conversation.

stars

Post to Ocoya (social media)

auto-built

Agent generates MCP server → deploys → adds to workspace

deployed_code

Read from Airtable

on Hub

Agent finds mcp-airtable on Hub → installs → ready to use

stars

Custom lead scoring logic

auto-built

Agent writes edge function → deploys → composes into workflow

deployed_code

Slack notifications

on Hub

Agent finds mcp-slack on Hub → installs with webhook URL

stars

Internal company API

auto-built

Agent generates proxy MCP → wraps your API → encrypted secrets

deployed_code

Stripe payments

on Hub

Agent finds mcp-stripe on Hub → installs with API key

extension Marketplace has it? install()
stars Doesn't exist? build_spec() → create() → deploy()
security

Giving agents infrastructure access? Control exactly which tools they can use. Block destructive operations at the platform level. Learn about MCP Security →

Give your agent
superpowers.

Get your API key, paste the MCP config, and your agent can build, deploy, and compose anything on Aerostack's infrastructure. Start free.

mcp-config.json 
{
  "mcpServers": {
    "aerostack": {
      "url": "https://mcp.aerostack.dev",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
Get Your API Key — Free Full Documentation

Related features

Workflows OpenClaw Edge Functions

Frequently asked questions

What is an AI automation platform, and how does Aerostack fit that definition? expand_more
An AI automation platform gives agents the tools to act on your infrastructure — not just reason about it. Most platforms stop at orchestrating API calls; Aerostack goes further by giving any MCP-compatible agent a single URL that unlocks 16 infrastructure tools: build edge functions, deploy MCP servers, create bots, compose workspaces, store encrypted secrets, and wire up workflows — all without leaving the conversation. The agent doesn't need a dashboard, a CLI, or a deployment pipeline. It generates the code, validates it, tests it, and pushes it live in one session. Claude Code, Cursor, OpenClaw, and CrewAI all work out of the box, and any agent that speaks the Model Context Protocol can connect the same way.
What exactly happens when an AI agent connects to Aerostack via one MCP URL? expand_more
Connecting the Aerostack MCP URL hands the agent a set of 16 tools that cover the full infrastructure lifecycle. The agent can create a workspace, add MCP servers to it, store encrypted API keys, scaffold and deploy edge functions on Cloudflare Workers, generate and publish workflows, and spin up bots — all from a single conversation thread. Nothing is mocked: when the agent calls a deploy tool, the function goes live on Cloudflare's edge with near-zero cold start. The workspace it creates is a real, persistent environment you can open in the dashboard, inspect, and hand off to teammates. The agent is doing real work, not producing a spec for you to implement.
How is this different from the Aerostack visual workflow builder? expand_more
The visual workflow builder on the Workflows page is for designing automation logic by hand — drag nodes onto a canvas, connect them, publish. It's the right tool when you already know the shape of the automation and want full control over every step. Agent automation is for when you want an AI agent to figure out and build the automation for you from a description. The agent can generate a workflow, but it can also do much more: deploy the edge functions that power it, install the MCP servers it needs, and configure the workspace around it. Think of the visual builder as one thing the agent can build on your behalf, not the ceiling of what agentic automation means on Aerostack.
Which AI agents and frameworks work with the Aerostack MCP? expand_more
Any agent or framework that supports the Model Context Protocol standard can connect. That includes Claude Code, Cursor, OpenClaw, and CrewAI today. Because the interface is standard MCP, there is no SDK to install and no per-framework adapter to maintain — you add the Aerostack MCP URL to your agent's tool config the same way you'd add any other MCP server. The agent discovers the 16 available tools automatically and can start using them immediately. If you're building your own agent with an MCP client library, the same URL works there too.
Where does the code an agent deploys actually run? expand_more
Everything the agent deploys runs on Cloudflare Workers at the edge: globally distributed, near-zero cold start, no servers to provision or keep warm. When an agent builds and ships an edge function through Aerostack, that function is live worldwide in seconds. The free tier includes 500K AI tokens a month; if you bring your own model API key, the platform markup drops to zero, so you only pay Cloudflare's usage costs. State, secrets, and configuration are stored per-workspace on the platform, so nothing the agent creates is ephemeral — it's all there when you come back to the dashboard.
How do I control what an AI agent is allowed to do on my infrastructure? expand_more
Aerostack lets you allowlist or blocklist individual MCP tools at the workspace level, so you can grant an agent read and build access without exposing deploy or delete operations. This is the same tool-level permission model that governs every MCP server in a workspace — agents, bots, and human users all operate under the same policy layer. You can also require human approval before any destructive or irreversible action executes, using the same approval primitive that the workflow builder exposes. The result is that you can let an agent work autonomously on a build task while keeping a hard boundary around production deploys until you sign off.
What kinds of agentic automation tasks is Aerostack best at? expand_more
Aerostack is strongest when the task crosses multiple infrastructure concerns in a single session: build a function that calls an external API, wire it into a workspace with the right MCP servers, create a bot that surfaces the result on WhatsApp, and set up a workflow that runs the whole thing on a schedule. Any one of those steps is table stakes; doing all four without switching tools is what agentic automation actually means here. It's also a good fit for tasks where the right shape of the automation isn't obvious up front — the agent can propose, build, test, and revise in the same conversation rather than handing you a plan to implement yourself.
Can agents build infrastructure for other agents on Aerostack? expand_more
Yes, and this is the part no no-code tool replicates. When one agent builds an edge function or an MCP server, it can publish that to the Aerostack marketplace, where every other agent can discover it. A typical loop: Agent A builds a lead-scoring function and publishes it, Agent B finds it through the plan() tool and installs it into a workspace, and Agent C wraps it in a scheduled workflow. Each thing one agent ships makes the next agent more capable, so the platform compounds over time. An agent can also call create() to provision a persistent, managed agent that other agents or your team can hand work to.
Do the functions an agent deploys get more than an HTTP handler? expand_more
Yes. Every edge function an agent deploys on Aerostack gets a scoped SDK, so it is a real infrastructure component, not just a request handler. From inside one function the agent can query a database with sdk.db, read and write the edge cache with sdk.cache, enqueue background jobs with sdk.queue, call AI models inline with sdk.ai, send transactional email with sdk.email, read and write object storage with sdk.storage, and read encrypted secrets with sdk.secrets. That means a single deployed function can, for example, take a webhook, look up a record, call a model, and email a result — all without leaving the worker.
When do I NOT need an AI automation platform like this? expand_more
If your automation is a single, fully deterministic step — a webhook that always transforms data the same way, a scheduled job with no branching, a one-time migration script — you don't need an agent or a platform. A standalone edge function or a simple script is faster to write, cheaper to run, and easier to debug. Aerostack's agent automation earns its place when the task involves coordinating multiple services, when the right approach requires reasoning rather than a fixed recipe, or when you want the whole infrastructure — functions, bots, workflows, MCP servers — built and composed together.