The Logical Architecture

The system has three simultaneous identities

The ideal Agent is a persistent semantic system that knows what it is responsible for, what is known and unknown, which Decisions remain effective, who is authorized, what has been proven, and what changed. It is also a distributed cognitive system that assembles models, humans, algorithms, knowledge sources, compilers, tools, and external Actors for the specific problem in front of it. Finally, it is a reality-coupled control system that acts on the world, observes consequences independently, revises affected state, and maintains Commitments over time. The user may experience one stable Agent identity, but that identity is a relationship and accountability boundary rather than one permanent cognitive process. The underlying Resources can change completely while the accepted semantics remain.

Full logical map

Five cross-cutting systems apply throughout:

SEMANTIC LOGICExtension and Module System
Security, Trust, and Privacy
Provenance, Temporality, and Versioning
Materiality
Observability and Evaluation

The diagram expresses logical responsibility. A small implementation may combine most of these concerns in one process; a large implementation may distribute them. The architecture depends on the boundaries remaining meaningful, not on a microservice count.

1. Agent Experience and Interaction

This is the human-facing surface: conversation, voice, views, notifications, status, explanations, decision requests, approvals, and Artifacts. It is intentionally thin because the interaction channel should not become the owner of Work, Memory, Goals, Commitments, Decisions, or Authority. A user may begin through voice, inspect state on a dashboard, approve a Decision on mobile, and continue through chat while referring to the same underlying Work. The architectural identity of the work does not change when the interface changes.

Conversation identity ≠ Work identity

2. Identity, Principal, Governance, Value, and Policy

This layer owns the legitimacy of action. Its objects include Principal, Actor, Identity, AuthorityGrant, AuthorityEnvelope, Policy, Purpose, StandingInstruction, TrustClass, InfluenceClass, PrivacyScope, DataPurpose, and CredentialBinding. It answers who acts, for whom, for what purpose, within which scope, under which privacy and Policy constraints, and with which redelegation rights. It deliberately does not answer which software architecture is correct or what the system should do next; otherwise Governance becomes an untyped Planner. Authority may be compositional. The admission of one effect can depend on prior effects, delegated purpose, accumulated budget, resulting information flow, and current Policy. Permission for two individual calls does not imply permission for their combined consequence.

3. Ontology and Semantic Type System

The ontology defines the shared language through which the rest of the architecture can make claims:

SEMANTIC LOGICcore.intent · core.goal · core.commitment · core.work
core.unknown · core.decision · core.obligation
core.responsibility · core.capability · core.evidence

Extensions may contribute domain types such as software.repository, travel.flight, or finance.transaction. Types and relations are namespaced, versioned, and extensible; their meaning remains stable enough that historical Work can still be interpreted after upgrades. The ontology defines what a concept means and which relations are legal. It does not declare concrete propositions true. Grounding happens through Observation, epistemic admission, Decisions, and Evidence.

4. Persistent Semantic State Fabric

This is the continuity substrate. It is not one omniscient database, but a fabric of scoped semantic authorities whose objects can participate in several coupled views.

4.1 Commitment and Work

This authority owns Goal, Commitment, Horizon, Outcome, WorkNode, Decomposition, Dependency, Unknown, Impasse, Decision, and reconsideration conditions. It preserves what the system has accepted as work and how that meaning evolved. It does not execute the Work, select a model, or verify its own completion.

4.2 Epistemic, Support, and Context

This authority owns Observation, Fact, Inference, Assumption, Hypothesis, Contradiction, Source, SourceAuthority, TypedSupportRelation, Validity, and SemanticContext. It explains why something is justified, under which assumptions and Context it remains valid, and what became stale when an upstream premise changed.

4.3 Memory

The Memory authority owns Episode, SemanticMemory, ProceduralMemory, MetaMemory, UserMemory, PreferenceState, retention, and consolidation lineage. MemoryRecallSet and UserModelSlice are projections compiled for a purpose; they are not independent canonical truth.

4.4 Responsibility and Coordination

