Ecosystem & compatibility

Ingram Cloud integrates over industry standards. Wherever a standard exists, the API speaks it — OpenAI Chat Completions and Responses, the Model Context Protocol for tools, the Vercel AI SDK, and the major model providers. So the SDK, tools and channels you already use keep working against Ingram Cloud.

The one place that isn't a standard is the native run envelope, and it exists only for what no standard expresses yet (live tool-progress frames) — see the native surface.

Each surface below has its own page; this one shows how they fit together.

Drive a smith from your code

You call Ingram Cloud; the smith runs the agent loop server-side — its agent's instructions, tools, memory, and approvals — and streams the result back. Every surface below drives the same run loop, so the smith, its memory, and its tools behave identically; only the wire framing differs. Pick the one that matches the stack you already have.

A smith token is browser-safe and names exactly one smith; a tenant-admin token is server-side only and names the smith per request. See Auth & tokens and Browser calls.

The native surface

The OpenAI-compatible surface is the primary path and carries almost everything. The native run envelope (POST /v1/smiths/{id}/runs, a { "v": 1 } SSE stream) adds the one thing the standard wire doesn't yet: live tool-progress frames while a run works. Reach for it only when you need those; otherwise prefer a standard surface above. Details in Runs & streaming.

Reach your users where they are

Deploy a smith or agent to a messaging channel and Ingram Cloud runs it on every inbound message — the reply returns to the same conversation, on the same thread. You configure the channel once; there is no run loop to host and no webhook to write.

A deployment targets either a fixed smith or an agent that mints a fresh smith per sender — the pattern that gives each end-user their own isolated instance automatically. All of it, plus cron schedules, is in Deployments & schedules.

Give a smith tools and models

A smith reaches outward for the model it thinks with and the tools it calls.

• Models — bring your own key. Pick the provider and model per agent: OpenAI, Anthropic, or Gemini. Move between them without touching your code; hosted models work out of the box if you'd rather not manage keys.
• Tools over MCP. Register any MCP server and its tools become available to the smith — Ingram Cloud is the MCP client, calling your server and running the tools for you, with optional human approval gating. A curated catalog of common integrations ships ready to enable.
• Hosted tools. In-process tool bundles (calculation, reasoning, channel actions) a smith can use with no server to run.

See Tools & approvals.

Plug Ingram into other systems

The mirror image of the above: Ingram Cloud as a building block inside someone else's stack.

Where to start