Source availableby Agentifiers

Ship agents like software, not magic prompts

Deployments.ai is the agent platform you embed in your product. Agents as code, immutable releases, a governed model gateway, tools and MCP, sandboxes, memory, channels, agent email, workflows, and observability — one control plane you can run in your own AWS account.

Get early accessExplore every capability
agent.json
{
  "apiVersion": "agents.deployments.ai/v1",
  "kind": "Agent",
  "metadata": {
    "key": "example.assistant",
    "name": "Example Assistant",
    "version": "1.0.0"
  },
  "spec": {
    "instructions": "Use the declared capabilities to complete the request.",
    "model": {
      "id": "openrouter/default",
      "fallbackIds": ["openrouter/fallback"]
    },
    "memory": { "mode": "workspace" },
    "capabilities": {
      "tools": [{
        "authorization": "workspace",
        "name": "records.read",
        "required": true,
        "requiredScopes": ["records:read"]
      }]
    },
    "runtime": { "modelTools": ["records.read"] },
    "sandbox": { "mode": "none" },
    "triggers": ["api", "schedule", "workflow"]
  }
}
terminal
$ deployments dev agent.json --message "Summarize ticket 812"
$ deployments release promote --target-environment "$PROD_ENV"
$ deployments trace list
  • Agent-as-code
  • Immutable releases
  • Canary & promotion
  • Model gateway
  • MCP & tools
  • Sandboxes
  • Web & browser tools
  • Memory & Brains
  • Slack · Telegram · RCS
  • Agent email
  • Durable workflows
  • Approvals
  • Durable Streams
  • Semantic events & webhooks
  • Traces & evaluations
  • Usage & budgets
  • Signed audit exports

360+

operations in one public API, mirrored by the CLI

170+

integration providers in the catalog

130+

vendor-hosted MCP servers

1

thread and run model for every channel and trigger

Counts come from the current development contract and catalogs.

Why Deployments.ai

Everything agents need to run inside your product

Stop stitching model calls, secret stores, sandboxes, webhooks, and dashboards together yourself. Deployments.ai is the layer between agents defined as code and a runtime you can trust in production — built so your product team ships agents instead of infrastructure.

  • Releases you can trust
  • Channels and agent email
  • Tools with guardrails
  • Observability from the first run
See how the platform works
01

Releases you can trust

Agents are code. Publishing creates an immutable, SHA-256 content-hashed release; every run pins the exact release it started on.

Canary, roll back, or promote the identical release across environments.

02

Channels and agent email

Slack, Telegram, RCS business messaging, and real agent inboxes on your domain — all landing on the same thread and run model as your API.

One conversation model, wherever your users are.

03

Tools with guardrails

MCP servers, client-executed tools, HTTP callbacks, sandboxed code, and durable workflows — with approvals before risky actions run.

Secrets are injected at execution, never into model context.

04

Observability from the first run

Traces, spans, metrics, semantic events, evaluations, and usage metering are part of the runtime, not a dashboard you bolt on later.

Inspectable, comparable, and metered per environment.

The lifecycle

From a manifest to production, the way you ship software

  1. 01

    Define

    Write the agent as code: instructions, model, tools, memory, sandbox, and triggers in one versioned manifest.

  2. 02

    Preview

    Run an unpublished manifest on the hosted worker with deployments dev — no definitions, releases, or deployments created.

  3. 03

    Publish

    Publishing creates a numbered, immutable release whose content hash is computed server-side.

  4. 04

    Deploy

    A deployment pins a release in an environment, with that environment's credentials and tool policies.

  5. 05

    Run

    API calls, chat, email, schedules, heartbeats, webhooks, and channels all converge on one thread and run.

  6. 06

    Promote

    Canary a candidate, roll back, or promote the identical release to another environment without a rebuild.

One public contract across the API, SDK, and CLI.

Read the platform tour

Capabilities

One platform. The full surface area

Twelve capability areas ship together, so your agents get production plumbing on day one instead of a roadmap.

Agent-as-codeAgents are JSON manifests validated against one schema and published as immutable releases. Deployments pin a release per environment, so every run records exactly which definition it executed.SHA-256 content hashesCanary weights 1–99
Model gatewayEvery model call goes through a private gateway that holds the provider keys, so agent workers never see them. Each environment decides which models its agents may use.OpenAI, OpenRouter, BedrockShort-lived signed tokens
Tools and integrationsAgents call tools from a shared catalog, vendor-hosted MCP servers, your own MCP servers, your client app, or your HTTP endpoints. Connections are authorized and synced per environment.130+ vendor MCP servers170+ catalog providers
Code sandboxescode.execute runs Bash, JavaScript, and Python inside AWS Lambda MicroVMs. Workspaces can be scoped to one run or persist across a thread.Lambda MicroVMsBash, JavaScript, Python
Web and browser toolsA self-hosted web tools service gives agents search, scraping, crawling, and parsing, and headless Chromium handles screenshots. Requests to private addresses are refused.Search, scrape, crawlPrivate egress denied
Memory and Native BrainsAgents keep portable memory across threads and draw on organization knowledge through Native Brains. Memory is canonical in DynamoDB, with search on AWS OpenSearch.Typed memoriesCited Brain answers
Channels and agent emailSlack, Telegram, RCS, and email all land on the same thread and run model as API calls. Agents can have their own inboxes on a hosted domain or yours.Slack, Telegram, RCSAgent inboxes
Workflows and approvalsDurable workflows, schedules, and heartbeats run agents without anyone at a keyboard. Approvals pause a run until a person decides.Durable workflowsApproval deadlines
Streaming and eventsLive run output streams to clients over SSE, and every customer-visible state change becomes a semantic event. Events reach EventBridge and signed webhooks.SSE streamsTransactional events
Observability and evaluationsEvery hosted run produces a trace covering model calls, tools, memory, sandboxes, approvals, tokens, and cost. Evaluations score runs against datasets and compare releases.Metadata-only by defaultDataset replays
Usage and budgetsEach install meters itself from its own usage ledger, with no third-party billing in the loop. Budgets at organization, project, or environment scope refuse new runs once exhausted.Self-metered ledgerOrg, project, environment
Security and governanceTenancy, identity, credentials, and data lifecycle are part of the platform, not something each agent adds. Each environment is the isolation boundary for credentials, deployments, and usage.Hashed API keysKMS-encrypted vault
Browse the full capability catalog

