The Agent Loop Is the Wrong Architectural Center

The loop became durable. It did not disappear

The first tool-using agents were easy to describe: observe, reason, act, observe again. Current systems are considerably stronger. They preserve sessions, compact Context, store Artifacts, recover from failure, create subagents, coordinate parallel work, enforce approvals, and schedule future execution. OpenAI's Agents API exposes a long-running Codex harness with tools, Context management, subagents, and durable execution.^{[1]Current agent systems and engineering evidencesourceOpen bibliography entry →} Anthropic has documented both orchestrator-worker research systems and managed agents that separate a coordinating “brain” from execution “hands.”^{[2]Current agent systems and engineering evidencesourceOpen bibliography entry →[3]Current agent systems and engineering evidencesourceOpen bibliography entry →} Cursor Projects gives a persistent coordinator shared project Context and many parallel coding agents, while LangGraph adds checkpoints, stores, interrupts, and recoverable graph execution.^{[4]Current agent systems and engineering evidencesourceOpen bibliography entry →[5]Current agent systems and engineering evidencesourceOpen bibliography entry →} These systems solve real engineering problems, and a stronger architecture should use rather than dismiss them. The remaining issue concerns the object that stays authoritative when the coordinating model is wrong, replaced, paused, or absent. In most documented designs, meaning still resides in some combination of session state, coordinator Context, a saved plan, a task or run, a workflow node, and a model-authored summary. The infrastructure has made the trajectory durable; it has not yet made the work semantically independent from that trajectory.

Recoverable activity can still lose semantic continuity

An agent trajectory is the evolving sequence through which a model or coordinator interprets current state, selects a next step, creates or revises a plan, invokes tools, delegates, incorporates Results, and decides whether to continue. It may be persisted, replayed, divided across several contexts, mediated by a scheduler, or rendered as a graph. Those properties allow activity to resume after interruption, which is valuable. They do not, by themselves, give another Actor an authoritative answer to questions such as which statement was an Assumption, which Decision remains effective, what Evidence would invalidate it, who had Authority to make it, or which Obligation remains open despite successful execution. The same problem appears in model-authored plans. One prose artifact often combines desired outcome, assumed current state, selected design, unresolved question, execution step, verification idea, and completion judgment. Better prompting can make that artifact more disciplined, but each proposition still lacks an independent lifecycle, Authority, provenance, and invalidation rule. When recovery means loading a transcript, retrieving a summary, reopening scratch files, or resuming a coordinator thread, the system reconstructs what the model appeared to mean; a plausible reconstruction can omit an Obligation, flatten a Contradiction, reinterpret an old Decision, or convert uncertainty into confidence. Persistent semantic continuity starts from accepted objects: Commitment, Decision, Unknown, Assumption, ResponsibilityAssignment, AuthorityEnvelope, Obligation, Evidence, and current Observation. A fresh model receives a ContextPack compiled from those objects and the responsibility it has been assigned. It can inherit the work without inheriting the previous model's entire narrative, because the state from which Context is rebuilt survives independently.

Recovering a model's context and recovering the work are different operations.

Responsibility and completion expose the missing structure

Coordinator-worker systems increase throughput, but throughput does not settle responsibility. A task description may tell a worker what to produce while leaving parent accountability, Authority limits, sibling interfaces, Evidence requirements, escalation, Acceptance authority, and redelegation undefined. The worker can execute the request competently and still return a locally correct result for a responsibility that was badly formed. A typed DelegationContract makes the boundary inspectable before execution and lets the receiving Resource accept, decline, request clarification, or ask for redecomposition. Completion reveals the same structural gap because material work produces several facts rather than one done event:

SEMANTIC LOGICAttempt succeeded
Responsibility fulfilled
WorkNode satisfied
Obligations verified
Outcome accepted
Horizon closed
Commitment satisfied

An executor can submit a valid Result without satisfying the parent Outcome. A test can pass while its Evidence is stale or incomplete, and an independent reviewer can verify technical properties without possessing business Acceptance authority. Once these states collapse into one completion judgment, the system can produce fluent false closure even when every participant behaved locally as instructed. Action and observation create another boundary. A tool may time out after causing an external effect; a deployment report may say success while the live service remains unhealthy; a coding Resource may report passing tests based only on its own environment. The architecture therefore preserves attempted, reported, and independently observed effects. An ambiguous effect creates Reconciliation Work and a new authoritative Observation, while an Artifact becomes Evidence only under an applicable Obligation and collection policy. Closure follows from the accepted and observed state that remains after execution, not from the executor's confidence in its own account.

