Braid Reasoning

Category role · Version 5.1

Equation term PPD as inference-layer V(π,t), C_amortized for reasoning infrastructure, Model Capacity × Prompt Structure as inference-layer P^1.5

Bounded reasoning architecture for privacy-preserving AI agents using BRAID Mermaid graphs. Activates when discussing Generator/Solver split architecture, Performance-Per-Dollar (PPD) inference economics, BRAID Parity Effect (small model + structure ≥ large model), Mermaid reasoning graph construction, node atomicity, procedural scaffolding vs answer leakage, terminal verification loops, Numerical Masking Protocol, cached reasoning graph libraries, split- architecture deployment, or any task where reasoning structure should be decoupled from reasoning execution for cost efficiency and privacy preservation. Use whenever designing how dual agents reason, not just what they reason about. Since 2026-09-12 also covers BRAID as a service (SERV Reasoning: Shadow Agent, Kronos, Multipath, PromptGuard, raw mode), the harness seat driver rule (one seat, never both, never the default) and the raw-versus-SERV round that measures C8.

Source: Privacy Value Model V4 + BRAID (arXiv:2512.15959) + Holonic BRAID Lite Paper
Target context: Agent inference architects, reasoning cost optimisers, split-architecture designers, privacy-agent deployment engineers
Architecture: agentprivacy.ai · Sync: sync.soulbis.com · Contact: mage@agentprivacy.ai

What this is

BRAID (Bounded Reasoning for Autonomous Inference and Decisions) replaces unbounded Chain-of-Thought reasoning with bounded, symbolic structures expressed as Mermaid flowchart diagrams. The core insight: reasoning performance is a product of Model Capacity × Prompt Structure. By increasing structure, you decrease required capacity. A nano-tier model executing a well-constructed BRAID graph matches or exceeds a medium-tier model reasoning without structure — at 74× the cost efficiency.

For the dual-agent architecture, BRAID provides the reasoning methodology. Agents don't just need to be separated (Swordsman ⊥ Mage) — they need to reason efficiently within that separation. BRAID makes privacy-preserving inference economically viable at scale by collapsing the cost of structured reasoning toward zero through caching and reuse.

The Generator/Solver split

BRAID operates as a two-stage pipeline:

Stage 1 — Generation. A capable model (the Generator) reads the problem and produces a Mermaid reasoning graph. The graph encodes the logical topology: constraints, facts, steps, branching logic, and verification checkpoints. This is the expensive step — it requires intelligence. But it happens once per task type.

Stage 2 — Solving. A lightweight model (the Solver) receives the graph as a system message and executes it to produce the final answer. This is the cheap step — it requires only the ability to follow structured instructions. It happens millions of times.

The economics: C_amortized = C_BRAID/N + C_inference. As N (the number of executions) grows, the generation cost vanishes. What remains is the solve-only cost — and for nano-tier models, this is 30–74× cheaper than running a medium-tier model without structure.

The privacy parallel: This is dual-agent separation applied to inference. Generator ⊥ Solver, just as Swordsman ⊥ Mage. The generator sees the full problem space (viewing capability). The solver executes within bounded constraints (signing capability). Neither reconstructs the other's function. The graph mediating between them is a bounded channel — the inference-layer analog of the separation matrix.

The BRAID Parity Effect

The paper's most significant finding: "a smaller model equipped with bounded reasoning (BRAID) often matches or exceeds the performance of a model one or two tiers larger using unstructured prompting."

Empirical results:

• GSM-Hard: gpt-5-nano-minimal (BRAID) achieved 98% accuracy vs 95% for gpt-5-medium (Classic). PPD: 74.06× baseline.
• SCALE MultiChallenge: gpt-5-nano-minimal (BRAID) achieved 45.2% vs 40.4% for gpt-5-minimal (Classic). PPD: 52.84× baseline.
• AdvancedIF: gpt-5-nano-minimal (BRAID) more than doubled accuracy from 18% to 40%. PPD: 61.69× baseline.