Bring your own cloud

Run the whole stack in an AWS account you own

The platform is provisioned with OpenTofu into any AWS account you point it at — one dedicated account per environment. Canonical state stays in your DynamoDB tables and KMS-encrypted S3; provider keys stay in your model gateway.

  • One deploy tool ships the OpenTofu stack, images, and functions into a target account
  • Dedicated AWS account per environment for real isolation
  • Built on Lambda, ECS on Fargate, DynamoDB, S3, KMS, EventBridge, and Kinesis
  • Container images pinned by content digest
Security and governance

Run it your way

Self-hosted, set up for you, or fully managed

The same platform and API in every case. Agentifiers — the team behind Deployments.ai — can set it up in your AWS account or run it for you.

Self-hosted

Teams who want to run it themselves

FreeFSL-1.1-ALv2 · runs in your AWS account
Read the source

Run the full platform in your own AWS account, on your own schedule.

What you get

  • The complete platform source
  • OpenTofu modules and the deploy tool for AWS
  • API, CLI, and SDK
  • Every capability in the catalog
  • Changes for your own use, including commercial use
White-glove

Set up by Agentifiers

Teams who want BYOC without the platform work

Fixed scopeone engagement
Talk to Agentifiers

Agentifiers deploys and configures Deployments.ai in an AWS account in your AWS Organization and gets your first agent into production.

Everything in self-hosted, plus

  • Deployment into an AWS account in your org
  • Environments, model policies, and credentials configured
  • Your first agent built with your team
  • Runbooks and handover to your engineers
  • Optional ongoing support

Hosted & managed

Teams who want to ship without running infrastructure

Managedongoing platform access
Request access

Use the platform without operating it. Agentifiers runs, upgrades, and monitors it; your engineers build agents.

What you get

  • Same platform and API as self-hosted
  • Operated, upgraded, and monitored for you
  • Environments for development and production
  • Usage and budgets per environment
  • Invoiced by Agentifiers
Source and license

Use cases

What teams build on it

Product teams

Agents inside your SaaS product

Ship agent features your customers use in your app. Agents call functions inside your product through client-executed tools, stream responses into your UI, and keep memory and tool authorization scoped to each customer's workspace.

Vertical software

Vertical AI products

Build a focused product for one industry on a shared agent runtime instead of rebuilding infrastructure each time: releases, channels, agent email, approvals, and governance come with it.

Customer experience

Support and success agents

Agents read tickets and inbound email, pull context through connectors such as Zendesk, Linear, and Notion, draft replies, and wait for a person's approval before writing back.

All use cases

FAQ

Questions we hear most

01The platform

Deployments.ai is an agent platform you embed in your product. You define agents as code, publish them as immutable releases, deploy them per environment, and run them through one thread and run model — with the model gateway, tools, sandboxes, memory, channels, agent email, workflows, streaming, observability, usage, and governance already built in.

A framework is a library you call from your own code. Deployments.ai is the platform underneath: the control plane, the hosted runtime, the secrets vault, the tool and channel integrations, and the operational pipeline. You can still bring your own logic through tools, MCP servers, HTTP callbacks, and client-executed tools.

Agents call models through a private gateway with OpenAI, OpenRouter, and Amazon Bedrock as providers. Each environment has a model policy that decides which models are allowed, and agents can declare fallback models. Provider keys stay in the gateway.

The catalog includes more than 170 integration providers, among them 130+ vendor-hosted MCP servers such as GitHub, Notion, Linear, Sentry, Google Drive, Jira, and Zendesk. You can also add your own MCP servers, HTTP callbacks, hosted functions, and tools that run inside your own application. See tools and integrations.

02Source and license

In the Agentifiers/deployments repository on GitHub: the control plane and public contract, the agent runtime, tools and channels, the operational pipeline, the OpenTofu modules and deploy tool that install it, and the CLI and SDK. See what's in it.

The platform is licensed under the Functional Source License, Version 1.1, with the Apache License 2.0 as its future license (FSL-1.1-ALv2). FSL is a Fair Source license, not an OSI-approved one: the source is public, with one restriction on competing use. Each release becomes available under Apache 2.0 two years after it is published. The TypeScript SDK and the deployments CLI are MIT licensed.

You can read the code, self-host it, and modify it for your own use, including commercial use inside your business. You cannot offer it to others as a competing commercial product or service. White-labeling or reselling the platform to other companies is a competing use and needs a commercial license from Agentifiers; talk to us. If you are unsure whether your use competes, ask us first.

Agentifiers. The same team also helps companies set the platform up in their own AWS accounts, and offers it hosted and managed.

All questions