Glossary

Agentic Debt: Debt that accrues when agent autonomy grows faster than architectural discipline. It surfaces in four forms: authority sprawl, contract gap, observability gap, and validation gap. The OCLS loop is the mechanism that pays it down systematically.
Agent: A responsible actor that calls modules and participates in collaboration flows in service of a goal. Not a function caller — a unit that owns and can explain an outcome.
Module: A reusable execution unit with declared input/output, authority, and failure conditions. The minimum governance unit an agent calls to fulfill its responsibility.
Contract: The bundle of interface and constraints an agent or module must honor. Includes input schema, output schema, required authority, failure conditions, and the shape of the failure response.
Governance: The operational control layer that manages quality, cost, authority, approval, and safety. Not a bolt-on afterthought — a baseline element of the architecture.
Responsibility Boundary: The boundary of an agent's owned responsibility. Decisions and execution inside the boundary are made by the agent alone; anything outside is delegated through an explicit handoff.
Handoff: The act of one agent explicitly delegating work that exceeds its responsibility to another agent. The scope and format of context passed at handoff must be defined.
Authority Scope: The range of actions an agent or module is permitted to execute. Covers read/write authority, callable external services, and cost ceilings.
Context: Structured information passed between agents at handoff. Includes conversation history, user intent, intermediate results, and metadata — filtered to what the receiving agent's responsibility requires.
State: Session-scope short-term data. Holds the current conversation, running temporaries, and progress markers, and is cleared automatically at session end.
Memory: System-scope long-term data. Holds learned patterns, customer preferences, and prior resolutions, and is promoted from short-term state by explicit criteria.
Evaluation Criteria: Quantitative measures of agent or module output quality. Covers success rate, response-quality score, cost efficiency, and hallucination detection.
Guardrail: A safety rule validated before agent execution. Constraints such as cost ceilings, authority scopes, action denylists, and PII blocks that stop risk before it materializes.
Escalation: The act of handing judgment to a higher-level agent or a human approver when the agent detects that the situation exceeds its autonomous scope. Escalation criteria must be defined explicitly.
Decision Traceability: The design principle of recording an agent's reasoning path, module-selection rationale, and handoff reasons in structured logs. Without traceability, evaluation, improvement, and audit are all impossible.
OCLS Loop: Own → Contract → Layer → Sharpen. The governance design loop of reopt architecture. Each cycle sharpens ownership, contracts, layering, and boundaries.
Own Every Outcome: The design principle that an owner assigned to every outcome makes responsibility explicit. With an owner, incidents trigger an immediate response and governance can operate.
Aim the Compute: The design principle that without human direction, compute runs in circles. Ownership is not only bearing responsibility — it is setting an ambitious goal and connecting domains; as token capital grows, the human capital that sets direction grows more valuable, not less.
Contract First: The design principle that declaring input, output, authority, and refusal conditions before implementation makes evaluation, replacement, and control possible. Contracts are provisional — operational data updates them.
Sovereign Over the Model: The design principle that the model is a borrowed part while sovereignty lives in the learning system you stack on top of it. Swap the generalist model, and the company's expertise must remain in your contracts, traces, and internal evals (a private eval). The test is not picking the best model but owning a learning loop that works no matter which model arrives.
Layer, Then Scale: The design principle that structuring agents into categories, layers, and boundaries preserves governance as agent count grows. Layering is the scaling strategy.
Sharpen in Operation: The design principle that adjusting boundaries from operational data lets governance evolve with reality.