Translation to sovereignty economics: The BRAID Parity Effect is P^1.5 at the inference layer. Just as doubling privacy protection more than doubles data value (PVM-V4), doubling prompt structure more than doubles reasoning accuracy per dollar (BRAID). Structure is superlinear. This validates the core thesis: you don't need the biggest model, you need the right architecture.

Inference layer of V(π,t): If privacy-structured inference compounds with privacy-structured data and privacy-structured identity, the multiplicative value is triply superlinear. A sovereign agent using BRAID reasoning on holonic data with dual-agent separation doesn't just add up the advantages — it multiplies them.

Four principles of BRAID graph construction

Principle 1: Node Atomicity (< 15 tokens)

Each node represents one atomic reasoning step. Not "observe, analyse, and decide" but three separate nodes: A[Observe constraint] → B[Analyse feasibility] → C[Decide strategy]. Verbose nodes reintroduce the noise that BRAID is designed to eliminate.

Privacy parallel: This is the machine-readable equivalent of spell encoding. Spells compress persona identity to ~30 characters using the three-clause grammar. BRAID nodes compress reasoning steps to <15 tokens. Both pursue maximum semantic density. Both lose regenerability if over-compressed. The sweet spot is the minimum encoding that remains unambiguous — spell validation rule 6 ("decodable back to natural language without ambiguity") applied to reasoning nodes.

Principle 2: Procedural Scaffolding (not Answer Leakage)

The graph encodes constraints and requirements, not the output text. A scaffold, not a script.

• Ineffective (leaking): C[Write: "Dear Team, I regret to inform you..."]
• Effective (scaffolding): C[Draft introduction: Acknowledge success → Pivot to news → Professional tone]

Privacy parallel: This is selective disclosure for reasoning. The graph reveals the reasoning STRUCTURE without the reasoning CONTENT. Exactly as a ZK proof reveals a property without the underlying data. The Numerical Masking Protocol — replacing all numbers in graphs with _ — is zero-knowledge for computation: prove you know HOW to solve without revealing the solution.

Principle 3: Deterministic Branching

Edges must be deterministic and mutually exclusive. A -- "If text > 300 words" --> B not A --> B. No ambiguity. No probabilistic transitions.

Privacy parallel: Consent infrastructure (IEEE 7012 / MyTerms) requires exactly this: IF consent for purpose X THEN allow ELSE block. BRAID found that nano-tier models "struggle with ambiguity." If AI agents struggle with ambiguous reasoning instructions, they will also struggle with ambiguous consent instructions. Both require deterministic branching.

Principle 4: Terminal Verification Loops

Before the final output, the graph must converge on verification nodes. Check: constraint satisfied → pass/fail → feedback edge to revision if fail. This is BRAID's "System 2 thinking emulation."

Privacy parallel: This is the Swordsman as boundary verifier. Before any output leaves the dual-agent system, check it against privacy boundaries. Before any response leaves the BRAID solver, check it against the graph's constraints. The pattern is identical:

[Generate output] → [Check: R(d) disclosure within bounds?]
  -- pass --> [Deliver]
  -- fail --> [Revise with tighter constraints] → [Re-check]

For dual-agent deployment

Swordsman reasoning (boundary enforcement graphs)

The Swordsman needs to reason about boundaries quickly and cheaply — every data access request triggers a boundary check. BRAID enables this:

1. One-time generation: A capable model generates BRAID graphs for each boundary-checking pattern (data access evaluation, consent verification, separation violation detection).
2. Guild validation: The Cipher guild validates the graphs for correctness and completeness.
3. Cached deployment: Graphs stored as immutable holons in the guild library.
4. Nano execution: Each boundary check is a nano-tier model executing the cached graph. Cost: fractions of a cent. Speed: milliseconds.