This authority represents Accountability, Responsibility, Role, Delegation, Collaboration, Handoff, Communication, review responsibility, Negotiation, shared-resource coordination, and conflict. Its topology may cross the Work decomposition and the runtime arrangement of agents.

4.5 Capability and Resource state

This authority describes Resources, Capabilities, Procedures, Tools, Models, HumanExperts, DomainCompilers, Executors, KnowledgeSources, Verifiers, and Environments, together with relations such as requires, substitutes, composes_with, authorized_for, and compatible_with. It supports general Resource resolution rather than only model routing.

4.6 Evidence and Obligation state

This authority owns Obligation, Evidence, VerificationRecord, AcceptanceDecision, Waiver, and ClosureDecision. The Assurance layer evaluates these objects, but it does not invent the Obligations it is meant to prove.

4.7 Domain and World Models

Work answers what should be done; Epistemics answers what is known; a Domain or World Model represents how the subject itself is structured. Software may require services, contracts, data, runtime relations, and failure semantics; travel may require places, times, connections, availability, and constraints. The Universal Core defines the contract, while each Module chooses a representation: graph, constraint model, state machine, simulation, table, symbolic model, or learned representation.

4.8 Event and Provenance

This authority preserves what happened, when, which Actor or Resource produced the record, which revisions were used, and which activity generated it.

SEMANTIC LOGICProvenance ≠ Justification
Dependency ≠ Causality

5. Deliberation and Cognitive Fabric

This is the system's cognitive repertoire: interpretation, formulation, modeling, research, hypothesis generation, search, planning, decomposition, design, constraint reasoning, simulation, counterfactual analysis, synthesis, creativity, verification reasoning, explanation, and metacognition. These activities produce proposals, models, assessments, Artifacts, and Evidence candidates. They do not mutate canonical state merely because they required a powerful model or expert. Planning remains a first-class cognitive operation that may be performed by several Resource classes; Semantic Work Refinement is one operation inside this Fabric rather than a hidden permanent Planner Agent.

6. System and Structural Intelligence

This layer maintains the structure through which distributed cognition remains coherent. Its responsibilities include cross-view consistency, truth maintenance, local impact analysis, SemanticContext management, Frontier derivation, partial-order structure, Resource-matching support, Context compilation, conformance between accepted and observed state, and revision propagation. The Frontier is the derived set of admissible and useful semantic advances, not a scheduler-owned queue. The Context Compiler builds a purpose-bound ContextPack from canonical state, selected Memory, User and Domain projections, Policies, Authority, Procedures, Capabilities, and the expected Result and Verification requirements.

7. Executive Control and Resource Allocation

Executive Control is deliberately narrower than an executive agent. It arbitrates Commitment attention, portfolio priority, deadlines, Risk, cost of delay, Resource contention, cognitive budget, scheduling, concurrency, and activation. It does not determine which architecture is correct, what Research proves, or how a product should be decomposed. Those belong to domain deliberation and accepted Decisions. This boundary prevents the control layer from becoming a super-agent whose private interpretation silently owns the whole system.

8. Execution and Reality Interface

This is the motor boundary between accepted responsibility and the world. The Capability Fabric describes what can be done, the input and output contracts, effect class, Risk, reversibility, idempotency, Evidence produced, and failure semantics. The Credential Broker resolves reusable secrets only at the execution boundary:

SEMANTIC LOGICPrincipal + ResponsibilityAssignment + Capability
→ scoped credential use

The Execution Fabric may use a model executor, coding agent, browser, script, API, generator, robot, human, or organization. Effect Tracking distinguishes attempted, reported successful, independently observed successful, ambiguous, compensated, and reversed effects. Observation and Reconciliation then ask what actually happened in the world rather than treating the executor's narrative as confirmation.

9. Assurance, Verification, Acceptance, and Closure

Execution and final judgment remain separate. Assurance evaluates canonical Obligations and Evidence through deterministic checks, domain verifiers, independent Resources, human Acceptance, or model-assisted semantic review. It produces VerificationRecords, AcceptanceDecisions, and ClosureDecisions.

