Your agent decides what to build. Apso decides how.
Turn a schema into a production-ready backend with REST API, auth, migrations, and AWS deployment for TypeScript, Python, and Golang backends. Deterministic output every time, on any model. You own every line.
- Ship a production API in minutes, not weeks
- Same schema, same output, every run, on any model
- TypeScript, Python, and Golang backends
- Own every line with no vendor lock-in
Open-source CLI. Apache-2.0 templates. Free tier forever.
The Problem
Agent-authored backends drift every time the model changes
Most AI coding tools let a model write your backend directly. The output varies with the model, the prompt, and the day. Two services built a week apart follow different patterns. Auditing means reading thousands of lines the agent chose to write. When the model upgrades, your guardrails silently change.
Apso works differently. The agent translates intent into an .apsorc schema. The CLI deterministically generates a production-ready backend with auth, multi-tenancy, and validation baked in. Guardrails live in the generator, not the prompt. Same schema, same output, every time, on any model.
Two Approaches
One lets the model write your code. The other gives it guardrails.
Agent-authored code is only as consistent as the model, on that day, with that prompt. Agent-driven code is deterministic by construction.
Agent-Authored
The model writes your backend directly
- Output varies with the model, the prompt, and the day
- Two services built a week apart follow different patterns
- Guardrails depend on prompt engineering, not code
- Model upgrades silently change your backend's behavior
Agent-Driven
The Apso approach
- Deterministic output from a schema, every time
- Every service follows identical, auditable patterns
- Guardrails are baked into the generator, not the prompt
- Model upgrades do not change your backend's behavior
What You Get
Production guardrails that no agent can weaken
Auth, multi-tenancy, migrations, and deployment infrastructure are baked into the generator. They ship correctly every time, regardless of the model.
Same Output Every Time
Same schema produces identical output on every run, regardless of which model or agent drove it. Prompt drift does not decide the backend structure. The output is reproducible today, next month, or two years from now.
Works With Any Agent
The built-in MCP server lets Claude Code, Cursor, Copilot, or any MCP-capable editor discover and drive Apso. The agent calls the CLI. The CLI enforces the guardrails.
Your Language, Your Backend
Pick TypeScript, Python, or Golang. Get production-grade code in the language your team already knows, without a proprietary runtime or vendor SDK in the output.
Auth and Multi-tenancy Built In
BetterAuth integration with tenant scoping enforced at the repository layer. Row-level isolation by construction, not by convention. No security afterthoughts.
Own Every Line You Ship
You get real source code in your repo. The generated service has no Apso imports or vendor SDK wrapping your logic. It compiles, runs, and deploys with or without Apso.
Regenerate Without Breaking Custom Code
Generated code lives in autogen/ and is rewritten on every run. Your business logic lives in extensions/ and is never touched. Regenerate safely, as many times as you want.
Deploy in One Command, Eject Anytime
Ship to managed AWS infrastructure with a single command. Eject to your own AWS, GCP, or Azure whenever you outgrow managed hosting. No rewrite required.
Review a Spec Diff, Not a Code Diff
The .apsorc file is version-controlled, human-readable, and machine-writable. Review a 20-line spec change instead of a 4,000-line generated code diff.
How It Works
Schema to deployed API in three steps
Run each step yourself or let an AI agent handle it through the MCP server. The result is the same either way.
Define Your Schema
Describe your backend in a single .apsorc file, or let an AI agent generate it from a conversation. Entities, relationships, auth rules, and validation constraints collapse into one reviewable, version-controlled spec.
- Declare your entire data model in one file
- Review a 20-line spec diff instead of a 4,000-line code diff
- Any MCP-capable agent can generate and validate the schema
- Version-controlled alongside your application code
Generate a Production Backend
Run the CLI or let your agent call it through the MCP server. The deterministic generator produces a complete backend with API endpoints, database migrations, authentication, and validation in the language your team knows.
- TypeScript, Python, or Golang backend output from the same schema
- Generated code lives in autogen/, your logic lives in extensions/
- Regenerate at any time without losing custom work
- Output is identical regardless of which model drove it
Ship to Production
Deploy to managed AWS infrastructure in one command. When you outgrow managed hosting, eject to your own cloud without an Apso runtime, a rewrite, or lock-in.
- One-command deploy to Lambda, RDS, and API Gateway
- Eject to your own AWS, GCP, or Azure account anytime
- Generated code has no proprietary imports or vendor SDK
- Apache-2.0 licensed templates you own and control
See the Output
A complete REST API from 30 lines of schema
This is a real Apso-generated backend. The .apsorc schema on the left defines entities, relationships, and auth rules. The CLI produces the full API on the right: endpoints, database migrations, validation, tenant scoping, and deployment config.
Every line of the generated code is standard TypeScript backend code that compiles and runs independently. It has no Apso SDK or vendor import, and you own it.
Try It Free
REST routes
Auth guards
RDS deploy
Stop rebuilding backends from scratch
Define a schema. Generate a TypeScript, Python, or Golang backend. Deploy to AWS. Own every line and start building for free with the open-source CLI.
Start without a credit card, keep the code, and use Apache-2.0 licensed templates.