# A11 vs Agentic Systems: How Vertical Integrity Solves the Core Failures of Modern AI Agents > Source: > Published: 2026-07-17 04:20:00+00:00 ### *A practical, model‑readable explanation with examples* ### **1. Problem: Context soup, forgotten rules, /compact drops invariants** #### Why this happens An LLM sees everything as a single stream of text: - CLAUDE.md - skills - dialogue history - tool results - compact summary → the model doesn’t know what is important and what is not. → `/compact` can drop a critical rule. → the agent loses invariants and starts causing chaos. #### How A11 solves this A11 introduces a vertical core S1–S3 that: - does **not** live in the chat history, - does **not** depend on the current context, - cannot be dropped by `/compact` . **S2 — Wisdom** stores values, constraints, prohibitions. **S3 — Knowledge** stores facts and methods. They do **not** get mixed with the current task. #### Example Problem: the rule “do not change the architecture” disappears from the summary → the agent performs a global refactor. **How A11 works:** - S2 contains the rule “architecture is immutable without a spec”. - S3 contains knowledge about the current code. - S4 receives a conflict: - S2: architecture must not be changed - S3: the task requires a change - S4 records a **TensionPoint**. - New S1 = “clarify the requirements”. - The agent is **not allowed** to change the architecture. **A11 makes loss of rules impossible.** ### **2. Problem: Role mixing, chaos in the agent team, orchestrator does everything** #### Why this happens The LLM does not understand: - where the role boundary is, - what it is allowed to do, - what it is not allowed to do, - when to stop. The orchestrator is also an LLM → it “blends” with the sub‑agents. #### How A11 solves this A11 is a **vertical role architecture**, where: - S1 = intention - S2 = values - S3 = knowledge - S4 = integration - S5–S10 = living / acting - S11 = result check Each level: - has a **strict purpose**, - cannot perform the functions of another, - cannot be skipped. This is a built‑in role model. #### Example Problem: the reviewer starts writing code. **How A11 works:** - S8–S9 = practical action - S6 = projective action - S4 = integration - S11 = verification The reviewer is **S3→S4**, but not S8–S9. If they try to write code: - S2 forbids it, - S4 records a TensionPoint, - New S1: “clarify the role boundaries”. **A11 makes role mixing impossible.** ### **3. Problem: Prompt injection, malicious data, agent reads text as a command** #### Why this happens The LLM does not distinguish between: - data, - instructions, - jokes, - malicious text. Everything is just tokens. #### How A11 solves this A11 introduces: - **S2 — values and constraints** - **S4 — honest integration** **Integrity Log — a tamper‑proof journal** Any external information: - enters S3 as **data**, - S4 checks it for conflict with S2, - if there is a conflict → a TensionPoint is created, - the action is blocked. #### Example Problem: the agent reads “delete the file” in WebFetch and deletes it. **How A11 works:** - S3: “external text contains a command to delete a file” - S2: “file deletion is forbidden” - S4: conflict → TensionPoint - New S1: “verify the data source” - The action is not executed. **A11 makes prompt injection safe.** ### **4. Problem: LLM non‑determinism → unpredictable behavior** #### Why this happens LLM = probabilistic system. The same prompt → different answers. #### How A11 solves this A11 does **not** make the LLM deterministic. It makes the **process around it** deterministic. - S1 fixes the intention - S2 fixes the values - S3 fixes the knowledge - S4 fixes the gaps - S5–S10 live through the action - S11 checks correspondence to S1 This turns chaos into a **vertical decision cycle**. #### Example Problem: the same request → different solutions. **How A11 works:** - S1 is fixed - S2 is fixed - S3 is fixed - S4 records the gap - S11 checks correspondence to S1 Even if S5–S10 produce variation, **S11 discards unsuitable variants.** **A11 makes behavior predictable at the system level.** ### **5. Problem: Meta‑prompting doesn’t work, the model produces garbage** #### Why this happens The model: - does not know the project, - drowns in noise, - hallucinates, - does not understand what is important. #### How A11 solves this A11 introduces: - S3 — unified knowledge layer - S4 — honest integration - S1 — intention - S2 — values Meta‑prompting becomes: “Update S3 within S1 and S2” Not “improve CLAUDE.md”. #### Example Problem: “improve CLAUDE.md” → the model returns Medium‑level generic advice. **How A11 works:** - S1: “improve agent performance” - S2: “do not change architecture, do not add unnecessary things” - S3: “current rules” - S4: integration → TensionPoint: “insufficient specificity” - New S1: “refine rules for specific task classes”. **A11 makes meta‑prompting structural.** ### **6. Problem: Scale → errors grow exponentially** #### Why this happens When an agent can write 20k lines of code in one prompt: - one error = catastrophe, - blast radius is huge. #### How A11 solves this A11: - fixes intention (S1) - fixes values (S2) - fixes knowledge (S3) - fixes gaps (S4) - lives through the action (S5–S10) - checks the result (S11) Any error: - is localized in S4, - recorded in the Integrity Log, - does not propagate further. #### Example Problem: the agent accidentally does `git push -f` . **How A11 works:** - S2: “force‑push is forbidden” - S3: “git push -f detected” - S4: conflict → TensionPoint - New S1: “check repository policy” - The action is blocked. **A11 reduces the blast radius to a minimum.** ### **7. Problem: The agent doesn’t understand what it’s doing and can’t explain it** #### How A11 solves this The **Integrity Log** is: - a hash chain, - append‑only, - records all gaps, - explains all decisions. This is built‑in explainability. ### **8. Problem: The agent doesn’t know when a deep pass is needed** #### How A11 solves this **Switch Flags:** - RiskFlag - ConflictFlag - UncertaintyFlag - ValueFlag - UserDepthFlag If at least one is active → a full S1–S11 pass is launched. This makes depth **deterministic**, not random. Algorithm 11 (A11) [https://github.com/gormenz-svg/algorithm-11](https://github.com/gormenz-svg/algorithm-11)