SEMANTIC LOGICResult ≠ Evidence
Evidence ≠ Verification
Verification ≠ Acceptance
Acceptance ≠ Closure automatically

Closure is derived from Dependencies, child coverage, Obligations, effective Decisions, approvals, Evidence freshness, and Contradiction state. Recent empirical work supports the need to model required actions explicitly: ObligationBench treats safety-critical actions that an Agent failed to perform as a distinct failure class and evaluates whether guard models can identify the omission.^{[1]Obligations, accountable coordination, and closed-loop governancesourceOpen bibliography entry →} That result does not prove the complete Closure model proposed here, but it reinforces the case for first-class Obligations rather than implicit checklist text.

10. Evolution, Learning, and System Evaluation

Persistent evolution differs from runtime adaptation. This layer aggregates experience, consolidates Memory, proposes Procedures, improves decomposition and Resource selection, updates ResourceProfiles, refines Context selection and coordination patterns, learns verification rules, and evaluates structural change.

SEMANTIC LOGICCandidate
→ Evaluation
→ Admission
→ Version
→ Monitoring
→ Rollback when necessary

There is no uncontrolled self-modification. Learning cannot change Principal identity, Core invariants, higher-authority Policy, or AuthorityGrants without an explicit authorized transition.

Extensions, Plugins, Modules, Procedures, and Configuration

These terms remain separate because they carry different governance and lifecycle semantics. An Extension contributes semantics or functionality through stable ContributionPoints. A Plugin packages one or more Extensions and supporting resources. A Procedure or Skill contributes governed reusable workflow knowledge. A Module composes Extensions, Procedures, Capabilities, schemas, Sources, compilers, Policies, and Closure defaults into a coherent domain runtime. Configuration specializes installed semantics for a Principal, organization, workspace, project, Commitment, or assignment.

SEMANTIC LOGICinstalled
≠ active
≠ applicable
≠ authorized
≠ selected

Core semantics remain open for extension and closed for weakening.

Cross-domain changes need coherent admission

One human act may affect several semantic authorities. “Cancel the trip and never book this class automatically again” can change Commitment, Work, Authority, Policy, Delegation, and Preference. A logical SemanticChangeSet records the base revisions, proposed changes, preconditions, Authority lineage, causal Source, and consistency constraints. The architecture does not prescribe ACID storage. It does require that logically inconsistent partial state never be accepted as a valid outcome.

The layers are not services

A small implementation may keep several logical authorities in one process and database; a large one may distribute them. Physical topology is secondary until implementation convenience starts collapsing meaning: a coordinator becomes the sole owner of Decisions, Memory becomes the User Model, a scheduler owns Work semantics, or an executor can set parent completion. Those are architecture violations regardless of deployment shape.

The reality-coupled relation recurs locally

The system has no one global lifecycle, but a common relation appears in many regions:

SEMANTIC LOGICaccepted semantics
→ cognition or deterministic derivation
→ admitted Responsibility
→ bounded Execution
→ world effect
→ independent Observation
→ Evidence and Verification
→ Closure, Contradiction, or revision

Many such processes operate concurrently across different Commitments and Work regions.

Semantic continuity does not require running cognition

With every LLM process stopped, the accepted portions of Governance, Semantic State, Structural Intelligence, Execution policy, Assurance, and Evolution still preserve identity and Authority; Commitments and Work; Decisions and Assumptions; Knowledge and Memory; ResponsibilityAssignments; waits and activation conditions; Observations and Evidence; staleness, readiness, and Closure projections; and deterministic Policy enforcement. Cognition may pause. Agency does not dissolve.

Compact definition

The ideal Agent is a persistent semantic and cognitive operating system for delegated activity. It maintains authoritative, provenance-aware representations of Commitments, Work, Knowledge, Memory, Responsibility, Authority, Domain state, and Evidence; dynamically assembles reasoning and execution Resources to resolve semantic uncertainty; acts through purpose-bound Capabilities; independently observes and verifies resulting state; and evolves through governed, reversible change.