Technical deep dive

Why Shogo agents ship working software.

Most coding agents spend their tokens — and your money — writing CRUD handlers, route files, and TypeScript types. Shogo doesn't. You describe your data once in Prisma, and the platform scaffolds a fully type-checked Hono server, a typed client, and live REST endpoints. The agent is left to do what only an agent can: write the UI and the business logic.

FastCheapDeterministicType-checked end-to-endOpen source
The core design decision

Your data model is the source of truth.

You write Prisma. Shogo writes the server. The agent writes what only an agent can — the UI, the workflows, and the rules that make the product yours.

Fast

Skip the boilerplate, ship the feature

Every model in your Prisma schema becomes a full set of Hono CRUD routes, types, and a typed API client — generated, not prompted. The agent moves straight to UI and business rules.

Cheap

Tokens go to logic, not REST handlers

By cutting the LLM out of the boilerplate loop, an entire class of repetitive output disappears. A sub-agent model router picks the cheapest model that can handle each task in under a millisecond.

Deterministic

Type-checked, schema-validated, lint-gated

Generated code is type-checked by the TypeScript compiler. Every tool call the agent makes is validated against a TypeBox/AJV schema. The build loop fails fast — and the agent fixes the error before it ships.

“Edit prisma/schema.prisma — this is the source of truth for all models. NEVER manually create route files.”

Shogo agent system prompt · packages/agent-runtime/src/code-agent-prompt.ts

How it works under the hood

One schema in. A full type-checked stack out.

shogo generate parses your prisma/schema.prisma via the Prisma DMMF and emits a complete backend surface — every artifact below is regenerated whenever the schema changes.

prisma/schema.prisma
shogo generate
routes · types · client · server
live /api/<model> CRUD
you write
prisma
// prisma/schema.prisma
model Todo {
  id        String   @id @default(cuid())
  title     String
  completed Boolean  @default(false)
  priority  Int      @default(0)
  userId    String
  createdAt DateTime @default(now())
}
shogo generates
tsx
// src/App.tsx — using the generated typed client
import { api } from './generated/api-client'

const open = await api.todos.list({
  where: { completed: false },
  limit: 20,
})

const todo = await api.todos.create({
  title: 'Ship the new dashboard',
  priority: 1,
})

await api.todos.update(todo.id, { completed: true })

