The Project OS: your project's live, governed state

The Project OS is the governed state of your project — your PRD, plan, board truth, and the rules your agent follows while it works. Many machines share one board, so work stays current without being picked up twice.

Your agent reads it live through Connect. An independent gate writes done, and every finished card leaves a receipt anyone can read.

The governed state your agent reads from is made up of:

• Your PRD — the requirements, as they stand right now
• Your plan — the execution plan and the tasks it breaks into
• Board truth — what's moving, what's waiting on review, what's done
• Governance rules — the standards your agent follows: roles, task sizing, review gates
• The decision trail — what was planned, what shipped, and why

None of it is a snapshot. It's the same state your agent reads the moment it connects.

The Project OS does not contain:

• Source code, application code, or generated code
• Dependencies, packages, or lock files
• Infrastructure configuration (Terraform, Docker, CI/CD)
• Secrets, credentials, or environment variables
• Third-party libraries or frameworks

It structures how the work gets directed — not what gets built.

The governance rules are the standards your agent follows whenever it picks up work. They cover:

• Role definitions and authority — who (or what) decides what
• Task workflow — how work gets broken down and handed off
• Session continuity — how context survives between sessions
• Review and evidence requirements — what "checked before it counts" means in practice
• Code and quality standards

They're version-pinned, and your agent reads them through Connect — not a file you hand-configure.

A handful of tunables control how work gets sized and reviewed:

• maxFiles — the maximum files a single task can touch
• maxDependencies — dependency limit per task
• enforcementMode — warn (advisory) or block (hard stop)

These are what keep each piece of work small, reviewable, and auditable — not a leap of faith.

The board's Connect button prints this line with your own token and project filled in:

Paste it in a terminal in your repo. Your own Claude Code or Codex agent then works cards through 10xs on your own subscription.

Yes. The governance rules that ship by default cover most projects, but you can adjust them from the board:

• Project context — name, stack, the basics your agent needs up front
• Base branch — your default branch for feature work
• Custom rules — project-specific standards on top of the defaults

Changes take effect immediately — your agent reads the updated rules live, the next time it connects. There's no separate adapter file to keep current.

Yes. Bring your own Claude Code or Codex agent. The board's Connect button gives it the line that works cards through 10xs on your own subscription.

The gate is an independent check between completed work and done. It reads the execution contract and evidence, applies the project's rules, and writes done only when they pass.

The receipt is the readable record left when a card finishes: what was planned, what your agent delivered, what the gate checked, and why the card reached done.

Done means the gate — not your agent — checked the work against its contract, wrote done, and left a receipt anyone can read. A completion claim on its own is not done.

Before your agent starts a task, an execution contract binds it to the rules: scope, file limits, dependencies, and required evidence — locked in before work begins.

When the task finishes, the gate checks that work against the contract it started with. The gate writes done only after the rules are met and the receipt records the result.

It's what makes handing work off auditable: what was planned, what was delivered, and whether the rules were met.

The gate evaluates completed work against its execution contract — file limits, dependencies, evidence, and rule compliance — and returns one of three states:

• Pass — every rule met, ready to be approved
• Warn — an advisory limit was exceeded, worth a look
• Fail — a hard limit was exceeded, the task can't proceed

Only the gate writes done, and it leaves a receipt anyone can read. The enforcement mode decides whether a violation is a warning or a hard stop.

Yes, at two levels:

• Governance overrides — adjust enforcement mode, file limits, or dependency limits for your project
• Local decisions — record project-specific calls that sit alongside the default rules, without editing them directly

The default rules stay version-pinned and update on their own. You're always the one deciding how tight the leash is — that decision doesn't get automated away.

The board keeps a running history of your project's work: session context, completion receipts with evidence, and the execution contracts each task was bound to.

It's a receipt anyone can read — what was planned, what was delivered, and what the gate checked before it wrote done.

Export is paused, so connect your agent to read these pieces live from the board.

No. Your agent reads the board live through Connect — nothing to place, copy, or keep in sync by hand.