Authority and revision accumulate across time

Long-horizon systems compose effects, so per-call tool permission is too weak as the governing model. Reading a private document and sending an ordinary email may each be authorized, while sending the document's contents outside the organization remains prohibited. Authority must stay bound to Principal, purpose, Responsibility, data flow, accumulated effects, prior actions, and current Policy. A hostile document may influence a proposal, but the proposal still crosses an independent admission boundary; technical access to a tool is evidence of Ability, not legitimate purpose. Change also accumulates. When an important premise changes, a planner-centered system often asks the model to regenerate or reinterpret the whole plan. That response can reopen settled Decisions, discard valid completed Work, change the parent Goal, or silently substitute a new assumption set. A semantic system first follows typed support and dependency. If Assumption A1 supported Decision D4, which governed Work W9 and Verification V7, a contradictory Observation can mark D4 for reconsideration, W9 for impact analysis, and V7 for reverification while leaving unrelated W10 untouched. Cognition may still design the revision, but the system already knows which region requires attention. Memory contributes continuity without becoming the authority that defines present state. Episodes, preferences, summaries, and prior plans can guide retrieval, interpretation, and observation; they can also be stale, scoped to another purpose, weakly inferred, or contradicted. Retrieved items therefore pass Principal, privacy, purpose, scope, freshness, and contradiction gates before entering a ContextPack. Repetition may support a PreferenceCandidate, but it cannot create an AuthorityGrant, and an old Observation cannot replace a live authoritative Source for a fact that changes independently.

Graphs and coordinators are useful substrates

Serious delegated work participates in several coupled graph views whose relations follow different laws:

SEMANTIC LOGICCommitment and Work
Epistemic support
Semantic alternatives
Responsibility and coordination
Authority and Policy
Capability and Resource
Memory and User state
Evidence and Obligations
Domain and world models
Events and Provenance

The same Decision may govern Work, assume a proposition, be accepted by a human authority, create an Obligation, and carry provenance from a particular Reasoner. A graph runtime can persist control flow and a graph database can store all of those edges, but representation alone does not establish which relation creates Authority, which one carries epistemic support, which transition is admissible, or how invalidation propagates. The architecture resides in object meaning, scoped ownership, transition law, and invariant enforcement. Coordinators remain useful Resources within that architecture. They can synthesize, interact with the user, allocate attention, decide which specialist to consult, and operate iterative loops inside research, coding, design, or review. Their role becomes safer and more replaceable when accepted meaning is available outside their private interpretation. The mutation boundary shows the difference:

SEMANTIC LOGICTrajectory-centered form:
model interprets state
→ model chooses action
→ model updates its plan

Persistent semantic form:
current accepted revisions
→ stimulus, Observation, cognition, or human act
→ ProposedSemanticChange
→ schema, Authority, Policy, support, Context, and revision checks
→ admitted revision
→ local impact and projection updates

The second path preserves reasoning while preventing a cognitive Result from becoming authoritative merely because the current coordinator produced it.

Long-lived agency invokes cognition selectively

A Maintenance Commitment may watch a production service, a flight, or a certificate for years. During normal periods, sensors, timers, schedulers, Policy predicates, and deterministic projections can observe the relevant state and preserve the responsibility without running a model. A material event activates a Horizon; cognition appears when the resulting semantic transition requires interpretation, research, design, or judgment. The economic model changes accordingly:

continuous intelligent process

becomes:

SEMANTIC LOGICpersistent semantic responsibility
+ event-driven Observation
+ selectively invoked cognition

This is more than a cost optimization. It makes waiting, dormancy, activation, and continuity first-class system states rather than moments in which an absent model has temporarily stopped driving the architecture.

The implementation boundary is falsifiable

The proposal has regressed if one smart model still owns the plan, retrieves or reconstructs Context, chooses tools, forwards prompts, adapts its private interpretation, and eventually decides that the work is complete. A distinct implementation preserves accepted Commitments and Work outside model Context; allows routine semantic transitions with zero model calls; represents Responsibility independently from a subagent tree; observes external effects outside the executor; derives Closure through Obligations, Evidence, and Acceptance; and routes model outputs through proposal and admission semantics. The agent loop was a productive abstraction for connecting models to tools, and durable harnesses, multi-agent systems, and graph runtimes have made that abstraction more capable. The next persistent object is the governed state of delegated activity itself.

The architecture preserves the meaning of the work, not merely the path taken by an intelligent model.