CMOS + DeepSearch — The High-Integrity Delivery Loop

The Problem: The Agent “Fog of War”

As autonomous agents move from simple code assistance to complex, multi-turn engineering tasks, a new problem emerges: visibility. Without a system of record, agent work becomes a “fog of war” for human operators. What was researched? Why was this architectural decision made? Is the mission actually complete or just stopped?

Most project management tools are designed for humans and rely on manual updates. For agents, these tools are just another friction point, leading to a drift between what the agent is doing and what the “official” record says.

The Solution: Mission-Oriented Build Work

CMOS (Context Management Orchestration System) was built to solve this by making the project management system the agent’s primary interface. Instead of an agent working “on” a project, it works “through” CMOS.

By exposing project management as a set of Model Context Protocol (MCP) tools, CMOS turns every status update, decision, and learning into a structured tool call. The result is a high-integrity delivery loop that handles orchestration, memory, and validation in one unified flow.

The Architecture: A Unified Stack

CMOS doesn’t work in isolation. It is the middle layer of a three-part stack that connects research to reality:

1. TraceLab / DeepSearch: The research engine where raw information is synthesized into validated knowledge chunks.
2. Mission Protocol: The authoring layer where ambiguous objectives are decomposed into explicit missions with success criteria.
3. CMOS: The execution engine that manages the mission lifecycle and maintains the “Master Context” of the project.

High-Level Data Flow

graph TD
    A[DeepSearch Research] -->|Validated Reports| B[TraceLab Knowledge Base]
    B -->|Reference Docs| C[Mission Protocol]
    C -->|Structured Missions| D[CMOS SQLite DB]
    D -->|Tool-Driven Execution| E[Agent Implementation]
    E -->|Status / Decisions| D
    D -->|Context Snapshots| F[Project Memory]

The Mission Lifecycle: Queued to Complete

CMOS enforces a strict operational loop for every build mission. This ensures that agents cannot skip critical steps like context onboarding or health checks:

• Onboard: Agent retrieves project identity and active session.
• Status: Agent checks the priority queue for the next mission.
• Start: Mission transitions to In Progress, recording the start event.
• Execute: Work is performed, with major decisions captured as strategic_decisions.
• Complete: Agent logs completion notes and success criteria validation.
• Snapshot: CMOS takes a snapshot of the project memory, preserving the state for future agents.

Why SQLite?

Early versions of CMOS used flat YAML files, but this became a bottleneck as project history grew. We migrated to a SQLite-first model to enable:

• Atomic Operations: No more corrupted YAML files from concurrent agent writes.
• Rich Queries: Humans can run SQL for ad-hoc analytics; agents get structured JSON via MCP.
• Relational Integrity: Missions are tied to sprints, and sessions are tied to missions, providing perfect lineage.

Meaningful Outcomes

• Repeatable Excellence: The “Operational Loop” ensures that every agent—regardless of its underlying model—follows the same high-quality delivery process.
• Auditable Decisions: Every major architectural choice is indexed and searchable, ending the “why did we do this?” search through weeks of chat history.
• Safe Participation: CMOS-MCP provides a sandboxed, tool-based way for agents to interact with project state, reducing the risk of destructive actions.

Lessons Learned

Structure isn’t just for data; it’s for the work itself. By wrapping the build process in a strict protocol, we’ve enabled agents to participate in complex systems with a level of reliability that was previously impossible. The goal isn’t just to automate code generation, but to automate the governance that makes code generation valuable at scale.