InfraFabric — Anthropic addendum (system explainer)
Danny Stocker Anthropic Fellowship Submission – January 2026 Track: AI Safety / Safety Engineering (Safety / Security – Runtime Governance & Verifiable Oversight) danny.stocker@gmail.com | ds@infrafabric.io | +33 6 52 48 90 17
Document 02 of 03 Architecture (dependency graphs + module map; ~20 min)Reading order: 01 (evidence) → 02 (you are here) → 03 (optional narrative)Prerequisite: read Document 01 first (and run “Proof in 60 seconds” if you want a quick integrity check).Meta-note: Document 01 contains a factual `if.knowledge` disclosure (v1 docs pipeline + v2 concept graph; task-board timestamps).
Project homepage https://infrafabric.io
LLM review access (task board, session ledger, registry) https://infrafabric.io/llm/
Document 02_InfraFabric-System-Explainer-2026012-0600CET
A system map with receipts: fewer vibes, more verifiable bytes.
Generated (UTC): 2026-01-12T05-17-58Z · Author: Danny Stocker (InfraFabric) · Single-file HTML · No browser login required
How to read this (black/white)
Receipts for integrity; skepticism for everything else.
This document is designed for reviewers in restrictive environments.
Verified public artifacts and their byte integrity when receipt-backed.Not verified factual correctness, safety, compliance, or intent (unless explicitly proven elsewhere).Status source product_id/path/kind/status come from the canonical registry.
Intro (A/B)
Two tones, one constraint: if it can’t be audited, it doesn’t count.
Two tone variants for the same system: both are black/white and registry-driven.
Intro A (plain)
For the meeting minutes: plain words, fewer loopholes.
InfraFabric is a set of products/modules designed to make outputs and decisions legible to non-experts. The core posture is simple: when an output matters, publish an artifact that third parties can verify without accounts. Integrity (bytes match the hash) is verifiable; truth, correctness, compliance, safety, and intent are not implied.
This single-file addendum is a navigation and context layer: it maps products from the registry, shows a dependency graph, and embeds the relevant review-pack text so reviewers aren’t blocked by link failures.
Intro B (direct)
For the war room: blunt words, same constraints.
The point is not to ship more pages. The point is to ship fewer lies. If a system can’t be audited by a nurse or a farmer, it isn’t constitutional “for the subjects” — it’s just another black box with better marketing.
InfraFabric treats verification as a product surface: publish artifacts, prove integrity without logins, preserve dissent and constraints, and make it cheap for reviewers to say “yes” or “no” based on evidence, not vibes.
Entry points (one URL per line)
No scavenger hunt: here are the doors.
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v6.2/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/index.html
https://infrafabric.io/llm/
https://infrafabric.io/llm/if.registry.json
https://infrafabric.io/llm/task-board.html
https://infrafabric.io/llm/session-state.html
https://infrafabric.io/static/hosted/evidence/index.html
Product tree
If we can’t point to the URL, it’s a rumor, not a surface.
Public + reviewer surfaces. Some registry SKU paths are not deployed pages yet.
infrafabric.io
├── /if
│ ├── gov/ (if.gov; preview; product)
│ │ └── council/ (if.gov.council; roadmap; sku)
│ │ └── council/extended/ (if.gov.council.extended; roadmap; sku)
│ │ └── triage/ (if.gov.triage; roadmap; sku)
│ ├── trace/ (if.trace; shipped; product)
│ ├── security/ (if.security; roadmap; module)
│ │ └── secrets/detect/ (if.security.secrets.detect; preview; module)
│ ├── bus/ (if.bus; roadmap; product)
│ ├── api/ (if.api; roadmap; product)
│ ├── emotion/ (if.emotion; preview; product)
│ ├── typeset/ (if.typeset; preview; product)
│ ├── kb/ (if.kb; preview; module)
│ ├── knowledge/ (if.knowledge; roadmap; module)
│ ├── story/ (if.story; roadmap; module)
│ ├── search/ (if.search; roadmap; module)
│ ├── intelligence/ (if.intelligence; roadmap; module)
│ └── swarm/ (if.swarm; roadmap; module)
├── /review
│ └── shadowrt/ (if.shadowrt; shipped; surface)
├── /llm
│ ├── if.registry.json
│ ├── task-board.html
│ ├── session-state.html
│ └── products/
│ ├── if-api/
│ ├── if-bus/
│ ├── if-emotion/
│ ├── if-gov/
│ ├── if-intelligence/
│ ├── if-kb/
│ ├── if-knowledge/
│ ├── if-search/
│ ├── if-security/
│ ├── if-story/
│ ├── if-swarm/
│ ├── if-trace/
│ └── if-typeset/
└── /static/hosted/review
└── infrafabric-anthropic-addendum/
└── 2026-01-11/
├── index.html (v5; single-file)
└── v6.2/index.html (this doc)
Conceptual stack (Graphviz)
The trust stack: contracts up top, receipts underneath, excuses nowhere.
Design-intent diagram (not a registry dependency graph).
if_concept_stack
cluster_decision
Decision contracts
cluster_integrity
Integrity + posture
cluster_transport
Transport + integration
cluster_support
Supporting surfaces
if.gov
if.gov
if.trace
if.trace
if.gov->if.trace
bind packs to receipts
if.security
if.security
if.gov->if.security
evidence posture + actuation gates
if.bus
if.bus
if.bus->if.trace
receipt-bind outputs
if.bus->if.security
security_signal posture
if.api
if.api
if.api->if.bus
adapters (envelopes)
if.shadowrt
if.shadowrt
if.shadowrt->if.trace
publishes / routes to receipts
if.typeset
if.typeset
if.typeset->if.trace
review packs / deterministic docs
if.emotion
if.emotion
if.story
if.story
if.knowledge
if.knowledge
if.kb
if.kb
if.knowledge->if.kb
build-time generation
if.search
if.search
if.intelligence
if.intelligence
if.swarm
if.swarm
if.security.secrets.detect
if.security
secrets.detect
Graphviz DOT source (conceptual stack) digraph if_concept_stack {
rankdir=TB;
graph [bgcolor="transparent", pad="0.2", nodesep="0.35", ranksep="0.55", fontname="Inter,Arial"];
node [shape=box, style="rounded,filled", fontname="Inter,Arial", fontsize=12, color="#2d3748", penwidth=1, fillcolor="#f7fafc"];
edge [color="#4a5568", arrowsize=0.7, penwidth=1, fontname="Inter,Arial", fontsize=10];
subgraph cluster_decision {
label="Decision contracts";
color="#e2e8f0";
style="rounded";
"if.gov" [fillcolor="#bee3f8"];
}
subgraph cluster_integrity {
label="Integrity + posture";
color="#e2e8f0";
style="rounded";
"if.trace" [fillcolor="#c6f6d5"];
"if.security" [fillcolor="#edf2f7"];
}
subgraph cluster_transport {
label="Transport + integration";
color="#e2e8f0";
style="rounded";
"if.bus" [fillcolor="#edf2f7"];
"if.api" [fillcolor="#edf2f7"];
}
subgraph cluster_support {
label="Supporting surfaces";
color="#e2e8f0";
style="rounded";
"if.shadowrt";
"if.typeset" [fillcolor="#bee3f8"];
"if.emotion" [fillcolor="#bee3f8"];
"if.story";
"if.knowledge";
"if.kb" [fillcolor="#bee3f8"];
"if.search";
"if.intelligence";
"if.swarm";
"if.security.secrets.detect" [fillcolor="#bee3f8", label="if.security\nsecrets.detect"];
}
// Conceptual edges (design intent). These are not registry dependencies.
"if.gov" -> "if.trace" [style=dashed, label="bind packs to receipts"];
"if.gov" -> "if.security" [style=dashed, label="evidence posture + actuation gates"];
"if.bus" -> "if.trace" [style=dashed, label="receipt-bind outputs"];
"if.bus" -> "if.security" [style=dashed, label="security_signal posture"];
"if.api" -> "if.bus" [style=dashed, label="adapters (envelopes)"];
"if.shadowrt" -> "if.trace" [style=dashed, label="publishes / routes to receipts"];
"if.typeset" -> "if.trace" [style=dashed, label="review packs / deterministic docs"];
"if.knowledge" -> "if.kb" [style=dashed, label="build-time generation"];
}
Dependency graph (Graphviz; registry-derived)
Because dependencies don’t care about your slide deck.
This graph uses only registry uses_receipts_from edges.
if_registry
cluster_core
core
cluster_support
supporting modules
cluster_gov_skus
if.gov SKUs (registry entries)
cluster_legend
legend
if.gov
if.gov
if.trace
if.trace
if.gov->if.trace
uses_receipts_from
if.security
if.security
if.security->if.trace
uses_receipts_from
if.bus
if.bus
if.api
if.api
if.shadowrt
if.shadowrt
if.shadowrt->if.trace
uses_receipts_from
if.search
if.search
if.search->if.trace
uses_receipts_from
if.intelligence
if.intelligence
if.intelligence->if.trace
uses_receipts_from
if.swarm
if.swarm
if.swarm->if.trace
uses_receipts_from
if.story
if.story
if.story->if.trace
uses_receipts_from
if.knowledge
if.knowledge
if.knowledge->if.trace
uses_receipts_from
if.kb
if.kb
if.kb->if.trace
uses_receipts_from
if.typeset
if.typeset
if.security.secrets.detect
if.security.secrets.detect
if.security.secrets.detect->if.trace
uses_receipts_from
if.emotion
if.emotion
if.emotion->if.trace
uses_receipts_from
if.gov.triage
if.gov.triage
if.gov.triage->if.trace
uses_receipts_from
if.gov.council
if.gov.council
if.gov.council->if.trace
uses_receipts_from
if.gov.council.extended
if.gov.council.extended
if.gov.council.extended->if.trace
uses_receipts_from
legend_shipped
shipped
legend_preview
preview
legend_roadmap
roadmap
Graphviz DOT source (registry-derived) digraph if_registry {
rankdir=LR;
graph [bgcolor="transparent", pad="0.2", nodesep="0.25", ranksep="0.45", fontname="Inter,Arial"];
node [shape=box, style="rounded,filled", fontname="Inter,Arial", fontsize=11, color="#2d3748", penwidth=1];
edge [color="#718096", arrowsize=0.7, penwidth=1];
subgraph cluster_core {
label="core";
color="#e2e8f0";
style="rounded";
"if.gov" [fillcolor="#bee3f8", tooltip="preview product"];
"if.trace" [fillcolor="#c6f6d5", tooltip="shipped product"];
"if.security" [fillcolor="#edf2f7", tooltip="roadmap module"];
"if.bus" [fillcolor="#edf2f7", tooltip="roadmap product"];
"if.api" [fillcolor="#edf2f7", tooltip="roadmap product"];
}
subgraph cluster_support {
label="supporting modules";
color="#e2e8f0";
style="rounded";
"if.shadowrt" [fillcolor="#c6f6d5", tooltip="shipped surface"];
"if.search" [fillcolor="#edf2f7", tooltip="roadmap module"];
"if.intelligence" [fillcolor="#edf2f7", tooltip="roadmap module"];
"if.swarm" [fillcolor="#edf2f7", tooltip="roadmap module"];
"if.story" [fillcolor="#edf2f7", tooltip="roadmap module"];
"if.knowledge" [fillcolor="#edf2f7", tooltip="roadmap module"];
"if.kb" [fillcolor="#bee3f8", tooltip="preview module"];
"if.typeset" [fillcolor="#bee3f8", tooltip="preview product"];
"if.security.secrets.detect" [fillcolor="#bee3f8", tooltip="preview module"];
"if.emotion" [fillcolor="#bee3f8", tooltip="preview product"];
}
subgraph cluster_gov_skus {
label="if.gov SKUs (registry entries)";
color="#e2e8f0";
style="rounded";
"if.gov.triage" [fillcolor="#edf2f7"];
"if.gov.council" [fillcolor="#edf2f7"];
"if.gov.council.extended" [fillcolor="#edf2f7"];
}
"if.shadowrt" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.search" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.intelligence" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.swarm" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.story" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.knowledge" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.kb" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.gov" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.gov.triage" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.gov.council" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.gov.council.extended" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.security" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.security.secrets.detect" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
"if.emotion" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
subgraph cluster_legend {
label="legend";
color="#e2e8f0";
style="rounded";
"legend_shipped" [label="shipped", fillcolor="#c6f6d5"];
"legend_preview" [label="preview", fillcolor="#bee3f8"];
"legend_roadmap" [label="roadmap", fillcolor="#edf2f7"];
"legend_shipped" -> "legend_preview" [style=invis];
"legend_preview" -> "legend_roadmap" [style=invis];
}
}
Security posture (why so much?)
Security is expensive; breach optics are a subscription you can’t cancel.
Security isn’t a tax; it’s a seatbelt. It is insurance against silent failure: it reduces likelihood and blast radius, and makes incidents auditable rather than invisible.
In InfraFabric terms: when something goes wrong, the system should emit structured signals, preserve decision context, and produce artifacts that can be verified without privileged access.
Products and modules (registry-driven)
Meet the cast: shipped, preview, roadmap — and none secured by adjectives.
Gov-first ordering; each section includes Who/Why/What/Where/When/How and embedded review-pack text when available.
if.gov preview product
Governance as files: boring on purpose, auditable by default.
path /if/gov
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Decision owners and reviewers who need audit-ready outputs that remain verifiable years later (without trusting a specific model).
Why does it exist?
Because “we meant well” isn’t an audit trail.
Make decisions reproducible: structured inputs + evidence links + deterministic checks where possible; optional LLM drafting is treated as untrusted.
What is it?
Define the thing, then we can argue about it.
Decision-pack contracts (preview demos) + governance seat models (design target).
Where does it live?
No URL, no audit — just vibes.
Public product page + decision-pack demo + council seats pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Preview: demo packs exist; the multi-tier SKUs are registry entries (roadmap) and do not have deployed pages yet.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Emit a decision pack as files; bind integrity to if.trace receipts; treat actuation gating as an evidence-typed design target (defined in if.security posture).
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/gov/
https://infrafabric.io/llm/products/if-gov/
Cost posture (token burn → deterministic)
Tokens are a budget line item, not a personality trait.
Portfolio-style seats are useful if (and only if) they are a progressive engineering path: start with structured outputs, then replace expensive simulation with deterministic checkers. The goal state is reproducible governance with minimal or zero token cost.
Numbers below are illustrative heuristics (not measured on this host):
Phase LLM usage Typical token profile Goal 1 (bootstrap) LLM-heavy ~5–20 seats; structured JSON outputs Collect decision data + failure modes 2 (structured) LLM + validation Schema-linted seat outputs Reduce sprawl; increase determinism 3 (hybrid) Checkers gate actuation LLM only for narrative drafts Lower cost; higher auditability 4 (deterministic) Optional 0 required tokens Reproducible decisions without model lock-in
Embedded LLM review pack content
if.gov — review pack
Governance, bundled: what we claim, what we can prove, and where to poke holes.
product_id if.gov
status preview
updated 2026-01-11
What it is (plain)
The job description, minus the marketing.
if.gov is governance-as-a-pack: triage and decision packs designed for adversarial review.
Purpose make decisions checkable later: explicit assumptions, risks, controls, deltas, and evidence links.
Receipt-bound outputs can be bound to if.trace so third parties can verify bytes without logins.
SKUs
Pick the scope; the accountability stays.
if.gov.triage deliberation target: milliseconds (status: roadmap)
if.gov.council deliberation target: milliseconds (status: roadmap)
if.gov.council.extended deliberation target: adaptive ms → minutes (status: roadmap)
Note: the SKU naming exists in the registry; the public demo evidence below currently covers the decision-pack shape. Treat the SKUs as spec-level
until standalone demo packs exist.
Black / white
Receipts prove bytes; they don’t prove virtue.
Receipts prove integrity: the bytes you download match the receipt hashes (and signatures only where present and verifiable).
Receipts do not prove compliance, policy effectiveness, safety, or factual correctness.
if.gov adds structured decision framing: scope, assumptions, risks, controls, and deltas — packaged for third-party critique.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
What’s missing (to ship the SKUs)
Specs are cheap; shipping is the tax.
Seat templates standardized seat charters + triggers + required artifacts.
Schemas transcript/vote/research artifact schemas that can be verified and diffed.
Reference runner runnable reference implementation for the pack lifecycle.
Standalone demos separate public demo packs for triage/council/extended (HTML-first, receipt-bound).
Review questions (what we want from you)
Attack the claims, not the people.
Sellability is the “decision pack” deliverable buyable, and by whom?
Assumptions which parts would fail in real procurement / audit workflows?
Contrarian critique what’s the simplest wedge that gets paid?
Diffs if you’d change the pack structure, propose unified diffs.
Back
Back to the map; don’t let the appendix eat the narrative.
if.trace shipped product
Trust is optional; hashes are not.
path /if/trace
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Anyone who must verify byte integrity without accounts: auditors, partners, journalists, regulators, internal teams.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Give third parties a no-login way to verify: do the bytes match the public hash (and signature, when present and verifiable)?
What is it?
Define the thing, then we can argue about it.
Public receipt surface + offline verifier tooling; integrity proofs, not truth proofs.
Where does it live?
No URL, no audit — just vibes.
Product page + live receipt surface + offline verifier.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Shipped surface on this host.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Publish a receipt with hashes; later anyone downloads and checks sha256 matches; use QUANTUM READY only when a PQ receipt exists.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/trace/
https://infrafabric.io/llm/products/if-trace/
Embedded LLM review pack content
if.trace — review pack
Trust is optional; hash checks are not.
product_id if.trace
status shipped
updated 2026-01-06
What it is (plain)
The job description, minus the marketing.
if.trace is a public, no-login receipt surface that binds source_sha256 ↔ output_sha256 to a stable shareId.
Purpose prove byte integrity across handoffs (email, tickets, vendors, auditors) without granting internal access.
Black / white
Receipts prove bytes; they don’t prove virtue.
Receipts prove the bytes you download match the hashes on the receipt (and signatures only when present and verifiable).
Receipts do not prove factual correctness, compliance, safety, intent, or “no hallucinations”.
Practical wedge you can prove the AI output (or PDF) you reviewed is exactly the one that shipped.
QUANTUM READY means: a post-quantum signature receipt exists for the trace; it is not a claim of quantum security.
Fast verify (60 seconds)
Set a timer, check the hash, move on.
Open a receipt and copy output_sha256.
Download the output you are checking (pack or dossier) and hash it locally.
Compare hashes. If one character changes, the hash changes and verification fails.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
Receipt surfaces (canonical)
These are the URLs that keep their promises.
Example (known-good demo):
Offline verification (bundles)
For air-gapped skeptics: same receipts, fewer assumptions.
Related surfaces
Nice-to-have context, not required faith.
Review questions (what we want from you)
Attack the claims, not the people.
UX is the receipt page enough for a third-party to verify in 60 seconds?
Truth claims is black/white wording strict enough (integrity only)?
Pricing do retention/privacy/SLA/volume knobs map to value?
Threat model does this cover adversarial reality (insider edits, external tampering, handoff drift) without overclaiming?
Back
Back to the map; don’t let the appendix eat the narrative.
if.security roadmap module
Security posture: rules we can point to before the incident.
path /if/security
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Builders who need a consistent, cross-cutting security posture across modules (not bespoke per product).
Why does it exist?
Because “we meant well” isn’t an audit trail.
Security isn’t a tax; it’s a seatbelt. It’s insurance against silent failure: it reduces likelihood and blast radius, and makes incidents auditable.
What is it?
Define the thing, then we can argue about it.
Cross-cutting posture doc (roadmap): evidence typing, containment levels, and how modules emit/consume security signals.
Where does it live?
No URL, no audit — just vibes.
Public module page + posture snapshot pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: posture exists; enforcement is a design target implemented module-by-module.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Standardize security signals, define evidence posture + actuation gates, and map containment actions onto module control planes.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/security/
https://infrafabric.io/llm/products/if-security/
Embedded LLM review pack content
if.security — review pack
Posture before panic: boundaries, threat model, and receipts-friendly evidence.
product_id if.security
status roadmap
updated 2026-01-11
What it is (plain)
The job description, minus the marketing.
if.security is the cross-cutting posture for how modules describe security-relevant findings without over-claiming.
Primitive the shared atomic unit is if.bus.security_signal (redacted; public-safe).
Actuation posture containment reuses if.bus control-plane commands; high-impact actions can escalate to if.gov.
Black / white
Receipts prove bytes; they don’t prove virtue.
Verified a posture doc + schemas can be reviewed and diffed (static artifacts).
Not claimed a deployed security runtime exists on this host.
Receipts prove integrity (hash match), not truth, correctness, safety, or compliance.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
Review questions (what we want from you)
Attack the claims, not the people.
Minimum is if.bus.security_signal sufficient, or is a second schema required for security actions?
Automation what would you require before allowing automated CONTAIN/HALT actions on a bus control plane?
Scope what is the smallest security posture that is still worth adopting across modules?
Back
Back to the map; don’t let the appendix eat the narrative.
if.bus roadmap product
Make the safe path the easy path, or nobody takes it.
path /if/bus
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Platform/integration teams who want integrations to be boring: one envelope, predictable outputs, auditable failure modes.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Make the compliant path the easy path: budgets, security signals, DLQ, replay controls, and receipt binding are part of the contract.
What is it?
Define the thing, then we can argue about it.
Transport-agnostic bus contract (roadmap) + runtime spec and sandbox artifacts.
Where does it live?
No URL, no audit — just vibes.
Product page + whitepaper + runtime spec + sandbox pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: architecture/specs + sandbox exist; not shipped as a shared live bus service on this host.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Stable envelope schema; separate data-plane from control-plane; implement transport adapters (in_memory / NATS JetStream reference).
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/bus/
https://infrafabric.io/llm/products/if-bus/
Embedded LLM review pack content
if.bus — review pack
Make compliance the easy path, then ship the pipes.
product_id if.bus
status roadmap
updated 2026-01-11
What it is (plain)
The job description, minus the marketing.
if.bus is the integration backbone: normalize events, route them, and make outputs verifiable by default.
Two-way street inbound webhooks and outbound actions flow through the same envelope (via if.api adapters).
Status architecture exists; not shipped as a runnable bus on the current single-host deployment.
Black / white
Receipts prove bytes; they don’t prove virtue.
Claim a bus makes integrations boring: one adapter per system, one envelope, predictable outputs.
Verification outputs can be bound to if.trace receipts (integrity only).
Not claimed a live deployed bus service exists (unless a runnable demo is linked).
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
What’s missing (to ship)
The gap list: where roadmap meets reality.
Contracts canonical envelope schema + versioning policy.
Adapters shipped if.api adapters for at least 2–3 real systems.
Runnable demo end-to-end bus demo (ingress → route → output) with receipt-backed artifacts.
Ops story rate limiting, replay protection, and failure-mode clarity.
Review questions (what we want from you)
Attack the claims, not the people.
Wedge is the “integration backbone” story compelling without a running demo?
Buyer who pays for this: platform teams, security, compliance, product ops?
Simplicity what’s the minimum bus that is still worth buying?
Back
Back to the map; don’t let the appendix eat the narrative.
if.api roadmap product
APIs as contracts: fewer surprises, more receipts.
path /if/api
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Teams integrating external systems who want adapters to be deterministic, reviewable, and inventory-tracked.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Stop bespoke glue code: normalize webhooks/actions into a shared envelope and keep a public integration inventory.
What is it?
Define the thing, then we can argue about it.
Adapter/integration layer (roadmap) with demo artifacts where available.
Where does it live?
No URL, no audit — just vibes.
Product page + integrations inventory + demo packs.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: demos and inventories exist; not shipped as a general-purpose runtime adapter service.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Adapters transform provider payloads to/from if.bus envelopes; demos publish reproducible bundles.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/api/
https://infrafabric.io/llm/products/if-api/
Embedded LLM review pack content
if.api — review pack
APIs as contracts: fewer surprises, more audit trails.
product_id if.api
status roadmap
updated 2026-01-10
What it is (plain)
The job description, minus the marketing.
if.api is an integration inventory + adapter concept for external APIs (webhooks in; actions out).
Purpose make integrations repeatable: stable contracts, predictable transforms, and fewer “one-off scripts”.
Status public artifacts exist; not shipped as a general-purpose integration runtime on the current host.
Black / white
Receipts prove bytes; they don’t prove virtue.
Claim adapters should be boring: one per system, mapped to a shared envelope.
Verification demo outputs can be bound to if.trace receipts (integrity only).
Not claimed a comprehensive adapter library exists today.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
What’s missing (to ship)
The gap list: where roadmap meets reality.
Adapter quality bar “official” adapter criteria (schema/versioning/error contracts).
Coverage initial 2–3 core systems end-to-end (GitHub/Jira/Slack etc.).
Runtime a stable adapter runner with retries, replay protection, and audit logs.
Review questions (what we want from you)
Attack the claims, not the people.
Buyer is this owned by platform, product ops, security, or compliance?
Simplicity what’s the smallest integration library worth paying for?
Positioning should this be sold as “inventory + contracts” first, before runtime?
Back
Back to the map; don’t let the appendix eat the narrative.
if.emotion preview product
High-stakes domain: we’d rather be cautious than clever.
path /if/emotion
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Product and governance builders needing wellbeing-aware outputs with explicit safety boundaries.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Sensitive UX requires auditability and clear non-clinical boundaries.
What is it?
Define the thing, then we can argue about it.
Wellbeing-aware interaction layer and governance-seat outputs (preview).
Where does it live?
No URL, no audit — just vibes.
Review hub + evidence index + receipts (when published).
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Preview: boundary posture exists; deeper demos should remain explicitly non-clinical.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Bind outputs to receipts when publishing; keep claims black/white (integrity vs interpretation).
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/emotion/
https://infrafabric.io/llm/products/if-emotion/
Embedded LLM review pack content
if.emotion — review pack
High-stakes domain: scope, safety boundary, and evidence first.
product_id if.emotion
status preview
updated 2026-01-06
What it is (plain)
The job description, minus the marketing.
if.emotion is a wellbeing-aware interaction layer and governance-seat output layer with explicit safety boundaries.
Purpose make sensitive UX and governance outputs audit-ready (what was shown, what changed, what was decided) without drifting into clinical claims.
Black / white (safety boundary)
Safety boundary: what we do, what we refuse, and what we won’t pretend.
Not clinical this is not diagnosis, therapy, or crisis services.
Verified (when receipt-backed) integrity of published outputs via if.trace (bytes, not correctness).
Not verified mental health outcomes, safety guarantees, or correctness of interpretation.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
What’s missing (to ship cleanly)
The last mile is where good intentions go to get linted.
Claims truth table approved vs disallowed phrases for public docs and UI (no clinical drift).
Receipt-backed demo a sanitized, explicitly non-clinical demo pack bound to an if.trace receipt.
Consent + data boundaries explicit data-handling modes and redaction rules for any published artifacts.
Review questions (what we want from you)
Attack the claims, not the people.
Safety is the boundary clear enough to avoid accidental clinical claims?
Value who buys this, and why (governance teams, org wellbeing, product safety)?
Proof story what would a third party need to verify (and what should never be published)?
Back
Back to the map; don’t let the appendix eat the narrative.
if.typeset preview product
Reproducible documents: fewer PDFs-as-folklore.
path /if/typeset
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Anyone shipping review packs who needs deterministic, repeatable document builds.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Make docs survive adversarial review: deterministic builds + lint gates + consistent packaging.
What is it?
Define the thing, then we can argue about it.
Deterministic doc pipeline (preview).
Where does it live?
No URL, no audit — just vibes.
Product page + review pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Preview: tooling exists and is used for hosted-static packs.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Lint → render → QA incidents → ship packs (HTML-first fallbacks).
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/typeset/
https://infrafabric.io/llm/products/if-typeset/
Embedded LLM review pack content
if.typeset — review pack
Turn documents into artifacts reviewers can actually verify.
product_id if.typeset
status preview
updated 2026-01-06
What it is (plain)
The job description, minus the marketing.
if.typeset is deterministic document CI: lint → render HTML/PDF → QA incidents → trust contract.
Purpose ship documents that survive scrutiny and remain reviewable months later.
Black / white
Receipts prove bytes; they don’t prove virtue.
Verified deterministic builds and measured QA incidents (machine-readable outputs).
Not verified factual correctness, compliance, or “the narrative is true”.
Pairs with if.trace when you publish outputs for third parties to verify bytes without logins.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
Review questions (what we want from you)
Attack the claims, not the people.
DX is the demo pack self-explanatory for a third party?
Quality gates are the QA incidents meaningful and actionable?
Adoption what’s missing for teams to run this in CI with confidence?
Wedge is “scrutiny-proof publishing” a buyable problem statement?
Back
Back to the map; don’t let the appendix eat the narrative.
if.shadowrt shipped surface
Adversarial review as a surface: critique you can’t hand-wave away.
path /review/shadowrt
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Reviewers and publishers who need a navigable UI over receipt-backed artifacts.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Make review flows legible (dossiers/packs) while routing back to receipts.
What is it?
Define the thing, then we can argue about it.
Shipped review surface for browsing published artifacts.
Where does it live?
No URL, no audit — just vibes.
Public review surface.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Shipped surface on this host.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Serves HTML-first review pages that link to stable no-login receipt URLs.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/review/shadowrt/
Embedded mini-pack (generated)
Black / white
Claims in black/white; anything else is marketing.
Verified registry status + published URLs (when present).
Not verified factual correctness, safety, compliance, or intent.
if.kb preview module
If knowledge isn’t findable, it’s not knowledge; it’s lore.
path /if/kb
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Developers and reviewers who need build-time, static knowledge base pages (no runtime fetches).
Why does it exist?
Because “we meant well” isn’t an audit trail.
Keep KBs consistent and versioned by generating them at build time.
What is it?
Define the thing, then we can argue about it.
Build-time KB artifacts (preview).
Where does it live?
No URL, no audit — just vibes.
Product page + KB spec pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Preview: KB snapshots exist.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Generate static Markdown/HTML from registry + config + schemas + templates.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/kb/
https://infrafabric.io/llm/products/if-kb/
Embedded LLM review pack content
if.kb — review pack
If you can’t find it, you can’t govern it.
product_id if.kb
status preview
updated 2026-01-11
What it is (plain)
The job description, minus the marketing.
Module if.kb is a build-time pipeline for generating static developer KB pages.
Inputs registry + schemas + config + template + snippet ranges.
Outputs static Markdown + hosted-static HTML wrapper (no runtime fetches).
Black / white
Receipts prove bytes; they don’t prove virtue.
Claim registry + schema driven KBs reduce drift and keep reviewer links stable.
Verification posture KB pages are static artifacts; receipts (when referenced) prove byte integrity, not truth.
Not claimed a deployed if.kb runtime or live APIs on this host.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
Review questions
Be sharp: we can fix bugs, not flattery.
Contract should KB config files have an explicit JSON Schema (draft 2020-12) for validation?
Lint what should fail publish beyond registry + URL hygiene (secrets/PII, snippet bounds, forbidden wording)?
Scale should the KB builder be generalized to docs/data/*.json (multi-KB), or kept per product?
Back
Back to the map; don’t let the appendix eat the narrative.
if.knowledge roadmap module
The pack factory: turn scattered docs into reviewable bundles.
path /if/knowledge
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Maintainers who need deterministic, registry-driven documentation generation.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Reduce drift and manual copy-paste by generating docs from canonical inputs.
What is it?
Define the thing, then we can argue about it.
Build-time documentation pipeline (roadmap).
Where does it live?
No URL, no audit — just vibes.
Product page + spec pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: pipeline exists; expanded outputs iterate over time.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Parse registry + task board + templates to produce single-file review artifacts.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/knowledge/
https://infrafabric.io/llm/products/if-knowledge/
Embedded LLM review pack content
if.knowledge — review pack
The pack factory: generate review bundles without turning into a link farm.
product_id if.knowledge
status roadmap
updated 2026-01-11
What it is (plain)
The job description, minus the marketing.
Module if.knowledge is a build-time documentation pipeline (registry-driven).
Inputs registry + schemas + templates + deterministic generators.
Outputs static Markdown + hosted-static HTML wrappers (no runtime fetches).
Use produce reviewable artifacts quickly (specs, KB pages, and application addenda).
Black / white
Receipts prove bytes; they don’t prove virtue.
Claim build-time generation reduces drift and keeps links stable for external review.
Verification posture outputs are static artifacts; receipts (when used) prove byte integrity, not truth or correctness.
Not claimed a deployed if.knowledge service, live APIs, or runtime data fetching on this host.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
Review questions
Be sharp: we can fix bugs, not flattery.
Addendum What should be included/excluded to keep the addendum evidence-based (no “vibes”)?
Drift Which lints should be publish-blocking beyond URL hygiene + registry alignment?
Scope Should if.knowledge remain a pipeline module or evolve into a general “knowledge graph” product?
Copy/paste bundle (one URL per line)
Clipboard-ready links; your reviewer bot will thank you.
https://infrafabric.io/if/knowledge/
https://infrafabric.io/llm/products/if-knowledge/
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/index.html
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/index.md
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/artifacts/spec/90-if-knowledge-spec.md
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/artifacts/scripts/build_if_knowledge_addendum.py
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/artifacts/scripts/lint_if_knowledge_addendum.py
https://infrafabric.io/llm/products/if-knowledge/knowledge-graph/2026-01-11/index.html
https://infrafabric.io/llm/products/if-knowledge/knowledge-graph/2026-01-11/index.md
https://infrafabric.io/llm/products/if-knowledge/knowledge-graph/2026-01-11/artifacts/spec/92-if-knowledge-graph-spec.md
https://infrafabric.io/llm/products/if-knowledge/knowledge-graph/2026-01-11/artifacts/data/if_knowledge_graph.v2.json
https://infrafabric.io/static/hosted/review/infrafabric-system-map/2026-01-11/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v1/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v2/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v3/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v4/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v5/index.html
https://infrafabric.io/llm/if.registry.json
Back
Back to the map; don’t let the appendix eat the narrative.
if.story roadmap module
Narrative with guardrails: explain without hallucinating.
path /if/story
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Teams who need narrative logs that preserve the “why”, not just the “what”.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Bitmap snapshots lose reasoning; vector logs preserve constraints and rejected options.
What is it?
Define the thing, then we can argue about it.
Narrative logging protocol (roadmap).
Where does it live?
No URL, no audit — just vibes.
Product page + review pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: protocol spec exists.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Produce md+json artifacts with required metadata and lint rules.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/story/
https://infrafabric.io/llm/products/if-story/
Embedded LLM review pack content
if.story — review pack
Narrative is a tool; receipts are the seatbelt.
product_id if.story
status roadmap
updated 2026-01-11
What it is (plain)
The job description, minus the marketing.
Module if.story is a narrative logging protocol module (vector vs bitmap).
Goal preserve decision geometry (“why”), not just status snapshots (“what”).
Status roadmap (protocol note + example artifacts published; no receipt-backed demo and no deployed service).
Black / white
Receipts prove bytes; they don’t prove virtue.
Claim narratives with explicit traps reduce regression and re-derivation failure over time.
Verification posture published artifacts can be bound to if.trace receipts to verify bytes without logins.
Not claimed factual correctness, safety, intent, or a deployed if.story runtime on this host.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
Review questions
Be sharp: we can fix bugs, not flattery.
Scope where should narrative logging be mandatory (controls, policy changes, decisions) vs optional?
Trap should “trap” be required in every narrative, or maintained as a separate stop-conditions artifact?
Lint what should fail publish (missing trap, missing evidence links, mixed URLs on one line, secrets leakage)?
Back
Back to the map; don’t let the appendix eat the narrative.
if.search roadmap module
Search as method: eight passes, fewer unforced errors.
path /if/search
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Investigators needing multi-pass, evidence-linked search workflows.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Turn research into a reproducible workflow (questions → sources → outputs).
What is it?
Define the thing, then we can argue about it.
Investigation/search workflow module (roadmap).
Where does it live?
No URL, no audit — just vibes.
Product page + review pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: no deployed service on this host.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Define a multi-pass protocol and bind important outputs to receipts.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/search/
https://infrafabric.io/llm/products/if-search/
Embedded LLM review pack content
if.search — review pack
Methodology over magic: reduce unforced errors, then show your work.
product_id if.search
status roadmap
updated 2026-01-10
What it is (plain)
The job description, minus the marketing.
Module if.search is a pass-based investigation workflow (question → plan → evidence → synthesis).
Goal turn messy inputs into a traceable output that stays black/white about what is verified vs interpretation.
Status roadmap (receipt-backed demo exists; no deployed service).
Black / white
Receipts prove bytes; they don’t prove virtue.
Claim a structured investigation flow reduces “one prompt” failure modes.
Verification when outputs matter, the design target is to bind output bytes to if.trace receipts.
Not claimed a shipped, deployed if.search service exists on this host.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
Review questions
Be sharp: we can fix bugs, not flattery.
Wedge what’s the simplest “investigation workflow” story that lands with non-technical reviewers?
Next demo what should the next receipt-backed demo prove (and what should it explicitly not claim)?
Outputs what output artifact shape would be most reviewable (JSON transcript, Markdown pack, both)?
Back
Back to the map; don’t let the appendix eat the narrative.
if.intelligence roadmap module
Signal over noise — and a place to be wrong in public.
path /if/intelligence
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Teams orchestrating evidence gathering and synthesis under strong auditability constraints.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Treat research as an auditable pipeline, not vibes.
What is it?
Define the thing, then we can argue about it.
Research orchestration module (roadmap).
Where does it live?
No URL, no audit — just vibes.
Product page + review pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: not a deployed service on this host.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Coordinate searches, cite sources, and bind outputs to receipts when they matter.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/intelligence/
https://infrafabric.io/llm/products/if-intelligence/
Embedded LLM review pack content
if.intelligence — review pack
Signals, not vibes: keep the claims checkable.
product_id if.intelligence
status roadmap
updated 2026-01-10
What it is (plain)
The job description, minus the marketing.
Module if.intelligence is research orchestration: turn an inquiry into citations, constraints, and a readable answer.
Goal reduce “vibes” by grounding debate in evidence and clearly separating verified vs interpretation.
Status roadmap (receipt-backed demo exists; no deployed service).
Black / white
Receipts prove bytes; they don’t prove virtue.
Claim research should be auditable: what sources were used, what was uncertain, what was assumed.
Verification when outputs matter, the design target is to bind output bytes to if.trace receipts.
Not claimed any specific live data access exists, or that outputs are “true” (unless independently verified and cited).
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
Review questions
Be sharp: we can fix bugs, not flattery.
Scope what should be “policy-gated” vs always allowed in an evidence workflow?
Outputs what artifact formats are easiest to review (citations table, transcript, executive memo)?
Failure modes what should fail closed vs fail open in research orchestration?
Back
Back to the map; don’t let the appendix eat the narrative.
if.swarm roadmap module
Many agents, one exit condition: evidence.
path /if/swarm
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Builders coordinating multiple agents/tools while keeping outputs traceable.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Multi-agent coordination needs a contract surface and auditability.
What is it?
Define the thing, then we can argue about it.
Multi-agent execution module (roadmap).
Where does it live?
No URL, no audit — just vibes.
Product page + review pack.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: not a deployed service on this host.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Treat each agent/tool call as an auditable step, optionally receipt-bound.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/swarm/
https://infrafabric.io/llm/products/if-swarm/
Embedded LLM review pack content
if.swarm — review pack
Many perspectives, one bar: evidence you can hand to a stranger.
product_id if.swarm
status roadmap
updated 2026-01-10
What it is (plain)
The job description, minus the marketing.
Module if.swarm coordinates parallel work: scoped roles exchange bus envelopes and emit a transcript.
Goal make multi-agent execution reviewable: “what happened” is visible, not only the outcome.
Status roadmap (receipt-backed demo exists; no deployed service).
Black / white
Receipts prove bytes; they don’t prove virtue.
Claim coordination should use one envelope (if.bus) so work can be routed, replayed, and audited.
Verification when outputs matter, the design target is to bind output bytes to if.trace receipts.
Not claimed a deployed swarm runner exists on this host; the demo is a deterministic simulation only.
Evidence links (HTML-first)
If it needs a login, it’s not evidence; it’s theater.
Review questions
Be sharp: we can fix bugs, not flattery.
Outputs what transcript shape would make you trust the process (without trusting the model)?
Control what should be pausable/quarantinable/replayable by design?
Boundaries what should be banned by default (safety, policy, or operational risk)?
Back
Back to the map; don’t let the appendix eat the narrative.
if.security.secrets.detect preview module
Catch secrets in CI, not in headlines.
path /if/security/secrets/detect
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Teams who need secrets detection that is reviewable and safe to publish (redacted outputs).
Why does it exist?
Because “we meant well” isn’t an audit trail.
Prevent accidental leakage by detecting secrets before publishing artifacts.
What is it?
Define the thing, then we can argue about it.
Secrets detection module (preview; brand: if.yologuard).
Where does it live?
No URL, no audit — just vibes.
Public page + registry entry.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Preview: demo posture exists; outputs must stay redacted.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Scan inputs, emit security signals, and publish only redacted findings.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/security/secrets/detect/
Embedded mini-pack (generated)
Black / white
Claims in black/white; anything else is marketing.
Verified registry status + published URLs (when present).
Not verified factual correctness, safety, compliance, or intent.
if.gov.triage roadmap sku
Triage: fast decisions, explicit unknowns.
path /if/gov/triage
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Decision pipelines needing a fast preflight risk scan.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Catch obvious blockers early.
What is it?
Define the thing, then we can argue about it.
SKU design target (roadmap; registry entry).
Where does it live?
No URL, no audit — just vibes.
Included under if.gov specs/packs.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: registry SKU exists; no public /if/gov/triage page on this host.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Input schema + deterministic checks where possible; outputs become part of a decision pack.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/gov/triage/
Embedded mini-pack (generated)
Black / white
Claims in black/white; anything else is marketing.
Verified registry status + published URLs (when present).
Not verified factual correctness, safety, compliance, or intent.
if.gov.council roadmap sku
Council: structured dissent, slower mistakes.
path /if/gov/council
Who is it for?
If you’re in this audience, you’re the one who gets paged.
High-stakes decisions needing multi-lens deliberation.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Capture dissent and make trade-offs auditable.
What is it?
Define the thing, then we can argue about it.
SKU design target (roadmap; registry entry).
Where does it live?
No URL, no audit — just vibes.
Included under if.gov specs/packs.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: registry SKU exists; no public /if/gov/council page on this host.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Seat outputs are structured; deterministic checkers gate actuation (design target).
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/gov/council/
Embedded mini-pack (generated)
Black / white
Claims in black/white; anything else is marketing.
Verified registry status + published URLs (when present).
Not verified factual correctness, safety, compliance, or intent.
if.gov.council.extended roadmap sku
Extended: when the answer needs a checklist, not a vibe.
path /if/gov/council/extended
Who is it for?
If you’re in this audience, you’re the one who gets paged.
Decisions that need extra evidence gathering or external challenge.
Why does it exist?
Because “we meant well” isn’t an audit trail.
Make “go get more evidence” explicit rather than implicit.
What is it?
Define the thing, then we can argue about it.
SKU design target (roadmap; registry entry).
Where does it live?
No URL, no audit — just vibes.
Included under if.gov specs/packs.
When / readiness?
Status is a promise type: shipped > preview > roadmap.
Roadmap: registry SKU exists; no public /if/gov/council/extended page on this host.
How does it work (at a high level)?
Inputs, outputs, and where the receipts attach.
Extended workflow can allocate budget to evidence gathering, then re-run deterministic gates.
Review links (one URL per line)
Receipts aisle: grab what you need.
https://infrafabric.io/if/gov/council/extended/
Embedded mini-pack (generated)
Black / white
Claims in black/white; anything else is marketing.
Verified registry status + published URLs (when present).
Not verified factual correctness, safety, compliance, or intent.
Appendix: if.registry.json (embedded)
Source of truth beats source of vibes.
Canonical mirror is /llm/if.registry.json; embedded here for offline review.
Show registry JSON {
"version": 1,
"updated_utc": "2026-01-11T19:17:11Z",
"notes": [
"This file is the canonical naming/slug registry. Do not hand-type product IDs, URL paths, or artifact slugs elsewhere.",
"Brand labels are defined here (e.g., if.trace, IF.GOV). They may differ from product IDs.",
"Receipts and manifests should always carry `product_id`; `brand` is the human-facing SKU label.",
"Statuses are evidence levels (shipped/preview/roadmap); they do not imply customers, revenue, or multi-host reliability."
],
"glossary": {
"product_id": "Lowercase dot-namespace ID used in receipts/manifests and internal docs. This is the stable identifier.",
"brand": "Human-facing SKU label. It can change without breaking receipts, as long as product_id stays stable.",
"kind": "What this entry represents: a product, a surface (UI/distribution), a module (component), or a sku (deliverable tier).",
"status": "Black/white evidence level (shipped/preview/roadmap). Status does not imply customers or revenue.",
"path": "Canonical public URL path shape. Do not claim deployed unless verified; avoid dots in URL paths.",
"slug": "Hyphenated artifact slug for filenames and page slugs.",
"bundle_slug": "Hyphenated slug for demo bundles/artifacts.",
"repo_dir": "Workspace-relative implementation directory (when applicable).",
"vendored_engine_dir": "Workspace-relative path to an upstream/vendored engine used by a wrapper module (when applicable).",
"uses_receipts_from": "If present, indicates which product_id provides the receipt surface used to bind outputs (e.g., if.trace)."
},
"status_definitions": {
"shipped": {
"means": "Public, no-login surface exists and is deployed; at least one real artifact is reviewable end-to-end.",
"does_not_mean": [
"paying customers exist",
"multi-host reliability exists",
"compliance guarantees",
"factual correctness of narratives"
]
},
"preview": {
"means": "Public demo artifacts exist (and can be reviewed), but the module/service is not yet treated as a live production surface.",
"does_not_mean": [
"paying customers exist",
"CI/production integration is complete",
"compliance guarantees"
]
},
"roadmap": {
"means": "Concept/spec exists, but there is no public demo evidence that meets the reviewability bar.",
"does_not_mean": [
"deployed",
"reviewable without internal access"
]
}
},
"kind_definitions": {
"product": "A sellable SKU/service concept with a canonical product_id.",
"surface": "A UI/distribution surface that routes users to verification primitives (e.g., ShadowRT routes to if.trace receipts).",
"module": "A component/module that can be integrated into workflows (e.g., CI scanners) and may publish receipt-backed outputs.",
"sku": "A deliverable tier under a product (e.g., if.gov.triage)."
},
"products": [
{
"product_id": "if.trace",
"brand": "if.trace",
"kind": "product",
"description": "Public receipt surface (hashes; signatures only when present and verifiable). Proof of bytes/integrity, not correctness.",
"path": "/if/trace",
"slug": "if-trace",
"bundle_slug": "if-trace-demo-bundle",
"status": "shipped"
},
{
"product_id": "if.shadowrt",
"brand": "ShadowRT",
"kind": "surface",
"description": "Publishing/review UI that makes if.trace legible via dossiers/packs and routes reviewers to receipts.",
"uses_receipts_from": [
"if.trace"
],
"path": "/review/shadowrt",
"slug": "if-shadowrt",
"bundle_slug": "if-shadowrt-demo-bundle",
"status": "shipped"
},
{
"product_id": "if.bus",
"brand": "IF.bus",
"kind": "product",
"description": "Integration bus concept (message normalization + routing). Not shipped on the current host.",
"path": "/if/bus",
"slug": "if-bus",
"bundle_slug": "if-bus-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.api",
"brand": "IF.api (integrations)",
"kind": "product",
"description": "Integration inventory + adapters for external APIs. Not shipped as a runnable module on the current host.",
"path": "/if/api",
"slug": "if-api",
"bundle_slug": "if-api-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.search",
"brand": "if.search",
"kind": "module",
"description": "Multi-pass investigation/search workflow module (roadmap only; no receipt-backed demo published yet).",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/search",
"slug": "if-search",
"bundle_slug": "if-search-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.intelligence",
"brand": "if.intelligence",
"kind": "module",
"description": "Research orchestration module (roadmap only; no receipt-backed demo published yet).",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/intelligence",
"slug": "if-intelligence",
"bundle_slug": "if-intelligence-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.swarm",
"brand": "if.swarm",
"kind": "module",
"description": "Multi-agent/swarm execution module (roadmap only; no receipt-backed demo published yet).",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/swarm",
"slug": "if-swarm",
"bundle_slug": "if-swarm-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.story",
"brand": "if.story",
"kind": "module",
"description": "Narrative logging protocol module (vector vs bitmap). Roadmap only; no receipt-backed demo published yet.",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/story",
"slug": "if-story",
"bundle_slug": "if-story-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.knowledge",
"brand": "if.knowledge",
"kind": "module",
"description": "Build-time documentation pipeline (registry-driven; static Markdown/HTML; no runtime fetches). Roadmap: no public demo artifacts published yet; no deployed service on this host.",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/knowledge",
"slug": "if-knowledge",
"bundle_slug": "if-knowledge-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.kb",
"brand": "if.kb",
"kind": "module",
"description": "Build-time developer knowledge base (KB) artifacts generated via `if.knowledge` (static Markdown/HTML; no runtime fetches). Preview: a bus/api KB snapshot is published; no deployed KB service on this host.",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/kb",
"slug": "if-kb",
"bundle_slug": "if-kb-demo-bundle",
"status": "preview"
},
{
"product_id": "if.typeset",
"brand": "iftypeset",
"kind": "product",
"description": "Deterministic document CI (lint → render HTML/PDF → QA) for review-proof packs.",
"path": "/if/typeset",
"slug": "if-typeset",
"bundle_slug": "if-typeset-demo-bundle",
"repo_dir": "ai-workspace/iftypeset",
"status": "preview"
},
{
"product_id": "if.gov",
"brand": "IF.GOV",
"kind": "product",
"description": "Governance packs (triage/decision/external challenge) bound to receipts; not compliance guarantees.",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/gov",
"slug": "if-gov",
"bundle_slug": "if-gov-demo-bundle",
"status": "preview"
},
{
"product_id": "if.gov.triage",
"brand": "IF.GOV triage",
"kind": "sku",
"description": "Deliverable tier: triage memo + receipt-backed decision framing (not a compliance guarantee).",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/gov/triage",
"slug": "if-gov-triage",
"bundle_slug": "if-gov-triage-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.gov.council",
"brand": "IF.GOV council",
"kind": "sku",
"description": "Deliverable tier: council-style decision pack with risks/controls/eval plan, bound to receipts.",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/gov/council",
"slug": "if-gov-council",
"bundle_slug": "if-gov-council-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.gov.council.extended",
"brand": "IF.GOV council extended",
"kind": "sku",
"description": "Deliverable tier: extended council pack + external challenge add-on (receipt-backed).",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/gov/council/extended",
"slug": "if-gov-council-extended",
"bundle_slug": "if-gov-council-extended-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.security",
"brand": "if.security",
"kind": "module",
"description": "Cross-cutting security posture for InfraFabric modules (signals + evidence-typed actuation + containment mapping). Roadmap only; no deployed security runtime on this host.",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/security",
"slug": "if-security",
"bundle_slug": "if-security-demo-bundle",
"status": "roadmap"
},
{
"product_id": "if.security.secrets.detect",
"brand": "if.yologuard",
"kind": "module",
"description": "Receipt-backed secrets detection (audit mode, redacted outputs). Preview demo exists; not CI-integrated or 'live'.",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/security/secrets/detect",
"slug": "if-security-secrets-detect",
"bundle_slug": "if-security-secrets-detect-demo-bundle",
"repo_dir": "src/armour/secrets",
"vendored_engine_dir": "armour/yologuard",
"status": "preview"
},
{
"product_id": "if.emotion",
"brand": "IF.emotion",
"kind": "product",
"description": "Wellbeing-aware interaction layer (non-clinical) and governance-seat outputs with explicit safety boundaries; not diagnosis/therapy; not compliance guarantees.",
"uses_receipts_from": [
"if.trace"
],
"path": "/if/emotion",
"slug": "if-emotion",
"bundle_slug": "if-emotion-demo-bundle",
"status": "preview"
}
]
}