For developers

Connect your systems to agents that do the work

Use webhook starts, the partner API with your own API keys - including creating and changing agents from JSON files - reviewed connectors and HTTP calls, imported connector manifests, and reusable Skills. Connect remote MCP servers and let agents run their tools - read-only tools automatically, everything else after your approval.

A bigger screen is best for building. On a phone you can read this page and follow its links, and you can still make quick edits to an agent - add blocks, open one to configure it, and connect them with a button. Dragging blocks around and wiring by hand work best with a mouse.

Explore connectors Read the webhook guide

From your event to a useful result

Your system sends a verified event. The agent uses only the connected actions you allow, then returns or delivers the result.

Choose how you want to connect

Open the path that matches your job. Every path below exists in the product now.

Start agents from your systemsAvailable

Activate an agent with a webhook start and it mints a unique URL, shown exactly once. The URL's unguessable token is the whole credential - treat it like a password, and re-activate the agent to rotate it. Anything that can POST JSON to that URL can start the agent.

Managed event triggers are live for Telegram messages, GitHub issues opened, GitHub pull requests opened, new RSS items, new videos on a YouTube channel, and new YouTube comments. Amistio registers the Telegram and GitHub webhooks for you and verifies deliveries before they run - unrecognized or unverified calls get a plain not-found answer. RSS feeds and YouTube need no webhook: Amistio checks them for you every five minutes.

POST /api/hooks/<secret-token>
Content-Type: application/json

{
  "event": "order.ready",
  "id": "evt_123"
}

Read the webhook setup guide

Call Amistio from your own softwareAvailable

Create API keys under Settings in Amistio. Each key belongs to you, carries only the scopes you choose, can expire, and can be revoked at any time. The key is shown exactly once - Amistio keeps only a digest. Send it in the Authorization header over HTTPS, never in a URL.

Under /api/v1 you can list your agents with their published versions, start a run of an agent's published version, and read one run or the runs of one agent. Send an Idempotency-Key header when you start a run so a retry never starts a second one. Everything is scoped to your own agents; another owner's id gets a plain not-found answer.

Show a published agent's public run page inside your own site: register the exact origins that may embed it, then mint a short-lived embed session for one of them. Register a callback URL for an agent and Amistio sends a signed result event when a run settles, retrying for a bounded time.

The OpenAPI document at /api/v1/openapi.json describes every operation. Protection bounds, not pricing: 60 requests per minute per key and 10 run starts per minute per owner, answered with 429 and Retry-After.

Agents as code: with a key that carries agents:write and agents:publish, create an agent from a JSON document, check a document without saving, read and replace the draft behind the revision you read, freeze a version, and put it live or take it off - with exactly the checks a save in the Studio gets. The document's JSON Schema is at /api/v1/schemas/agent.json.

GET /api/v1/agents
Authorization: Bearer amk_<key-id>_<secret>

POST /api/v1/agents/<agent-id>/runs
Authorization: Bearer amk_<key-id>_<secret>
Idempotency-Key: order-123
Content-Type: application/json

{
  "input": { "topic": "weekly report" }
}

Open the developer corner Create an agent from your terminal Read the API reference Read the integration guides

Call any API from an agentAvailable

The generic HTTP request operation lets an agent call any service you can reach with a URL. Alongside it, provider connectors - Slack, GitHub, Notion, Airtable, Discord, Telegram, LinkedIn, Google Calendar, Google Sheets, Gmail, Google Tasks, YouTube, and more - ship with reviewed operations; the directory lists every one.

Bring your own tokens: they are stored encrypted, visible only to you, and never copied when an agent is shared. Where a provider OAuth app is configured, you can connect your account with OAuth instead.

Browse all connectors

Bring your own connectorAvailable

Import a connector manifest - a JSON document you supply - and it lands in review. An imported connector never executes until it is published. What you import becomes available on this Amistio service; there is no marketplace.

Teach agents reusable behavior with SkillsAvailable

Skills are reusable instruction packs written in plain language. Create and edit them at /builder/skills, attach up to 8 to an AI step, and release immutable versions. A released skill is shared as a pinned slug@N link, so what others attach is exactly what you released.

Remote MCP serversAvailable

You can connect a remote MCP server today - from the curated directory or any URL you paste. Sign in with OAuth, paste a server token, or connect a public server with no sign-in. The server's tools, resources, and prompts are pinned when you connect, and every run first checks the live tool against the details frozen when you added it.

Read-only tools and resource reads run on their own, with a size bound on what one read may return; every other tool waits for your approval. You can import a server's prompts as Skill drafts and review them before release. A server can never drive the model or ask you questions - sampling and elicitation are not supported.

Create an agent from your terminal

From an empty folder to a live agent you can open in the Studio, in nine short steps. Every command is plain curl on your own machine; the reference shows each call in eight languages.