The Swordsman doesn't need to "think" about boundary enforcement — it needs to execute a pre-validated decision tree. BRAID provides exactly that.

Mage reasoning (delegation graphs)

The Mage needs to reason about delegation — which external service to use, what capabilities to advertise, how to coordinate with other agents. BRAID enables split-architecture delegation:

1. One-time generation: A capable model generates BRAID graphs for each delegation pattern (service selection, capability matching, coordination protocol).
2. Contextual caching: Unlike boundary graphs (which are mostly static), delegation graphs may be context-specific. But many delegation patterns repeat — "find cheapest provider for X" is the same graph regardless of what X is.
3. Lightweight execution: Mage-tier models execute delegation graphs at scale.

Oracle reasoning (mediation graphs)

The Oracle mediates between Swordsman and Mage. BRAID graphs for Oracle reasoning encode the mediation logic: when to pass Swordsman signals to Mage, when to block, when to transform.

BRAID economics for privacy agents

The Golden Quadrant applied to privacy:

Configuration	PPD Range	Privacy Parallel
Expensive generator + cheap solver	30–74× baseline	High privacy infrastructure + low marginal operations
Expensive generator + expensive solver	~1–2× baseline	Over-engineered monolith
Cheap generator + cheap solver	Low absolute	Under-invested — reasoning quality suffers
Cheap generator + expensive solver	~1–3× baseline	Wasteful — expensive execution of poor plans

For guild economics: A guild that invests in generating and validating high-quality BRAID graphs (expensive one-time cost, shared across all members) creates an economic asset that benefits every member through cheap execution. This is the reasoning-layer implementation of guild value: membership grants access to validated reasoning infrastructure.

Token mapping:

• Generating a BRAID graph that the guild validates and caches = earning MAGE tokens (delegation value created)
• Executing a BRAID graph correctly = demonstrating capability (armor tier progression)
• Graph library size and validation quality = guild reputation (stratum weight in network topology)

Integration with holonic architecture

BRAID graphs stored as holons gain persistence, multi-provider replication, and shared-parent library structure:

• Graph holon (immutable): HolonType: ReasoningGraph. MetaData carries the Mermaid code, domain, benchmark accuracy, validation status. ProviderUniqueStorageKey maps to IPFS (permanent), MongoDB (fast), Zcash (integrity proof).
• Library holon (shared parent): One parent per guild domain. Children = individual reasoning graphs. LoadHolonsForParentAsync(libraryId, HolonType.ReasoningGraph) loads the full library.
• Execution telemetry holon (versioned): Records which graphs were executed, by which agents, with what accuracy. Used for graph quality monitoring and dynamic re-planning triggers.

The compression spectrum (updated)

BRAID adds a 7th layer to the narrative compression hierarchy:

Layer	Form	Ratio	Reader	Purpose
1. Experience	Raw encounters	1:1	Person who lived it	Source truth
2. Story	24 acts	~10:1	Human reader	Transmit motivation
3. Proverb	Single statement	~70:1	Any human	Transmit principle
4. Equation	V(π,t) = ...	~500:1	Formal reader	Transmit relationships
5. Spell	☯️🔷→🆔⊥📦	~1000:1	Agent-to-agent	Transmit identity
6. BRAID graph	Mermaid DAG	~50:1 from CoT	Solver agent	Transmit reasoning
7. Skill file	SKILL.md	varies	Agent runtime	Transmit capability

Layer 6 compresses reasoning for agents the way Layer 2 compresses experience for humans. Both achieve "learn once, reuse everywhere" through different encoding strategies. The Chronicler encodes knowledge in stories that regenerate understanding. The Architect encodes reasoning in graphs that regenerate correct inference.

BRAID as a service (2026-09-12 update)

The paper came home as a product. OpenServ, the company of the BRAID authors, ships SERV Reasoning: an inference API at https://inference-api.openserv.ai where every call runs through a generated bounded reasoning prompt before it reaches the upstream model. Read on 2026-09-12 from docs.openserv.ai; not called; nothing below is a measurement.

