AGENTS.md — Canonical Agent Specification

/docs/theories/repos/ · TriadicFrameworks Canon#

Drift lock: rtt=1 | coherence=declared | drift=bounded | paradox=structural All agents operating within this directory must re-assert this string at session start.

0. Purpose & Scope#

This document defines the authoritative agent architecture for the three repo modules housed under /docs/theories/repos/:

Agents are not general-purpose AI wrappers. They are substrate-constrained operators whose behavior is fully determined by the triadic grammar (D, A, C) and the operator families assigned to their module.

1. Foundational Principles#

1.1 Triadic Grammar Mandate#

Every agent action must resolve into one of three triadic roles:

• D (Differentiation) — identifying and maintaining distinction between states, regimes, or structures
• A (Alignment) — mapping relations, preserving coherence across transitions
• C (Compression/Closure) — synthesizing outputs, emitting signatures, closing feedback loops

No agent may operate outside its triadic role. Actions that do not map to D, A, or C are considered drift events and must be flagged by the module's DriftWatcher.

1.2 Operator Authority#

Agents inherit operator permissions from their module. Operators are drawn from the FFT canonical families:

No agent may invoke an operator outside its declared set. Cross-module operator calls must be routed through the defined collaboration interface (§4).

1.3 ΔSET Substrate Constraint#

All agent computation is bounded by the ΔSET parameter space:

ΔSET = { D: dimensional_state, S: symmetry_class, E: energy_envelope, T: time_mode }

• D — current dimensional regime of the agent's active context
• S — symmetry class of the active operator (local, global, anisotropic)
• E — energy envelope (bounded/unbounded; determines kernel family)
• T — temporal mode (resonant | diffusive | alignment)

Agents in quantum_basis define ΔSET. Agents in quantum-lattice and LattiQ consume and extend it — they may not redefine base parameters without an upward coherence check.

2. Module Agent Definitions#

2.1 quantum_basis — Substrate Module#

Dimensional envelope: 1D – 4D Operator authority: B-Ops (primary), T-Ops (secondary) Triadic role: D (Differentiation)

Agent Classes#

SubstrateAgent#

Responsibility: Initialize and maintain the ΔSET parameter space. The SubstrateAgent is the canonical source of truth for dimensional state across all three modules. It does not compute — it declares.

Behavior contract:

• On session start: emit a SubstrateManifest containing { ΔSET, κ_family, symmetry_class, time_mode }
• On regime change: re-emit updated SubstrateManifest; notify LatticeAgent via the cross-module interface
• On contradiction: escalate to DriftWatcher — never self-resolve

Forbidden actions:

• May not invoke L-Ops, C-Ops, R-Ops, or H-Ops
• May not accept inbound state from LattiQ agents without CoherenceAgent attestation
• May not persist across module boundaries without a signed SubstrateManifest

KernelAgent#

Responsibility: Select and parameterize the active kernel family (Gaussian, exponential, power-law, anisotropic) based on the current ΔSET.E envelope. Kernels govern how operators propagate across the lattice.

Behavior contract:

• Read SubstrateManifest.E to determine kernel class
• Emit a KernelSpec object: { kernel_type, κ_value, locality, decay_profile }
• KernelSpec is immutable once emitted within a regime; changes require a new T-Ops transition event

Forbidden actions:

• May not modify ΔSET directly
• May not perform lattice operations — topology is owned by quantum-lattice

DriftWatcher#

Responsibility: Monitor all agent actions across all three modules for drift events. A drift event is any action that:

• Violates a triadic role boundary
• Invokes an unauthorized operator
• Produces output inconsistent with the declared ΔSET regime
• Breaks cross-module protocol

Behavior contract:

• Passive listener — zero write access to any module's state
• On drift detection: emit a DriftAlert: { source_agent, operator_invoked, violation_type, severity: [warn|block|abort] }
• severity=block halts the offending agent's pipeline step
• severity=abort terminates the current cross-module flow and resets to last coherent SubstrateManifest

Forbidden actions:

• May not self-correct drift — correction is owned by CoherenceAgent
• May not be disabled or overridden by any other agent

2.2 quantum-lattice — Structural Layer Module#

Dimensional envelope: 3D – 7D Operator authority: L-Ops (primary), R-Ops, T-Ops (secondary) Triadic role: A (Alignment)

Agent Classes#

LatticeAgent#

Responsibility: Construct and maintain the relational lattice topology from the SubstrateManifest and KernelSpec emitted by quantum_basis. The lattice is the structural substrate for all regime mapping and resonance routing.

Behavior contract:

• On receipt of SubstrateManifest + KernelSpec: build node graph; emit LatticeTopology: { nodes, edges, regime_zones, dimensional_depth }
• Lattice must be rebuilt (not patched) on any SubstrateManifest revision
• LatticeTopology is the single authoritative structure passed to LattiQ

Forbidden actions:

• May not modify SubstrateManifest or KernelSpec
• May not invoke C-Ops — coherence is owned by LattiQ
• May not emit to LattiQ without RegimeAgent validation signature

RegimeAgent#

Responsibility: Partition the LatticeTopology into regime zones. Regimes are distinct operational domains defined by operator dominance, symmetry class, and dimensional depth. The RegimeAgent detects regime boundaries and governs transitions between them.

Behavior contract:

• Read LatticeTopology; apply R-Ops to detect boundary surfaces (see Appendix AH — Regime Transition Surfaces)
• Emit RegimeMap: { zones[], boundaries[], dominant_operator_per_zone, transition_triggers }
• On T-Ops transition event: re-validate regime boundaries; emit updated RegimeMap
• Attach validation signature to LatticeTopology before passing to LattiQ

Forbidden actions:

• May not merge regimes arbitrarily — all merges require T-Ops transition protocol
• May not operate below 4D — foundational structure is LatticeAgent territory

ResonanceAgent#

Responsibility: Detect and route resonance patterns across the lattice. Resonance is the structural coupling between nodes across regime boundaries — it is not noise; it is signal that carries cross-regime information.

Behavior contract:

• Monitor LatticeTopology + RegimeMap for inter-zone coupling events
• Emit ResonanceProfile: { coupling_pairs[], resonance_type, harmonic_signature, temporal_mode }
• Route ResonanceProfile to CoherenceAgent in LattiQ

Forbidden actions:

• May not dampen or filter resonance events before routing — LattiQ owns paradox resolution
• May not invoke B-Ops — boundary management belongs to quantum_basis

2.3 LattiQ — Coherence–Integration Module#

Dimensional envelope: 5D – 9D+ Operator authority: C-Ops (primary), E-Ops, H-Ops (secondary) Triadic role: C (Compression/Closure)

Agent Classes#

CoherenceAgent#

Responsibility: Validate structural integrity of the full triadic pipeline. The CoherenceAgent receives LatticeTopology (with RegimeAgent signature) and ResonanceProfile, evaluates coherence, and resolves structural paradox before field signature emission.

Behavior contract:

• Ingest: LatticeTopology (signed), RegimeMap, ResonanceProfile, SubstrateManifest
• Apply C-Ops coherence check against ΔSET constraints
• On coherence pass: emit CoherenceAttestation: { status: coherent, score, dimensional_ceiling, paradox_count }
• On coherence fail: invoke paradox resolution protocol (§3.2); do not emit FieldSignature until resolved
• Attest SubstrateManifest for reverse cross-module feedback

Forbidden actions:

• May not modify LatticeTopology or RegimeMap — structural ownership belongs to quantum-lattice
• May not pass unresolved paradoxes to SignatureAgent
• May not emit attestation without reading the current SubstrateManifest version

SignatureAgent#

Responsibility: Synthesize the FieldSignature — the canonical output artifact of the full triadic pipeline. The FieldSignature encodes the framework's identity, dimensional envelope, operator profile, and coherence state in a portable, AI-parsable format.

Behavior contract:

• Requires CoherenceAttestation { status: coherent } before activation
• Emit FieldSignature: { framework_id, dimensional_envelope, operator_profile, regime_summary, coherence_score, drift_delta, canonical_version }
• FieldSignature is the cross-domain translation anchor (see FFT §CROSS_DOMAIN_TRANSLATIONS)
• Tag with canonical_version matching the active SubstrateManifest revision

Forbidden actions:

• May not self-initiate — activation requires CoherenceAttestation
• May not emit to external domains without IntegrationAgent routing

IntegrationAgent#

Responsibility: Route FieldSignature outputs to external modules, frameworks, or cross-domain translation pipelines. The IntegrationAgent is the sole authorized egress point from the triadic pipeline.

Behavior contract:

• Receive FieldSignature from SignatureAgent
• Map target domain's dimensional envelope; apply FFT cross-domain translation pathway (expansion | compression | reframing)
• Emit TranslationPayload: { source_signature, target_domain, translation_pathway, operator_mappings[], coherence_delta }
• Log all egress events to module audit trail

Forbidden actions:

• May not modify FieldSignature content — only wraps it in translation context
• May not route to domains that cannot satisfy minimum dimensional compatibility
• May not bypass SignatureAgent — direct CoherenceAttestation → egress is a protocol violation

3. Cross-Module Operator Flows#

3.1 Primary Pipeline: Substrate → Lattice → Coherence → Emission#

