Agent-ready backend code — done for you.
Gutencode is an agent-ready backend spine — auth, billing, tenancy, an AI runtime and 35+ more domains, built identical in Python · Go · Node and shipped with its own one-command verifier. Clone it, run verify.py, build on top.
// the same audited spine, printed in python · go · node…
// …then it proves itself: python verify.py
Get your agent to import the code
It uses AGENT.md + CUSTOMIZE.md to add your features
Save weeks of building — launch faster
built on the standards you already trust — not reinvented
Gutencode implements these specs so you don't have to. Names shown are the standards and tools the spine targets — not endorsements.
The hard parts: Auth, Stripe, AI, Agents & 30+ more — done for you.
35+ audited domains — the parts you'd dread building, already built and battle-shaped. All proven, all in Python · Go · Node.
Auth
world-classSessions, password reset, email verify, token rotation — the part everyone ships subtly broken.
ASVS-shaped · no plaintext · rotate + revoke, ×3
RBAC
world-classDeny-by-default access control that never leaks across roles.
least-privilege, enforced
Tenancy
world-classMulti-tenant isolation — one cross-tenant read and you're on the news.
tenant-scoped rows (models Postgres RLS)
Stripe
world-classPayments where a double-charge or a replay is a refund war.
idempotent per caller · signature-verified
Ledger
Double-entry money movement that has to balance, every time.
debits == credits, proven by exit code
AI Agents
world-classA ReAct agent loop that can't spin forever or fire an unsafe tool.
the loop provably terminates · tool-safe
Idempotency
world-classReplay-safe writes so a retried request never double-acts.
IETF Idempotency-Key · replays are no-ops
Audit Log
world-classTamper-evident evidence for every privileged action.
append-only · tamper-evident
Webhooks
world-classSigned delivery with rotation + replay-dedup (Standard Webhooks).
multi-secret rotation · replay-deduped
every domain in the spine
world-class hardenedIdentity & Access
Money & Billing
AI & Agents
Data & Infrastructure
Reliability & Governance
Build your own Agents — rails included.
A real agent runtime — tools, retrieval, multi-agent orchestration and spend tracking — with the guardrails built in and proven by the same verify.py, across Python, Go & Node.
An agent that reasons, calls tools & remembers
world-classCreate one with a system prompt, give it a session, and run the loop — it thinks, calls your tools, reads the results, and keeps the conversation in memory until it answers. A few endpoints, ready to run.
what you get
Tool Belt
Hand your agent a typed tool belt — it calls them with validated args and gets structured results back. Drop your own in behind the same seam.
RAG + grounding
Feed it your documents — it chunks, embeds and retrieves the right passages, then answers with citations back to the source.
Workflows & crews
Go beyond one agent — chain multi-step workflows and hand off between named agents in a crew.
the rails — what it won't let happen
Bounded
Every loop — agent, workflow, crew — is capped. Nothing spins forever.
Tool-safe
Only registered tools run. A code-injection attempt is a no-op, not an exec.
Spend-metered
Cost is server-derived from a price table — no client-set prices, no double-charge.
Grounded
Citations point to real, in-bounds source text — never fabricated or stale.
Runs and tests fully offline with a deterministic stand-in model — no API keys in CI. Wire AI_PROVIDER to OpenAI or Anthropic for production; every guarantee above holds the same.
Verify & tests built in: green.
A starter that looks finished is easy. One that proves it — and keeps proving it while you and your agent build on top — is the whole point. verify.py is the judge, and it ships in the box.
A guardrail that stays on. Break a guarantee — by hand or by agent — and the build goes red.
// your agent can't merge a regression past a verifier it must keep green.
Every guarantee on the left has a test that runs on your machine — across Python, Go & Node. Green means all of them pass, right now, top to bottom. Not a screenshot. Not our word.
Don't believe us. Run it.
Clone the repo and run python verify.py yourself — green in under a minute, on commodity hardware. That's the only proof that counts.
One behavior. Three languages.
The same audited spine in Python, Go and Node — proven to behave identically. Pick the one your team already runs; the verifier holds all three to the same line.
@router.get("/v1/records")def list_records(ctx: Ctx) -> Page[Record]:# tenant scope is enforced, not optionalrows = store.list(owner=ctx.tenant_id, limit=ctx.limit)return Page(data=rows, next=ctx.cursor)
{"data": [ { "id": "rec_8x2…", "owner": "ten_4a…" } ],"next": "eyJpZCI6InJlY184…"}
Switch the tab — the handler changes, the contract doesn't. That's not something a template or a lucky prompt can fake; it's checked by verify.py on every run.
Read the real handlers// illustrative snippets — the repo ships the audited originals.
Code ready for your agent.
Customize and ship your idea.
Paste one prompt. It clones the spine, proves it's green on your machine, and builds on top.
Set up my backend from Gutencode — an audited, agent-ready backend spine (auth, billing, RBAC, an AI/agent runtime + 30+ more domains, all identical in Python, Go & Node, shipped with their own offline verifier). 1. git clone https://github.com/antonibot/gutencode-test && cd gutencode-test 2. Read AGENT.md (the operating law) and .gutencode/contract.json (the route + test map). 3. Run `python verify.py` and confirm it prints GREEN — the whole backend tests and proves itself. 4. Build my product on top of the green baseline (pick python, go, or node). Ship a test with every change and keep verify.py green.
Point your agent at the repo
Drop the prompt into Claude Code or Cursor. It reads AGENT.md — the operating law — before it touches anything.
It clones it & runs verify.py → GREEN
The whole spine tests and proves itself — suites, invariants, parity and durability — on your machine, not in a demo video.
You build your product on top
Follow CUSTOMIZE.md and ship the 10% that's actually yours. Every change keeps verify.py green.
// it reads AGENT.md + runs verify.py before it builds.
A SaaS Kit a senior dev would sign off on.
One run prints the same Verified backend spine — production-shaped, audited, reproducible in Python, Go & Node — then hands you the keys to the part that's actually yours: the app layer your agent builds on top.
Deterministic + Verified
Dozens of mechanical audit gates plus per-domain conformance checks run before you ever see the code — and it ships its own offline verify.py so you re-prove it yourself. A red is a real, located bug, not a vibe.
The hard domains, proven
Money, identity and multi-tenancy ship invariant-tested: a ledger that proves debits == credits, auth that proves no-plaintext & deny-by-default, an agent loop that provably terminates.
Green baseline on day 1
Not a skeleton with gaps. The spine is 100% working, audited and unit-tested. Your business logic — the app layer (records, your domain rules) — is what you or your agent build on top, against a green baseline. A CUSTOMIZE guide points at the exact lines.
Swappable adapters
LLM keys, queues, payments, storage — all behind ports. Swap providers from .env. No vendor lock-in, fully offline-testable with fake adapters.
One backend, three languages
Idiomatic, parity-matched code in Python, Go & Node — proven to behave identically across all three. The same spec always prints the same code: byte-for-byte reproducible, every time.
Production-shaped
Clean ports-and-adapters folders, RFC 9457 error envelopes, request IDs + structured logs, and durable SQLite via DATABASE_PATH behind a storage port — swap in your production DB. Restart-durable, proven across all three languages.
the catalog (and growing)
What it is — and what it isn't.
Backend Foundation — not a finished app.
it is
- A deterministic, Verified backend spine — 35+ audited domains, 3 languages
- A real GitHub repo you clone, run, and own (MIT)
- Self-proving: one offline `python verify.py` → GREEN
- A green baseline your agent customizes on top of
it is not
- A finished app — the business logic is still yours to add
- Generated bespoke from your prompt — every run prints the same Kit
- Your app layer, done (records + your domain rules = your part)
- A hosted or black-box runtime you rent from us
Free today. Get it now.
No signup, no subscription. Clone the repos while they're free — pricing may change later, but whatever you take is yours to keep. If it saved you a weekend of boilerplate, buy me lunch.
Free
- Watch it print on the site — then read the real repo
- The full output repo: models, schemas, routes, migrations, tests
- All 35+ audited domains (auth, rbac, tenancy, ledger, stripe…)
- Audit-green, unit-tested, durable in Python · Go · Node + a CUSTOMIZE guide
- Your code, your IP — clone it, it's yours to keep
Buy me lunch
support- Priority access to new domains
- Premium templates & bundles
- Your feature requests get built first
- Eternal warm fuzzy feeling ☕