Always online.
Unlimited usage.
One flat price.

Standard Code is a coding agent in the cloud with unlimited usage. Like a cell phone plan, you pay for lines of service. Each line on your plan powers one active session at a time.

$5 first week

then

$49/month

per line

Unlimited usage

Early access

Join the waitlist. We'll send you a key when it's your turn.

Already have an access code? Start your $5 1-week trial →

standardcode · ~/app

session 1 of 1unlimited usage

The how

How is unlimited usage possible?

Standard Code is able to offer unlimited usage because of its unique lines-of-service billing model and a novel, curated agent architecture.

01 · Lines of service

One active session per line

Each active Standard Code session occupies a line of service on your plan. Lines of service can be added to your plan at any time if you require additional parallel sessions.

02 · Concurrency, not tokens

Each line is unlimited

For each active line of service on your plan, you can run a Standard Code session with unlimited usage. Usage is constrained by linear time, not token quota.

03 · Preconfigured sub-agents

Standard Code is a swarm of agents

Standard Code is made up of a pre-configured, finely-tuned team of expert agents. Each is automatically invoked as needed, and sub-agents do not count against your active lines of service.

04 · Composable agent architecture

Sub-agents are full agents

Every sub-agent is a specialized domain-specific agent with its own curated prompts, tools, and context. This allows us to tune the agents that make up Standard Code for maximum efficacy per dollar.

Lines of service$294/ mo6 × $49/line

Stop configuring, start building

Two curated cloud agents
built for real-world work.

standardcode · ~/app

❯ migrate our REST layer to tRPC, update every call site, and keep the tests green

✓ code_explorer_agent · 214 files mapped

✓ research_agent · findings delivered

✓ edit src/server/router.ts

✓ edit src/api/client.ts (+412 −380)

✓ update 37 call sites across 22 files

session 1 of 1unlimited usage

CLI
API
Web app
macOS app
iOS app

Always-on cloud coding agent

Unlimited One

Standard Code's default agent leveraging open weight models. The world's first curated coding agent — powered by a coordinating team of domain-specific agents.

A curated collection of domain-specific agents working in concert
Unlimited usage per active session
Sessions run in the cloud and can be resumed from any connected machine
Flat, predictable billing per line of service

Always-on cloud coding agent

Sama One

Standard Code's same domain-specific agent architecture powered by OpenAI models. Uses your existing ChatGPT Pro subscription.

The same novel domain-specific agent architecture
Uses your existing Codex token quotas
Sessions run in the cloud and can be resumed from any connected machine
Does not occupy available lines from your Standard Code plan

Requires at least one active line of service.

Learn more about using Standard Code with OpenAI models

provision.ts — northstar-web

provision.tsstream.tswebhook.ts

