What Encore is, in its own words
Encore’s homepage calls it “Automated Infrastructure for Humans and Agents” and describes “a development platform that lets you deploy apps to your own AWS or Google Cloud without managing infrastructure.” The pitch is “Skip the Terraform handoffs. Go from code to production in minutes” — Encore “replaces Terraform files, infrastructure PRs, and DevOps handoffs with an automated workflow that provisions and validates infrastructure from development through production.” Developers “and agents define the infrastructure a feature needs directly in application code”, and databases, queues and buckets “run locally with the app.” On agents specifically, Encore offers to “Run background agents in cloud sandboxes”: “Each agent gets an isolated environment with your app and infrastructure, running independently of your laptop. Spin up as many as you need and let them work in parallel.” (Source: encore.dev .)
That is a real and well-built product, and the claim is substantially true within its scope. It is also aimed at a different question than Forge is.
Encore automates the infrastructure. Forge runs the team. Those are different halves of the same problem, and the comparison only becomes useful once you say which half you are shopping for.
The difference in one table
| Encore | Forge | |
|---|---|---|
| What you describe | The infrastructure a feature needs, in application code | The team you would have hired, and the process it follows |
| What an agent is | A background worker in a disposable cloud sandbox, spun up per task | A named character with a profession, a memory and a success record that persists across every run |
| How many | “Spin up as many as you need and let them work in parallel” | A standing roster you staff deliberately — the same product manager appears in every run that needs one |
| Who checks the work | You, reviewing the branch the sandbox produced | A management agent on every handoff: pass, send back with enrichment instructions, or escalate to a person |
| What the agent knows next time | The sandbox is destroyed when the branch closes | What it learned about your codebase, your preferences and its own mistakes — written down and carried forward |
| Application code | Written against the Encore.ts or Encore.go SDK | Unchanged — any language, any framework, any Dockerfile |
| Where it deploys | Your AWS or Google Cloud account | AWS, GCP, any Kubernetes cluster, or your own hardware |
| Primary artifact | Provisioned infrastructure in your cloud account | A run branch in your own repository — spec, brief and each role’s handoff as commits — and then a pull request |
| Scope | Backend services | Software delivery, research, content and operations on the same engine |
| Which model runs it | — | A provider pool you control: priority weights, failover, self-hosted models, any OpenAI-compatible endpoint |
Where Forge is different
An agent is somebody, not a sandbox. Encore’s agent story is explicitly disposable: each one gets an isolated environment, works in parallel, and the sandbox is destroyed when the branch closes. Forge went the other way. A Forge character has a name, a profession, a portrait and a voice; it accumulates what it learns while working and keeps it; it earns a track record you can read before you trust it with something bigger. We have run our own company this way since June — thirty-five named characters, one of them a product manager with a 98% success rate, another a marketing agent failing roughly half its work and visibly in need of help. We published both numbers, and why that matters.
Different roles, not one worker going faster. A Forge delivery run is five roles — a product manager who surfaces ambiguity instead of inventing an answer, an architect, a developer, a tester and a reviewer. Between each pair sits a management agent that reads the handoff and decides whether it is good enough to pass on. Parallel agents each produce a branch for you to review; a chain with a supervisor in it stops bad work before it reaches the next role. See Multi-Agent Pipeline .
Nothing to adopt, and nothing to rewrite. Encore’s infrastructure inference is the payoff for writing your services against its SDK. Forge attaches to the repository you already have, in whatever language it is already written in. The infrastructure half is Simple Container — MIT-licensed, YAML-configured, and able to target AWS, GCP, any Kubernetes cluster or on-prem hardware, with no change to your application code.
The reasoning is committed, and it is committed to your remote. Every run gets a branch holding the spec, the original brief, and each persona’s structured and freeform handoff as its own commit. You can read the argument behind a decision, diff a second attempt against the first, or intervene mid-run by committing a corrected handoff yourself. See Git-Backed Audit .
Your hardware and your keys. Self-hosted runners keep execution on your machines, and the routing gateway sends inference to a provider pool you control, with priority weights and automatic failover — including self-hosted models and any OpenAI-compatible endpoint. See Bring Your Own Hardware and Multi-Provider Routing .
The one number a disposable agent cannot report
Spin up ten agents in ten sandboxes and you get ten branches to review. What you do not get is a count of how often the work was sent back before it reached you — because there is nobody in the loop whose job is to send it back. Here is what happens when the reviewer is part of the system.
| Twelve weeks of Forge building Forge | |
|---|---|
| Runs dispatched | 322 |
| Handoffs judged by a management agent | 1216 |
| Sent back to their author for rework | 56 |
| Escalated to a human | 24 |
| Runs where the supervisor stopped at least one handoff | 51 |
| Runs that completed | 215 |
| Runs that failed, escalated or were cancelled | 103 |
| Median wall-clock, dispatch to finished run | 39 minutes |
| Median handoffs per completed run | 5 |
| Pull requests merged, across 7 repositories | 202 |
Where these came from. One workflow — Main Forge SDLC, the one that builds Forge — every run it made in twelve consecutive weeks, counted from the control plane’s own records. Not a sample, not a pilot, not a customer case study we cannot show you.
Forge stopped its own work 80 times. 56 handoffs went back to their author with specific rework instructions; 24 went to a person. One run in six was interrupted by its own supervisor before any human looked at it. That is precisely the review a parallel-sandbox model leaves on your desk — here it is priced at one model call per edge, and counted.
It merged 202 pull requests across 7 repositories in the same period — roughly 17 a week, into the platform you are reading about, with a human performing every merge. Organisation-wide, agent-authored work merged at 773 of 875 opened. Forge is not a demo running beside the product; it is how the product gets built, and these are its commits.
A finished run takes about 39 minutes and 5 handoffs. Median dispatch-to-done — and inside those 39 minutes sit the reviews that stopped 80 pieces of work from reaching the next role in the state they were first written in.
Ask us to walk you through the runs themselves — the branch, the handoff commits, the verdicts that sent work back, and the ones that went to a person.
Which one you want
If the thing standing between you and production is infrastructure — a backend service that needs a database, a queue and a bucket provisioned on AWS or GCP, written fresh in TypeScript or Go — Encore is built precisely for that, and it says so plainly.
If the thing standing between you and shipped work is the team — who writes it, who checks it, what they remember next time, and whether you can read why a decision was made six weeks later — that is the problem Forge was built for, on the codebase you already have, in the language it is already written in.
Sources
- encore.dev — homepage headline, platform description, infrastructure-from-code claim, background-agent sandboxes, preview environments.
- encore.dev/pricing — tier structure and feature gating.
- Forge claims on this page link to the corresponding feature pages , which describe the mechanism in detail. The named-character figures come from our own four-month write-up .