Generated for you, every regen

  • src/generated/<model>.routes.tsx

    Hono CRUD per model

  • src/generated/types.tsx

    TypeScript types from DMMF

  • src/generated/api-client.tsx

    Typed browser-safe client

  • src/generated/server.tsx

    Hono entrypoint + auth wiring

  • src/generated/prisma/*

    Prisma client

  • src/generated/stores/*

    Optional MobX / MST stores

scaffolded, off-limits to the agent
comment
// src/generated/*.routes.tsx
// Auto-generated by `shogo generate` — do not edit.
// Every model gets list / get / create / update / delete
// wired to Prisma. The agent never writes these handlers.

The Shogo platform itself is generated by the same pipeline — routes into apps/api/src/generated/, MST stores into packages/domain-stores/src/.

The Shogo SDK

One client. Auth, db, LLM, voice, machines.

createClient() returns a single, typed handle to everything Shogo knows about — and works the same in the browser, Node, Bun, and React Native.

client.auth

Better Auth, wired up

Email/password, OAuth, and sessions. Sign up, sign in, get-current-user, listen to auth state changes — same surface in the browser, Node, Bun, and React Native.

client.db

Prisma where you want it

Server-side: a direct pass-through to your Prisma client. Browser-side: a generated typed REST client with MongoDB-style filters, ordering, and pagination over the scaffolded routes.

client.llm

One key. Every model.

A drop-in Vercel AI SDK provider. Routes Anthropic, OpenAI, Google, and xAI behind a single Shogo API key. Tool calls, streaming, and structured output all flow through one base URL.

client.machines

Run on your hardware

Pin a project to a paired desktop or self-hosted worker. External triggers — Jira webhooks, Zaps, cron — relay through Shogo and run the agent on your VPS without exposing an inbound port.

client.projects

Cloud ↔ local sync

Pull a workspace down, edit it, push it back. Atomic, no AWS credentials required, and the agent-runtime reuses the same transport for auto-pull on paired machines.

Memory

Sub-10ms, no vector DB

Per-user markdown facts indexed with SQLite FTS5 + in-process TF-IDF. Retrieval runs in single-digit milliseconds. Optional LLM summariser de-duplicates and resolves conflicts across calls.

createClient + streamText
ts
import { createClient } from '@shogo-ai/sdk'
import { streamText } from 'ai'

const shogo = createClient({
  apiUrl: 'https://api.your-app.com',
  db: prisma,
  shogoApiKey: process.env.SHOGO_API_KEY!,
})

const result = streamText({
  model: shogo.llm!('claude-sonnet-4-5'),
  prompt: 'Summarise this week\'s pipeline movement.',
})

for await (const chunk of result.textStream) {
  process.stdout.write(chunk)
}
Self-evolving in practice

Schema in. Live routes out. Always.

When the agent edits the schema, the runtime regenerates and restarts before the next tool call returns. There is no “run a migration” step the LLM can forget.

1

Agent edits prisma/schema.prisma

Adds a model, a field, or a relation. The schema is the only thing the agent ever touches in the data layer — generated files are off-limits.

2

PreviewManager debounces and regenerates

A file watcher on prisma/schema.prisma fires shogo generate (Prisma DMMF → routes, types, client), then prisma db push (dev) or migrate (prod). All in a few hundred milliseconds.

3

Hono server hot-restarts; UI sees live routes

server.tsx reloads with the new endpoints. The tool response hands the agent the active route list and flags any UI fetch() calls that no longer map to a real endpoint.

Orphan detection. After every schema edit, the tool response scans your UI for fetch('/api/...') calls that no longer point at a real endpoint — so a renamed model surfaces immediately, not at runtime.

Engineered for cost and speed

Every token has to earn its place.

The agent runtime is tuned for predictable cost and latency before the model is ever invoked.

Sub-agent model router

<1 ms

When the main agent spawns a sub-agent, a heuristic router picks the cheapest model capable of the task — no extra LLM call, no extra latency. Routine searches don't pay frontier-model prices.

Microcompact compression

0 API calls

Long contexts are compressed with pure head/tail string manipulation — zero token spend on a summariser. The model still sees what it needs without re-paying for every prior turn.

Prompt-cache stability

~3.5× savings

A prefix fingerprint guards the cached prompt boundary. Unstable prefixes can blow cache and 3.5× your cost; the agent loop detects drift and warns before the next call goes out.

TypeBox + AJV tool validation

Schema-checked

Every tool call is validated against its schema before it executes. The model can't hallucinate a tool that doesn't exist, and arguments are rejected before they hit your code.

Benchmarks & evals

Honest numbers, not headlines.

We publish the artifacts we've actually graded. Everything else is in flight.

Preliminary results — dev subset

SWE-bench Lite — dev split, 23-instance internal subset

shogo-haiku-v1

Claude Haiku 4.5

13.0%

3 / 23 resolved

shogo-gpt54mini-v3

GPT-5.4-mini

43.5%

10 / 23 resolved

Graded with: Official SWE-bench harness (schema_version: 2)

Source: shogo-ai/sb-cli-reports/ · May 2026

Full SWE-bench Lite (300) and SWE-Bench Verified runs are in progress. We publish only complete, graded artifacts — no cherry-picking, no estimated scores.

How we evaluate

  • 1,900+ internal eval cases across 40+ tracks (canvas, coding, sub-agents, MCP, persona, adversarial).
  • Criterion-scored intention + execution phases with token, cost, and wall-time metrics per run.
  • External harnesses for SWE-bench (Lite / Full / Pro), GAIA, Terminal-Bench 2.0, WebArena, Tau2-bench, FeatureBench, FRAMES, and Aider Polyglot.
  • Token-budget regression guards — first-turn baseline ~12,500 tokens, ceiling 16,000, floor 5,000.
  • Self-improving GAIA loop with checkpoint persistence — the agent writes new skills and the run picks up where the last one left off.
  • DSPy-based prompt optimisation against meta-metrics (tool efficiency, latency, cost).

We don't publish head-to-head comparisons against Claude Code, Cursor, Codex, Devin, or Aider yet. When we do, the artifacts and replication recipes will ship alongside the numbers.

Open source & ownership

Built in the open. Yours to fork.

Every layer of Shogo is in a public monorepo. Client and library packages ship MIT; the platform itself is AGPL — so anything you build with the SDK is yours, unencumbered.

MIT-licensed — use anywhere

  • @shogo-ai/sdkClient SDK + `shogo generate` codegen + CLI
  • @shogo-ai/coreLogger, OTEL, stream-buffer, chat-message, tech-stack registry
  • @shogo-ai/agentrunAgentLoop, model router, hooks, pi-ai adapter
  • @shogo-ai/dbPrisma adapter — PG / SQLite / libSQL auto-detect
  • @shogo-ai/emailTransactional email — SES / SMTP / OCI
  • @shogo-ai/voiceElevenLabs + Twilio + React/RN UI
  • @shogo-ai/cliDeploy, manifest, packager helpers
  • domain-stores / ui-kitMobX/MST stores generated from Prisma + shared UI

AGPL platform — self-host, fork, audit

  • apps/apiHono API server — auth, billing, runtime orchestration
  • packages/agent-runtimeAgent gateway, tools, PreviewManager, integrations
  • packages/shared-runtimeServer glue — s3-sync, LSP, server framework
Fork the runtime and the agents. Self-host the API, the gateway, the database, and the storage.
The software your agents build is yours — code, data, infrastructure. No SaaS lock-in, no vendor roadmap.
Run on your VPS, your desktop, or Shogo Cloud — the same SDK, the same agent, the same artifacts.
Explore the open source repo

Build the system you imagine.

Let it evolve with Shogo.

Talk to Shogo. It creates the apps and systems you need, lives inside them, and keeps making them better.

Download Shogo

Available on: Windows, Mac (Apple silicon), Intel Mac or visit all releases