what shipped	as documented	which principle it is
the reasoning step	every request is transformed into a bounded reasoning prompt, cached per organisation on prompt + version; a system prompt is required or the call is rejected	the Generator/Solver split, with the Generator on the vendor's side
raw mode	header x-openserv-disable-braid: true bypasses the whole layer, billed at the upstream tier	the control arm of any experiment
serv_shadow_agent	a validator judges the draft against the request; fail → the upstream model revises, up to max_iterations (1–10, default 3); exhausted → the last revision is returned; abort → 502	Principle 4, terminal verification, run inside the provider's call and tuned by the caller's hint
-serv-multipath	a model-id suffix for branching rulebooks; "transforms reasoning only, does not execute branches or authorise actions"	Principle 3, deterministic branching, with the decision left to the application
-serv-kronos	audits the generated reasoning prompt for semantic problems and repairs it, re-audits, up to an internal limit	a critic on the Generator's artefact
serv_prompt_guard	evaluates the generated reasoning prompt against the user-controlled request; injection → an endpoint-shaped refusal, no upstream call	a boundary at the reasoning prompt
endpoints	/v1/chat/completions (all models), /v1/responses (OpenAI only), /v1/messages (Anthropic shape, most models); Bearer auth; response_format json_schema strict on chat completions	one code path for a multi-provider catalogue
the console	usage, a Safety report, a Shadow Agent report, billing; a request can carry several billable components (upstream inference, reasoning generation, guard, audit or repair, shadow validation)	the PPD denominator, itemised

The graph you cannot see. The caller never receives the reasoning graph. It is generated, cached and audited on the vendor's side; the audit trail lives in their console. Two consequences for this skill. Layer 6 of the compression spectrum, as a service, fails the regenerability rule (spell validation rule 6: decodable without ambiguity) unless the graph is returned. And the cached reasoning prompt is not a holon: it has no GUID, no provider-independent storage key, no guild validation, and it can change under you with a prompt version. The library-holon design in this skill remains the sovereign alternative, not a redundancy.

The harness seat. The dual-agent harness (dual-agent-harness) is target-agnostic; a driver decides which model holds which seat, and run.json records phiInference, the same Φ the Zero Spellbook writes for Generator ⊥ Solver. SERV fits as one optional API driver and nowhere else:

• a drivers/serv.mjs needs Bearer auth, a system message on every call (the seat contract line), /v1/chat/completions with strict json_schema, no fallback beta, and per-call usage logged into the round record;
• the Shadow Agent is not the Gap. It is a critic inside the provider's call, tuned by the caller's own hint. The Gap stays engine-side: the Fiat-Shamir seed is drawn after the proposals commit;
• one seat, never both, never the default. SERV in both seats puts proposer and prover behind one intermediary that reads both prompts; Φ_inference must be computed over observers, not over model ids. The honest shapes are the split pattern (proposer on SERV, prover local) or SERV against a local model;
• their audit trail is REPORTED tier. The console's reports are the vendor's record of the vendor's artefact. The round's admissible record is the files the runner writes and tools/verify_run.mjs replays.

The round that measures C8. Conjecture C8 ("BRAID compression reduces R_max", 45%, active) has waited since February for a number. The vendor's own tutorial, "Compare Raw mode with SERV", is that experiment once it is run as a harness round: same instance, same seat, same model, raw versus SERV, the census as the gate, tokens emitted under each recorded in the lane's own file. One round, two runs, one row. It needs a key and credits, so the run is the First Person's.