const BASE = "https://api.standardcode.ai";
const KEY = process.env.STANDARDCODE_KEY!;
const auth = { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json" };

// one thread per job, resumable from any client
const { threadId } = await fetch(`${BASE}/api/threads`, {
  method: "POST",
  headers: auth,
  body: JSON.stringify({ agent_id: "standard_code_agent", tags: ["ci"] }),
}).then((r) => r.json());

// sending a user message starts the agent's turn
await fetch(`${BASE}/api/threads/${threadId}/messages`, {
  method: "POST",
  headers: auth,
  body: JSON.stringify({ role: "user", content: "Rate-limit the upload route." }),
});

// watch it work
const { ticket } = await fetch(`${BASE}/api/auth/websocket-ticket`, {
  method: "POST",
  headers: auth,
  body: JSON.stringify({ pathname: `/api/threads/${threadId}/stream` }),
}).then((r) => r.json());
const ws = new WebSocket(
  `${BASE.replace("https", "wss")}/api/threads/${threadId}/stream?ticket=${ticket}`,
);
ws.onmessage = (e) => {
  const f = JSON.parse(e.data);
  if (f.type === "message_chunk") process.stdout.write(f.chunk);
};

TypeScriptLn 26, Col 3 · UTF-8 · LF

CLI
API
Web app
macOS app
iOS app

Every client connects
to the same cloud sessions.

How does it work? Take a look behind the scenes

standardcode · ~/app

❯ migrate our REST layer to tRPC, update every call site, and keep the tests green

✓ code_explorer_agent · 214 files mapped

✓ research_agent · findings delivered

✓ edit src/server/router.ts

✓ edit src/api/client.ts (+412 −380)

✓ update 37 call sites across 22 files

session 1 of 1unlimited usage

Standard Code is
always online.

Session state lives
in the cloud.

Sessions executing on an always-on machine, such as a VPS, can continue uninterrupted even if the client you're using to drive the session disconnects.

Every client connects
to the same sessions.

Standard Code ships with first-party native clients for your terminal, the web, macOS, and iOS.

Thread history, queued messages, and even unsent drafts stay synchronized.

Every session has
a full API.

Standard Code exposes the same REST and WebSocket APIs its own clients use. Drive sessions from CI, internal dashboards, or your own product.

Read the API docs

REST

Drive it from code

Create, message, list, and resume sessions from any language over plain HTTP. No SDK required.

POST /threads · GET /threads/:id

WEBSOCKET

Watch it live

Stream tokens, tool steps, and the end-of-turn signal as they happen.

⇅ wss://your-instance/threads/:id/ws

ACCESS KEYS

Hands-off loops

Use a bearer token to run jobs from a push or a schedule.

Authorization: Bearer sk_standard_…

Standard Code knows
how to get work done.

elapsed 0m

◇ goal 0/5 ship dark mode

Audit theme tokens6m

Define dark palette9m

Build the theme toggle4m

Migrate 41 components18m

Run visual regression11m

✓ goal complete · 48m

✓ assets/mark.png · saved to your project

Big asks,
little tasks.

Give Standard Code an outcome. It sets a goal, breaks it into steps, and checks each one off. Unlimited usage keeps it working until the goal is complete.

Every specialist owns
its own context.

Standard Code dispatches subagents for research, codebase exploration, asset creation, and more. Subagent work never crowds your session's context.

Thread compaction
is non-blocking.

Standard Code uses a dedicated subagent to compact long-running threads. Compaction happens in flight and never pauses your session's work.

Batteries (and
asset generation)
included.

Ask for an icon, a hero image, a sprite sheet. The asset subagent creates it, runs its own QA, and places the file into your project.

Also in the box

SKILLS & MCP

Bring your own tools

Install Agent Skills that persist across sessions and connect any MCP server.

FAILOVER

Sessions stay online

When a model provider fails, the session moves to another one mid-run and keeps its thread intact.

PERMISSIONS

Your machines stay yours

Per-tool permission gates mean the agent only ever touches what you allow.

APPROVALS

Approve from anywhere

Permission prompts follow you to whichever client you are watching, so a waiting session never blocks the machine running it.

Try Standard Code
for five dollars.

Your first week

$5then $49/month

Renews at $49/month after 7 days for one line of service. Cancel anytime.

Unlimited usage
Automatic subagents
Resumable cloud sessions
Official first-party clients
Programmable API
Add additional lines anytime
Unlimited One
Sama One

Start your $5 1-week trial

Additional lines available, $49/month each · Secure checkout by Stripe

For enterprise

Get Standard Code for your entire organization.

on our infrastructure

Organization-wide plan

Hosted seats billed centrally: headcount × $49, unlimited usage.

on your infrastructure

Full-stack license

The entire Standard Code stack on your infrastructure with your inference providers and visibility into usage through the Standard Code admin panel.

Standard Code for enterprise

Early access

Join the Standard Code
early access waitlist.

Join the waitlist. We'll send you a key when it's your turn.

By requesting access, you agree to our Terms of Use and Privacy Policy.

Already have a key? Start your $5 week →

Questions while you wait? Join us on Discord →

How is unlimited usage possible?

One active session per line

Each line is unlimited

Standard Code is a swarm of agents

Sub-agents are full agents

Two curated cloud agents built for real-world work.

Unlimited One

Sama One

Every client connectsto the same cloud sessions.

Standard Code isalways online.

Session state livesin the cloud.

Every client connectsto the same sessions.

Every session hasa full API.

Standard Code knowshow to get work done.

Big asks,little tasks.

Every specialist ownsits own context.

Thread compactionis non-blocking.

Batteries (andasset generation)included.

Try Standard Codefor five dollars.

Get Standard Code for your entire organization.

Join the Standard Codeearly access waitlist.

Two curated cloud agents
built for real-world work.

Every client connects
to the same cloud sessions.

Standard Code is
always online.

Session state lives
in the cloud.

Every client connects
to the same sessions.

Every session has
a full API.

Standard Code knows
how to get work done.

Big asks,
little tasks.

Every specialist owns
its own context.

Thread compaction
is non-blocking.

Batteries (and
asset generation)
included.

Try Standard Code
for five dollars.

Join the Standard Code
early access waitlist.