Create a key that may write and publish
Under Settings in Amistio, create a key with the agents:write and agents:publish scopes. It is shown exactly once - keep it in your shell as AMISTIO_KEY, never in a file you commit.
```
export AMISTIO_KEY="amk_<keyId>_<secret>"
```
Open Developer keys
Fetch the document's JSON Schema
It is generated from the very rules Amistio checks a Studio save with. Point your editor or your CI at it and a bad file is caught before it is sent.
```
curl https://www.amistio.com/api/v1/schemas/agent.json
```
This call in eight languages

Write the smallest agent file

One manual trigger, one AI step, one recorded result - the shape the Studio's blank template starts from. Save it as hello.agent.json.

hello.agent.json

{
  "name": "Hello from the terminal",
  "description": "A minimal agent: manual trigger, an AI step, and a recorded result.",
  "graph": {
    "nodes": [
      {
        "id": "trigger",
        "kind": "trigger",
        "name": "Manual trigger",
        "config": {
          "activation": {
            "kind": "manual"
          }
        }
      },
      {
        "id": "model",
        "kind": "model",
        "name": "Your model endpoint",
        "config": {
          "model": {
            "modelId": "byo-endpoint",
            "version": "1"
          }
        }
      },
      {
        "id": "agent",
        "kind": "agent",
        "name": "AI step",
        "config": {
          "instructions": "Read the incoming data and reply with a short, useful result in plain language."
        }
      },
      {
        "id": "done",
        "kind": "output",
        "name": "Result",
        "config": {
          "outputKey": "result"
        }
      }
    ],
    "edges": [
      {
        "id": "e-attach-model",
        "class": "attachment",
        "source": "model",
        "target": "agent"
      },
      {
        "id": "e-trigger-agent",
        "class": "flow",
        "source": "trigger",
        "sourcePort": {
          "port": "next"
        },
        "target": "agent",
        "targetPort": {
          "port": "input"
        }
      },
      {
        "id": "e-agent-done",
        "class": "flow",
        "source": "agent",
        "sourcePort": {
          "port": "next"
        },
        "target": "done",
        "targetPort": {
          "port": "input"
        }
      }
    ]
  }
}

Check the file without saving
The same checks as a save: schema, graph, size, and no credential-shaped strings. You get ok and the findings list, and nothing is stored either way.
```
curl -X POST -H "Authorization: Bearer $AMISTIO_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"document\":$(cat hello.agent.json)}" \
  https://www.amistio.com/api/v1/agents/validate
```
This call in eight languages

Create the agent

The draft is exactly your document, at revision 0. Keep the agentId from the answer; an Idempotency-Key makes a retry return the same agent instead of a second one.

curl -X POST -H "Authorization: Bearer $AMISTIO_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: hello-1" \
  -d "{\"document\":$(cat hello.agent.json)}" \
  https://www.amistio.com/api/v1/agents

This call in eight languages

Change it, behind the revision you read
Edit the file - the instructions, say - and send the whole document again with expectedRevision. A stale revision answers 409 with the current one, never a silent overwrite.
```
curl -X PUT -H "Authorization: Bearer $AMISTIO_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"document\":$(cat hello.agent.json),\"expectedRevision\":0}" \
  https://www.amistio.com/api/v1/agents/<agentId>/draft
```
This call in eight languages
Freeze a version
The draft at that revision becomes an immutable version with a digest. Blocking findings answer 422, exactly as the Studio refuses the same save.
```
curl -X POST -H "Authorization: Bearer $AMISTIO_KEY" \
  -H "Content-Type: application/json" \
  -d '{"expectedRevision":1}' \
  https://www.amistio.com/api/v1/agents/<agentId>/versions
```
This call in eight languages
Put it live
The latest frozen version starts answering - the Studio's Go live. DELETE the same address to take it off again.
```
curl -X POST -H "Authorization: Bearer $AMISTIO_KEY" \
  https://www.amistio.com/api/v1/agents/<agentId>/activation
```
This call in eight languages
Run it and open it
Start a run of the live version and read the result from the answer. The agent is an ordinary agent: open it on My agents, where the Edit door takes you to the Studio and the revision says Edited through the API.
```
curl -X POST -H "Authorization: Bearer $AMISTIO_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: hello-1" \
  -d '{"input":{}}' \
  https://www.amistio.com/api/v1/agents/<agentId>/runs
```
Open My agents This call in eight languages

Every call in the reference, in eight languages

Inspect the real connector surface

These examples come from the same reviewed platform directory the Studio uses. Open one to see every operation, input, and safety rule.

What exists today

Available now

Remote MCP servers

Not offered today

Amistio does not offer an SDK, a CLI, or an extension marketplace today. Use the API directly with any HTTP client.