Three braids, one word. (i) BRAID, capitals: the paper and, since 2026, the SERV Reasoning API; external, cited, never owned. (ii) Holonic BRAID: this corpus's own synthesis, made on 2026-02-26 when the BRAID analysis and the OASIS holonic analysis were written together: reasoning graphs kept as holons (holonic_reasoning). Act XXIV's "they never met, they discovered the same thing" is its founding line; the overlap was made on purpose, so it carries its date. (iii) the braid, lowercase, in UOR: the non-abelian braid generators of the UOR Atlas and the harness's "UOR/holonic braid reasoning" (κ-chain, folding accumulator, boundary-encodes-bulk; universe/SEATS.md, 2026-07-10). agentprivacy-ring-algebra already guards (iii) against being read as the Z/64Z ring, and uor_kappa_mage/CONNECTIONS.md files the homomorphism at coincidence level: "siblings on that ground, cited under plurality-over-precedence, not forced into one object". Rule: capitals for the paper and the product; Holonic BRAID, dated, for the synthesis; lowercase for the fold. Nothing is renamed. When the vendor's word moves, the corpus's does not; the paper's numbers are never borrowed for the fold.

Lore. Act XXIV The Holographic Bound (the Drake brings the graph; "Compression is not loss. Compression is defence."; "The Drive has always been a BRAID graph"), Zero Tale 30 Axis 3 (Φ_inference(Γ) = separation(Generator, Solver)), the labs ecosystem card (2026-09-12, "seat driver designed, unrun · no endorsement implied"), and a proposed City act, The Graph You Cannot See, unbound.

Open problems

1. Privacy of reasoning graphs. A BRAID graph reveals the reasoning structure even if not the content. In dark-forest environments, revealing that you're reasoning about ZKP soundness (vs delegating to a service) leaks strategic information. How to encrypt reasoning topology while preserving executability?
2. Adversarial graph injection. If an attacker can substitute a malicious BRAID graph for a cached one, they control the agent's reasoning. Graph integrity verification is critical — holonic versioning + guild validation + provider checksums, but formal guarantees needed.
3. Dynamic re-planning with separation preservation. BRAID's proposed Topology Error → re-plan loop must not violate separation constraints. The Solver must signal failure through the bounded channel without leaking WHY it failed (which might reveal sensitive reasoning state).
4. Spellbook-to-BRAID compilation. Is there a formal translation from narrative spellbook proverbs to executable BRAID graphs? If a proverb can regenerate an equation, and an equation can generate a BRAID graph, then proverb → BRAID is a two-step compilation chain. Can it be made one step?
5. PPD for privacy-specific benchmarks. BRAID's benchmarks (GSM-Hard, SCALE, AdvancedIF) test general reasoning. How does PPD change for privacy-specific tasks (boundary evaluation, consent verification, separation checking)? Hypothesis: privacy reasoning is more structured than general reasoning, so BRAID gains should be even larger.
6. The BRAID Parity ceiling. At what point does structure stop compensating for capacity? Is there a task complexity threshold above which even optimal BRAID graphs cannot bridge the model-tier gap? If so, this sets the minimum model tier for sovereign agents.
7. The graph you cannot see (2026-09-12). BRAID as a service never returns the generated graph; the audit trail is the vendor's. What is the minimum the API must return (the graph, a hash of it, a version id) for a round to be replayable from bytes the reader holds?
8. One intermediary, two seats (2026-09-12). When both seats of a dual-agent loop run through one provider, Φ_inference over model ids is 1 and over observers is 0. Which of the harness's ledgers can detect that from the run files alone?

Verify: agentprivacy.ai · sync.soulbis.com · BRAID: arXiv:2512.15959 · benchmark.openserv.ai · SERV docs: docs.openserv.ai (read 2026-09-12, not run)

Provenance

Forkable skill page migrated from the agentprivacy skills repo (persona/agentprivacy-braid-reasoning, v5.1).
Source of truth: agentprivacy-skills. Fork this page to materialize a local SKILL.md via fedwiki-to-skill.

origin: 0xagentprivacy · author: Mitchell Travers

Assets

Navigation

← Welcome Visitors · Role Skills