The Deployer is live. The Free plan ships a real app to a cloud account you own.
See pricingThe Deployer is an agentic deployment platform for developers. Point it at a GitHub repository and AI agents read your code, design the architecture, provision your cloud, and set up a production-grade CI/CD pipeline with monitoring, logs, DNS, and a chat copilot. You know your codebase. It handles the infrastructure you were never hired to run.
One agent team, in place of an entire open-source DevOps stack
A repository isn't a running product. In between sits provisioning, Dockerfiles, reverse proxies, TLS, secrets, CI/CD, monitoring, and DNS. That is a second discipline you never signed up to learn. The Deployer closes that gap, so shipping doesn't depend on hiring for it.
A deterministic orchestrator drives the flow, while specialist agents do the thinking inside each phase. You see every decision, and you approve the ones that matter.
Link a cloud account (AWS, GCP, Azure, or DigitalOcean) and GitHub. A guided walkthrough shows you exactly where to click, and every credential is encrypted in a vault.
The Repo Intelligence agent clones your code and detects languages, frameworks, services, ports, and environment variables, then builds a knowledge graph. It understands mono-repos too.
The Architect agent proposes three or four tiers, from hobby to scale. Each one is a concrete topology with clear trade-offs and a realistic monthly cost range. Pick the one that fits.
Your pipeline appears as an editable canvas. Swap an implementation, remove an optional step, or ask the copilot to add ArgoCD between CI and deploy.
Agents write a plan, a compiler checks it against a safety policy, and the engine runs twenty to forty steps with live logs, automatic retries, and honest hand-off cards when a human is genuinely needed.
You get a live dashboard for URLs, SSL, cost, and server health. After that, talk to it: "the site is slow", "add a domain", "rotate this secret". The agents handle it.
The Deployer is not templated. A hierarchical orchestrator hands each phase to a focused agent that reasons over your repository's knowledge graph, and every action is schema-validated, auditable, and safe to resume.
It shallow-clones your repository and runs deterministic detectors over manifests, lockfiles, Dockerfiles, and CI configs. Then a language model adds the semantic layer: what each service is, and how the pieces fit together. The detected facts are ground truth, so the model can enrich them but never overrule them.
It reasons over the knowledge graph, your chosen services, and a maintained pricing dataset to propose three or four tiers. Each one is a real topology rather than a vague suggestion, with the trade-offs stated plainly.
It renders the chosen architecture as an interactive, editable node graph. Every node ships with a sensible open-source default plus swappable alternatives, and the mandatory ones are protected from accidental removal.
It turns the workflow into a structured plan, never raw shell. A deterministic compiler checks that plan against schemas, a command denylist, and your knowledge graph before a single step runs. Intelligence writes the plan; determinism executes it.
Some repositories aren't ready to deploy. The Code Doctor proposes small, reviewable changes (a health endpoint, a leaner Dockerfile, a CI workflow, a /metrics route), commits them to a branch, and updates the knowledge graph. The Env Doctor places your secrets on the services that need them.
When a step fails, an escalation ladder takes over, so a non-engineer can survive real infrastructure. It retries, then diagnoses from the logs, then tries another strategy, and only then asks you for help with clear, numbered instructions.
A copilot for every project, grounded in your live dashboard and knowledge graph. It answers questions, edits the workflow through diffs you confirm, and runs "fix it" flows, with every action recorded in the audit log.
No black boxes. Every service the agents choose is a node you can open, swap, or remove, with curved edges that show how code and data move through your system.
Swipe to pan the board
This isn't a toy. The Deployer sets up the full lifecycle: build, ship, route, observe, secure, and operate, all on open-source tools running in infrastructure you own.
Real provisioning on AWS, GCP, Azure, and DigitalOcean behind one abstraction. Keyless GCP auth, IAM-scoped AWS, DigitalOcean tokens: the agents speak each provider's SDK so you don't have to. The Deployer runs none of your infrastructure, so you keep control and can walk away with everything.
Glibc-safe images, native-dependency detection, a health check that actually compiles, and a recovery agent that fixes, rebuilds, and commits.
Prometheus, Grafana, Loki, node-exporter, and cAdvisor, wired up for you. Real dashboards for any app, plus a /metrics route added on your behalf.
Services roll one at a time. The new container must pass a health check beside the old one before traffic moves, so a broken build can never take your app offline.
Say "set up a new domain" and it creates the hosted zone, detects your registrar, guides the delegation, and verifies it live. Extra domains attach without downtime.
Create a database, cache, queue, or bucket on any provider. An Attachment Doctor reads your code, says whether it fits, then wires encrypted env and redeploys.
Real terminals to your servers and a live environment manager. Read values off the box, edit them, apply with a targeted redeploy. Secrets never leave your infrastructure.
ChatOps isn't a chatbot bolted on. It drives the same validated engine the UI uses. Ask it to add a node, attach a service, diagnose a 500, or explain a log line. Changes appear as diffs you confirm, and everything lands in an audit trail. It's the on-call engineer you didn't have to hire.
Deploying to real infrastructure means holding powerful credentials. The Deployer is built so that power can't leak into a prompt, a log, or a database in the clear.
Every secret is encrypted at rest with Fernet. The master key lives in the environment, never in the database, and API responses reveal only metadata and the last four characters.
Agents and plans carry secret:// references, never the real values. Only the deterministic step runner resolves them, in memory, at the moment of use.
A denylist blocks destructive patterns, and any tool with side effects only produces a proposal that has to pass validation. The step engine executes; it never improvises.
A fresh ed25519 keypair per project, injected at provision time, so your personal keys are never requested. Every side effect is written to an audit log.
Every layer defaults to a self-hostable open-source tool, with vetted alternatives the agents can swap in. No proprietary runtime, no lock-in, and no surprise bill.
The scanner works out the language, the framework, the port your app listens on, and the lock files it pins, then writes the right build and run steps for you. These are the stacks it understands today.
Built with something else? If your repository already has a Dockerfile or a Compose
file, The Deployer will use it. Mono-repos are understood too, and every scan ends with an honest
verdict on whether your project deploys automatically, needs a little input from you, or is not a
fit yet. You see that verdict before you spend anything.
Not a raw cloud console, and not a walled garden. The Deployer gives you both ends at once.
I can build the product all day. It's the VPC, the reverse proxy, and the TLS renewal that used to eat my week. I connected the repo, picked the Startup tier, and it shipped.
We're four engineers and no DevOps hire. I told the chat to add ArgoCD before deploy, it planned the change and showed me a diff to confirm. That's the review step I'd have wanted anyway.
The self-healing won me over. A build failed on a native dependency, and the recovery agent switched the base image, rebuilt, committed the fix, and carried on. That's a senior engineer's afternoon, done automatically.
Composite personas that illustrate the intended experience during private beta.
The Free plan is live today and it's genuinely enough to run a real product. Your cloud provider bills you directly for your own infrastructure. We never mark it up, and we never touch it. Paid plans are being finalized and aren't purchasable yet.
$0/ mo
Ideal for solo developers. Everything you need to get a real app live and keep it running.
No credit card. Your cloud provider bills you directly.
$30/ mo
For small teams shipping together.
Not available yet. We'll announce it here.
Talk to us
For organisations operating many services.
Tell us what you need and we'll get back to you.
Full documentation is public, and no account is needed. Every provider is walked through click by click, and the limits are stated plainly so you know what works before you start.
secret:// handles, never the real values, and a deterministic compiler with a command denylist checks every action before it runs. Every side effect is audited, and we recommend scoped-admin credentials rather than root.Three projects, five services, and five deploys a day, free and with no credit card. You only ever pay your own cloud provider.
Questions about a stack we haven't listed, an enterprise rollout, or something that broke? Send a message and we'll reply by email.