Your agent says it's done. Are you ready to own it in production?
Owning it means understanding it. Reboot is the framework that lets you actually review what your agent builds: you work at the level of your domain model, and your app's behaviors are plain sentences that run as tests.
-
curl -fsSL https://reboot.dev/install.sh | bashWorks with Claude Code and Codex.
-
“Build me a bank where customers open accounts, deposit, withdraw, transfer between them, and earn interest.”
-
Reboot's developer dashboard updates as the agent writes. Types and methods appear first, then the calls between them.
-
Overdrafts are refused becomes a test that runs against the same methods your app runs in production.
Open source under Apache 2.0.
Why agent-written code fails
Your agents build the happy path. Production runs every path.
Your agent has written more code than you can review. It started from a clean spec, but got fragmented across databases, ORMs, queues, caches, lambdas, workflow engines, and services. Along the way, the agent invented its own concurrency, transactions, retries, and recovery, the kind of code whose bugs only show up in production. Checking its work now means reverse-engineering the domain model from source code.
The agent wrote it, but you are responsible for it.
- REST handler
POST /accounts/ {id}/ deposit - ORM model
class Account(Base) - Postgres table
accounts - Redis cache
balance:{id} - Kafka topic
account.deposited - Temporal workflow
TransferWorkflow
state balance number, never below zero
-
openfactory writer -
balancereader -
depositwriter -
withdrawwriter -
interestwriter
Spec-driven development without drift
With Reboot, the domain model is the application.
The domain stays visible. Named types such as Account,
Customer, and Bank remain the domain you
review and the application Reboot runs.
The dashboard shows those types, their behaviors, and their call graph, as implemented in the code. It is not a separate specification that can drift; it is the application running in production.
-
Visible
Read from your code: every type, every method, and who calls whom. It can't drift, because it isn't a copy.
-
Reviewable
Review the application at the level you designed it. You see that
transfercallsdepositandwithdrawwithout opening a file. -
Enforceable
Behaviors are sentences that run as tests. The dashboard shows which methods each one covers, and which methods nothing covers.
Behaviors in plain sentences
Write the rule in English. Reboot runs it as a test.
You describe what your app should do in plain sentences, built from your domain model's own nouns and verbs. Each one runs as a test against the same methods your app runs in production, so the words and the code cannot drift apart. And because Reboot handles durability, retries, and failures, passing the test means the feature works: there is no second layer of plumbing to verify.
You get to focus on the parts that matter: rules and behaviors — the decisions that affect your customers and your business.
The rule said a deposit is positive. The code let −50 through.
async def deposit( self, context: WriterContext, request: Account.DepositRequest,) -> None: if request.amount <= 0: raise Account.DepositAborted( NonPositiveAmountError(amount=request.amount) ) self.state.balance += request.amountThe deposit method checks the amount before touching state and aborts with a declared error.
Now the rule is enforced, and every run proves it.
Built in, not generated
Reboot handles the rest of the backend.
-
When a method returns, its state is saved. No database to set up, no cache, no queue.
-
Change state across multiple domain objects atomically, even when they run on different machines in production. All of it commits or none of it does.
-
Long-running work resumes where it failed. Finished steps are remembered, not re-run.
-
Generated React hooks re-render when backend state changes. No polling. And it is built into Reboot, so it is never code your agent has to rebuild or you have to review.
-
Reboot Cloud spreads your app across as many machines as it needs, automatically. Even though you are building at the level of domain objects, your app runs as scalable microservices in production.
Python backends today. TypeScript backends are in alpha.
One source of truth
The model is the code, all the way down.
What you see in the dashboard is what exists in your API; there is nothing to keep in sync. And the code is there if you need to take a closer look.
01 The Account card, in the model view
- open factory writer
- balance reader
- deposit writer
- withdraw writer
- interest writer
02 The Account state type, declared in Pydantic
class AccountState(Model):
balance: float = Field(
tag=1,
description="What the account holds, in dollars, and never below zero.",
)
api = API(
Account=Type(
state=AccountState,
methods=Methods(
deposit=Writer(
request=DepositRequest,
response=None,
errors=[NonPositiveAmountError],
mcp=Tool(),
),
withdraw=withdraw,
balance=balance,
),
description="One customer's money, in one account.",
),
)03 The deposit method, as implemented
async def deposit(
self,
context: WriterContext,
request: Account.DepositRequest,
) -> None:
if request.amount <= 0:
raise Account.DepositAborted(
NonPositiveAmountError(amount=request.amount)
)
self.state.balance += request.amountOne backend to serve every user — human or machine.
Build anything with Reboot: a web app, a mobile app, MCP tools an agent can call, and MCP apps that can render UIs inside ChatGPT and Claude.
Run agents within your app too: no need for a separate framework!
The class of bugs that is even possible is just dramatically smaller.
Get started
Reboot is open source under Apache 2.0. Run it on your own servers or on Reboot Cloud.
curl -fsSL https://reboot.dev/install.sh | bash