한국어 | English

What AGS Is — and Is Not

One-Sentence Definition

Agent Governance Suite is a governance layer for operating multiple AI sessions as accountable collaborators across long-running work, not merely a framework for spawning agents.

The Primary Unit Is Not "Number of Agents"

The central question in AGS is not how many agents were created.

The important questions are operational:

• Who owns a given goal or scope?
• Which session currently holds the relevant context?
• What information or evidence was transferred between sessions?
• Was a message sent, delivered, acknowledged, and acted upon?
• Was completion evaluated against current artifacts?
• Did an independent reviewer verify the result?
• Can interrupted work be resumed without losing the task frame?
• Can failure and recovery be traced without rewriting history?

AGS is built to make these questions explicit and inspectable.

How This Differs from a Subagent Framework

A typical subagent model centers on a parent execution that delegates work downward and gathers results back upward.

AGS can use that model, but it is not constrained by it.

Sessions can operate as peers with separate execution contexts and separate accumulated context.

For example:

Lead session
 ├── Implementation session (Codex)
 ├── Database / research session (Claude Code)
 └── Independent audit session

The database specialist can send a newly discovered constraint directly to the implementation session. The implementation session can evaluate that constraint against its own existing code context. The auditor can inspect the resulting change from a separate context and return findings to either the implementer or the lead.

The defining structure is therefore not the parent-child tree itself. It is the combination of:

• distinct responsibility,
• independent context,
• direct session-to-session communication,
• explicit evidence,
• audit separation,
• and recoverable task state.

How This Differs from a Plain Orchestrator

An orchestrator typically decides which tool, model, or agent should run next and how outputs should be chained.

AGS includes an orchestrator, but the system is broader than orchestration.

AGS also covers:

• task scope and completion criteria,
• specialist capability selection,
• responsibility boundaries,
• session discovery,
• inter-session messaging,
• ACK versus actual work completion,
• host execution observation,
• stage-level state recording,
• independent audit,
• blocker diagnosis and recovery handoff,
• long-running context continuity,
• SQLite-backed workflow state,
• and retention / cleanup policy.

The orchestrator is therefore one component within AGS, not a synonym for AGS.

AGS Is Not Just an MCP Server

AGS uses MCP as one execution boundary, but describing it as "an MCP server" also misses the system structure.

Specialist skills perform domain-specific reasoning. The orchestrator connects capabilities and artifacts. MCP, explicit contracts, and SQLite enforce execution structure, state transitions, required outputs, and completion conditions. Host adapters and hooks translate Codex- and Claude-specific behavior into common contracts.

The implementation deliberately separates these responsibilities.

What AGS Intentionally Does Not Guarantee

AGS is not an OS security sandbox. It does not isolate every process running under the same user account.

It also does not treat an ACK as task completion or approval. A successful tool call is not equivalent to correct output. A workflow receipt is not a magical proof that every submitted fact is true.

The goal is not to make AI infallible.

The goal is to make fallible execution more governable, traceable, reviewable, and recoverable.

A Useful Mental Model

A concise description is:

A local governance and coordination layer for operating AI work as an organization rather than as a single prompt chain.

Agent creation may be one mechanism inside that organization.

The core of AGS is the system of contracts, roles, communication, state, evidence, audit, recovery, and continuity around the work.