Platform
Turn coding agents into a delivery system.
Give coding agents shared context, coordinated execution, verification, and deployment workflows so they can deliver production-ready software instead of isolated pull requests.
Prefer we run it for you? See Managed.
Three surfaces
Context, then a plan, then the work
Understand the system, agree on what needs doing, then build it. A pull request is where the work becomes reviewable, not where it stops.
Context
One shared picture of your systems
Connect GitHub, GitLab, or Bitbucket and the catalog builds itself: repositories, languages, services, entry points. The infrastructure scan runs from within your cloud and maps what is actually running to the repository that ships it. Correct a low-confidence guess once and every session and Task afterwards starts from the corrected answer.
What Deployment.io isAssistant
Decide what to do before anything is built
Sessions read your code and discuss it. They do not edit files, run tests, or push anything, and the working copy disappears when the session ends. With Claude Code that restriction is enforced rather than requested. What you end up with is a spec: the goal, what counts as finished, what is out of scope.
Sessions and specsTasks
A board your team shares with its agents
Drop a card in the backlog, pick which agent and model runs it, and watch it move. A Task opens a pull request in each repository it touched, so your review, CI, and branch rules apply unchanged. The pull request is a checkpoint, not the finish line: verification runs before it appears, and the deploy that follows waits for your approval.
How Tasks workThe loop, in detail
Plan, implement, verify, deploy
What actually happens on each step when your team is driving.
Work it out in a session first
A session is a conversation with an agent that can read your repositories. It answers questions, and when you know what you want, it writes a spec. Sessions are read only. Convert the spec and it lands in your Tasks backlog as a draft.
A session reading your repositories and drafting a spec.
What it ships
Deploys run in your cloud, with no YAML to write. The build command, port, and health check are read from your repository.
Static sites
React, Next.js, Vue, Astro, and others, with HTTPS, a global CDN, cache invalidation, and rollbacks.
Web services
Go, Node.js, Python, Ruby, and Rust, with auto-scaling, health checks, and zero-downtime rollouts.
Environments
Dev, staging, and production, each in its own AWS account if you want them separated that way.
Preview deployments
Open a pull request and get a running preview of that branch, torn down when it closes.
Custom domains and headers
Bring your domain. Certificates, CDN, and load balancing are wired for you; response headers are yours to set.
Logs and alerts
Build logs and application logs in the dashboard, with deploy alerts in Slack.
Control
Autonomy you grant, not autonomy you inherit
Agents get exactly the scope you give them and nothing else. Every step that could affect production stops for a person, and the record of who allowed what stays queryable afterwards.
Role-based access controlsApproval gates
Tool calls that touch production queue for a human. Approve from Slack or the dashboard, or reject and nothing runs.
Roles for people and agents
Scope what each teammate and each MCP token can deploy, read, or approve. Share individual environments and deployments rather than the whole org.
An activity trail
Which agent ran, on what, with which model, what it changed, who approved the deploy, and when.
Your models, your keys
Bring your own provider key, or connect a Claude Code subscription. Plan with one model and build with another, and point the work at a better one when it ships.
Architecture
Control plane ours, data plane yours
Control plane
Runs on our AWS. Handles user management, scheduling the jobs your runner executes, billing, and the public API. It sees job state, logs, and metadata.
Data plane, in your cloud
The runner lives in your AWS account and does the actual work: checking out code, building, deploying, creating previews, and running coding agents in isolated containers. It needs a private subnet and an outbound HTTPS connection, nothing inbound.
Your code stays put
Source code, credentials, and execution remain in your cloud account. Only job state, logs, and metadata flow back to us, encrypted over TLS.
The runner is open source
The component that touches your infrastructure is public. Audit it, fork it, or build it yourself.
Revoke access anytime
We connect through a scoped role you control. Detach the role and we lose all access, instantly.
Already have an agent?
Drive it from the agent you already use
Deployment.io exposes a native MCP server, so Claude Code, Cursor, Windsurf, Copilot, Codex, or Gemini CLI can call real deploy actions rather than describing them. There is an open-source skill for agents that support one. Scope what each MCP token is allowed to do, the same way you scope a teammate.
Connect a repository and run one Task
The free tier is enough to see the whole loop: context, a session, a Task, and a deploy that waits for you.