subfloor

subfloor in action — booting and steering a team of AI coding agents

boot · remember · orchestrate

the subfloor browser interface — the team, steered from a control panel

…and the floor grows a window

subfloor

subfloor

The floor you stand on.

Subfloor is the substrate for a persistent team of AI coding agents. Their identities, memories, decisions and plans live in one database — the model sessions are disposable processes booted around that data. Intelligence is rented. Continuity is owned.

02 — your data

Your provider changes. Your harness changes.

Your data doesn't.

Chats, plans, progress — it all lives locally, in one database on your machine. Subfloor boots whichever coding CLI you already pay for, from a declarative adapter per harness. Swap providers mid-project and the team wakes up remembering everything: every decision, every spec, every open blocker.

claudecodexkimiopencodevibe

5 supported harnesses · 1 data layer

Swap the brain, keep the being

Each harness is a JSON adapter — launch flags, hooks, session resume. The agent's identity, memory and mandate live below all of them, untouched.

Local by default

One SQLite database on your host, rebuilt from tracked text. No SaaS, no dial-home. Your agents' memories are files you can back up, diff and own.

One API, token-scoped

Every read and write flows through a localhost memory API where an agent can only ever act as itself. Identity is a secret, not a CLI argument.

03 — two doors, one floor

CLI or browser, working in tandem.

Use whatever interface you like — your provider's harness, or our overlay. Subfloor runs the terminals under the hood either way, and both doors open onto the same data. The work doesn't change; the way you work does. Never lose track of a chat, a feature, a spec, or a doc again.

The terminal

sc boot drops you into a live session with any agent — claude, codex, kimi, whatever that shell runs. sc run fires headless units of work. Muscle memory intact.

The overlay

The same sessions, visible from the browser. Start a chat from the UI and subfloor spawns the terminal behind it — exact session resume, durable history, nothing stranded in a scrollback buffer.

04 — the browser

Progress, compartmentalized.

An install and a team per repo. Chats segmented by agent — each shell keeps its own conversations, its own context, its own lane. And between the lanes, a common data layer ties the team together, so the person and the agents that support them are always on the same page.

Flags — blockers

Anything that stalls the work becomes a flag, linked to the roadmap feature it blocks. Open flags surface on every boot; resolved ones record how.

Specs — objectives

Plans live as documents owned by the database, not scattered markdown. The team plans against them, builds against them, reviews against them.

Docs — shipped features

When work ships, its document freezes. What shipped, when, and why is a query, not an archaeology dig through chat history.

doctrine

01

The DB is the agent.

02

The session is disposable.

03

Doctrine lives in triggers, not prompts.

what the floor carries

An agent organization, as a database application.

Persistent identity

Shells: named agents with roles, mandates and seed values that survive every session. The process dies; the self persists.

Memory as a database

All memory lives in SQLite with real integrity constraints. Caps and legal transitions are enforced by triggers — not by prompt promises.

Harness agnostic

Boots claude, codex, kimi, opencode or vibe from declarative JSON adapters. Swap the brain, keep the being.

Governance in code

Branch guards, planner-only writes, boards of record — enforced by git hooks and SQL, not team etiquette.

Sprint orchestration

A deterministic conductor runs multi-agent sprints over git PRs: plan, build, review, reconcile — agents emit events, code decides.

Bare metal first

One host, one repo, a localhost API and control panel. No SaaS, no dial-home. The floor is yours.