You hand over a clear brief
Scope is understood on both sides.
Agent Operating System · v4.2
Ship at AI speed.
Without the AI mess.
An operating contract that turns any AI coding agent into a governed delivery team — it plans before it builds, it cannot touch your source without your approval, and it remembers every decision across every session.
src/ locked
0project tiers, one contract
0mechanical approval gates
0files carry the whole project
The problem
AI doesn't fail loudly. It drifts quietly.
One unspoken assumption in week two becomes an architecture you can't unpick in week nine.
The agent hits an ambiguity
It doesn't stop to ask. It picks.
The guess becomes structure
Later code is written to fit the guess.
The defect ships — and scales
Now it is load-bearing across the repo.
Mid-build drift
It changes direction halfway and never says so.
Session amnesia
New chat, new interpretation of the same product.
Invisible progress
Nobody can tell what changed, or why it changed.
Growing blast radius
The smaller the repo, the better the bug hides.
A bug found across 10 files costs an afternoon. The same bug across 500 files costs a release.
The market's answer
The industry fixed drift by documenting everything.
It works — right up until context bloat turns every small feature into a token invoice.
Docs-first, always-on
A full specification set is generated up front — then re-read, session after session.
Context grows with the repo
Every turn pays to reload pages that had nothing to do with the task.
Teams throttle their own guardrails
When the bill lands the process gets switched off — and the drift comes straight back.
Our answer
- Only the documents that change a decision
- Live memory capped at ~100 lines, older facts indexed
- Context loaded by phase, never the whole spec
The operating model
One controlled lifecycle, idea to release.
Each phase produces exactly the input and the control the next phase needs. Nothing is improvised per session.
- 01
Requirements
Define the problem before anything gets built.
- 02
Tier
Match the depth of process to the real risk.
- 03
Clarify
Every assumption surfaced, each with a recommendation.
- 04
Blueprint
Architecture, contracts and delivery phases, scoped to the tier.
- 05
ApproveHITL-0
You unlock the source. Nothing proceeds without it.
- 06
Decompose
Small dependency-aware T-XXX tasks.
- 07
Build
One task at a time, inside the locked architecture.
- 08
Verify
Reviewed, then tested to the depth the tier demands.
Persistent layer
Written at every phase. Read at every restart.
memory.mdDurable decisions, preferences, fixes
progress.mdPending, active, blocked, done
Enforcement
The gate is not a guideline. It is a lock.
Approval is wired into the tool layer and the git layer — the agent cannot talk its way around either one.
13 automated test cases prove the gates. Both hooks are fail-open by design — enforcement can never brick a live session.
HITL-0 · Plan
src/ stays locked until you create the approval marker. This is the gate that ends drift.
HITL-1 · Schema
Entities, indexes, migration order and destructive changes reviewed before anything runs.
HITL-2 · Release
Coverage, threat-model and secrets evidence presented before deployment is allowed.
Context engineering
A project brain that never fills up.
Live memory stays deliberately small. History stays reachable — retrieved by pointer, never re-read whole.
memory.mdlive · 0 / 100 lines
auto-archive once live memory passes ~100 lines
memory-archive.mdmapped history
0 entries indexed
Resolved entries move here, indexed so the agent pulls the one fact it needs — not the file that fact lives in.
Every session restarts like this
01
A cold session opens
No chat history. No context. No assumptions carried over.
02
Reads memory.md
What must still be true about this product?
03
Reads progress.md
Where exactly did the work stop, and what is blocked?
04
Loads only the current phase
Not the whole specification — just the section in play.
It resumes the exact task — no codebase re-scan, no re-briefing, no token tax.
Team scale
Your AI briefs their AI.
The expensive handoff on an AI team isn't developer to developer any more. It's agent to agent.
Developer A
Ships the payments module on Monday.
Developer B
Pulls on Tuesday, opens a fresh agent.
QA / Reviewer
Joins Thursday, has never seen the repo.
Shared project truth
memory.md + progress.md
Committed with the code. Every teammate's agent boots from the same two files — same decisions, same active task, same blockers.
Same context, any machine
A teammate's agent starts where yours stopped.
Zero-meeting handoffs
The status call is replaced by a file that is always current.
Onboarding is two files
New joiners — and their agents — are useful on day one.
Right-sized rigor
Process scales with risk. Quality never scales down.
Four additive tiers. Pick Small and you drop paperwork — never code quality, memory discipline, or the approval gate.
Demo
A clickable client preview.
Pick when you need to show a flow, not run a business on it.
PlanOne demo brief
TestClick-through check
GatesQuick screen sign-off
DataMock data, no database
Invariant core — always on
code quality·memory discipline· context management·plain-language communication·HITL-0 approvalThe quality engine
It reviews and tests its own work before you see it.
Build, Review and Test are separate responsibilities with different questions — so the agent can never sign off on itself.
Build
Did we implement the requirement?
Writes only the active task, inside the locked architecture and design tokens.
Review
Did we implement it the right way?
Checks scope, architecture boundaries, secrets, accessibility and traceability to the plan.
Test
Does it behave correctly and safely?
Owns an isolated test workspace and runs the depth your tier demands.
AgentShield
- Coverage gates on domain and infrastructure
- Transaction-isolated database tests
- Malicious-input fuzzing: XSS, SQLi, type mutation
- Contract tests, a11y audits, visual regression
Taste Engine
- Explores 2–3 genuinely different directions
- Locks colour, type, spacing, one signature element
- Builds, then critiques its own result
- Screenshots the real render and fixes what it sees
The control room
Watch it work. Steer it live.
A native dashboard that watches the project folder — the full backlog, the one task actually in progress, every tool call as it happens, and the approval gates, all on one screen. No terminal required.
Pending 3
In progress 1
the hook blocks any src/ write unless a task sits here
Blocked 1
Done 3
Live activity events.jsonl
Approval requested
HITL-1 · database schema6 entities · 3 indexes · 1 destructive change
A board that cannot go stale
Task state is written at three points by the agent itself, and a hook refuses source edits when nothing is marked in progress.
Every tool call, as it happens
One JSON line per action appended to events.jsonl. Events accumulate while the dashboard is closed and replay when it opens.
Approve or push back, in place
Plan, schema and release gates surface as requests you answer from the dashboard — no marker files by hand.
Read the diff before you say yes
Proposed changes, several agent sessions side by side, and a plain-language summary of what each one did.
Windows app, launched with npx @agilecrafts/agent-os-dashboard. Binds to 127.0.0.1 with a per-project token — nothing is exposed to the network.
Ready when you are
Speed with control. Continuity with visibility.
Drop it into a repo, add your requirements, and watch a governed agent plan, ask, wait for you, build, and prove its work.