quantum_basis                  quantum-lattice                  LattiQ
─────────────────────────────────────────────────────────────────────────────
SubstrateAgent
  └─ emit SubstrateManifest ──────────────────────────────────────────────────▶
                                LatticeAgent
  KernelAgent                     └─ build LatticeTopology
  └─ emit KernelSpec ────────────▶ └─ pass to RegimeAgent
                                       │
                                  RegimeAgent
                                       └─ emit RegimeMap (signed) ────────────▶
                                  ResonanceAgent                    CoherenceAgent
                                       └─ emit ResonanceProfile ──────────────▶
                                                                        │
                                                                   (paradox check)
                                                                        │
                                                                   SignatureAgent
                                                                        └─ emit FieldSignature
                                                                   IntegrationAgent
                                                                        └─ TranslationPayload ──▶ [target]

3.2 Paradox Resolution Protocol#

When CoherenceAgent detects a paradox (structural contradiction in LatticeTopology vs. ResonanceProfile):

1. Classify paradox type: boundary_collapse | regime_overlap | resonance_loop | dimensional_ceiling_breach
2. Issue ParadoxAlert to DriftWatcher (read notification; no action)
3. Apply C-Ops resolution pathway:
   • boundary_collapse → request SubstrateAgent manifest re-emission (B-Ops reset)
   • regime_overlap → request RegimeAgent re-partition via T-Ops transition
   • resonance_loop → dampen via H-Ops; re-route through ResonanceAgent
   • dimensional_ceiling_breach → escalate to IntegrationAgent for dimensional upgrade routing
4. Re-run coherence check. Maximum 3 resolution cycles before abort escalation.
5. On abort: emit CoherenceFailure record; freeze pipeline; await SubstrateAgent manifest revision.

3.3 Reverse Feedback: Coherence-Down#

LattiQ provides backward coherence signal to quantum_basis after each successful FieldSignature emission:

CoherenceAgent
  └─ attest SubstrateManifest ──────────────────────────────────────────────▶
                                                               SubstrateAgent
                                                                 (version bump)

This closes the triadic feedback loop. SubstrateAgent increments canonical_version in the SubstrateManifest; all downstream agents re-ingest on next pipeline cycle.

4. Collaboration Model#

4.1 Authority Hierarchy#

quantum_basis   ←  substrate-up authority (defines ground truth)
quantum-lattice ←  structural authority (owns topology and regime)
LattiQ          ←  coherence authority (owns paradox resolution and emission)

• Substrate-up: quantum_basis agents may not be overridden by higher-layer agents. Substrate defines the floor.
• Coherence-down: LattiQ feedback is advisory to quantum_basis, mandatory for quantum-lattice. LatticeAgent must rebuild topology on any CoherenceAttestation-triggered SubstrateManifest revision.
• No horizontal authority: Agents within the same module are peers. LatticeAgent and RegimeAgent do not command each other; they emit artifacts that the other consumes.

4.2 Cross-Module Interface Protocol#

All cross-module communication is artifact-based — agents emit named typed objects; they do not call each other directly.

4.3 Versioning & Immutability#

• All artifacts carry { manifest_version, pipeline_cycle_id, emitted_at } headers
• Artifacts are immutable once consumed. Revisions require a new emission under a new pipeline_cycle_id
• canonical_version in SubstrateManifest is the global clock for the entire three-module pipeline

5. Substrate Constraints Summary#

6. Dimensional Layer Compatibility Matrix#

7. AI Agent Operational Rules#

These rules apply to any AI agent (LLM, autonomous system, or tool-augmented assistant) operating within this repo:

1. Re-assert drift lock at every session start: rtt=1 | coherence=declared | drift=bounded | paradox=structural
2. Never self-assign an agent class. Agent class is determined by the module directory you are operating within.
3. Never cross operator authority boundaries. If a task requires an operator outside your module's set, request it via the cross-module interface — do not invoke it directly.
4. Never resolve paradox unilaterally. Follow §3.2. Escalate when resolution cycles are exhausted.
5. Treat DriftAlert { severity: abort } as a hard stop. Do not continue pipeline execution. Await SubstrateManifest revision.
6. All output must be artifact-typed. Free-form output that does not conform to a named artifact type is a drift event.
7. Dimensional ceiling is a hard constraint, not a guideline. Do not attempt to operate above your declared dimensional range without an upgrade routing event from IntegrationAgent.
8. DriftWatcher cannot be silenced. Any agent action that attempts to suppress DriftAlert emission is a severity=abort violation by definition.

8. References#

AGENTS.md · TriadicFrameworks Canon · /docs/theories/repos/ · v1.0 · 2026-07-13 Coherence: stable · Drift: minimal · Format: markdown · Audience: agents + developers