🦔 SmartFabric

Carry IAIso containment across the whole fleet. One wire protocol, one node fingerprint — so many governed AI agents behave as one governed data fabric, not a pile of independently-wrapped agents.

IAIso §0 · Fabric · binds to IAIso v5.0 core · SmartTasks.cloud · the Smart* family

The problem: AI is spreading through your systems, and you can't see the layer it lives on

AI/LLM calls now sit inside your CRM, your CI, your data pipelines, your agents. Each one influences and controls real systems — and each is wired in its own bespoke way. There is no common layer where you can measure, monitor, audit, and trace what the AI is doing across all of it. You can't govern a black box, and you certainly can't govern a hundred differently-shaped black boxes.

SmartFabric is the hardened layer that separates AI/LLM traffic and functionality out into its own governed plane. It is the reference implementation of the IAIso Fabric Protocol (IFP): a wire protocol + a node fingerprint that every AI node publishes, so a heterogeneous fleet becomes measurable and enforceable as one organism.

Where the IAIso engine answers "is this agent over pressure?", IFP answers "what is the pressure of the whole system, is any node about to breach, and can a global halt be honoured everywhere at once?" — the questions IAIso's Layer 3 (ecosystem coupling), Layer 4 (escalation) and Layer 6 (existential guards) can only answer if nodes speak a common protocol.

Install

SmartFabric is not published on PyPI or any other package registry yet. Until this section says otherwise, a package called sf-smartfabric on any registry is not ours, and neither is smartfabric.

Install from a clone (Python 3.10 or later):

git clone https://github.com/SmartTasksOrg/sf-smartfabric
cd sf-smartfabric
python -m venv .venv
. .venv/bin/activate          # Windows PowerShell: .\.venv\Scripts\Activate.ps1
python -m pip install .
sf-smartfabric --demo

Status

• Version 0.5.0, experimental. The reference implementation of the IAIso Fabric Protocol (IFP), version 0.5.0, with a frozen wire format and ports in nine other languages that reproduce the same behavioural vectors.
• Published: nowhere yet; install from a clone (above).
• Tested: on Python 3.10, 3.11 and 3.12 (Linux): the 59 tests, the demo, the behavioural vectors, the live FAB-L-* harness against an in-process node, and ports/conformance/run.sh across every port whose toolchain the runner has, on every push to master and every pull request (.github/workflows/ci.yml).
• Not tested: Windows and macOS; Protobuf binary interop (field numbers are frozen, not exercised without protoc); ed25519 report signing (not implemented yet: a content digest stands in for the signature).
• Ports: Node, Java, C, C++, Go, PHP, Rust, Ruby and C# ports in ports/ reproduce the Python reference's vectors (ports/conformance/run.sh, run in CI); none is published on a registry.
• Protocol: a frozen wire format (canonical-JSON encoding + LEB128 framing and a field-number-frozen proto/fabric.proto, see docs/08_WIRE_FORMAT.md) and behavioural conformance (spec/vectors/ pins inputs to outputs; sf-smartfabric vectors runs them). Static FAB-* checks remain for what a node declares.
• Container image: the deploy configs reference ghcr.io/smarttasksorg/sf-smartfabric:0.5.0, which is not published yet; build it locally from Dockerfile until it is.
• Security review: none independent. Report vulnerabilities as described in SECURITY.md.

What it does, in one screen

sf-smartfabric --demo runs three things against bundled synthetic data, no network:

1. Single-node pressure — drives a token/tool workload up the dp/dt curve until it hits the release threshold and atomically resets (invariant 2: lossy, no learning across resets).
2. Fleet pressure — aggregates five nodes into one topology-weighted P_fleet (Layer-3), so a high-centrality hub moves the number more than a leaf.
3. Conformance — runs the FAB-* suite over an example fingerprint and prints a pass/fail report a node can carry in its own contract.

Run it in your stack

What's in this repo

• The spec — docs/, reading order below. docs/07 is the binding to the real IAIso v5.0 core (pressure fields, layers 0–6, the 5 invariants); docs/08 is the frozen wire format.
• The contract — schema/fingerprint.schema.json: the machine-readable descriptor every node publishes, plus a passing example.fingerprint.json.
• A runnable reference — src/sf_smartfabric/: the pressure engine, fleet aggregation, CIR envelope + wire codec, the FAB-* conformance suite, a live HTTP/CIR node (node.py) with optional mTLS (mtls.py), an over-the-wire harness (live.py), and a registry (registry.py) for fleet discovery + P_fleet aggregation. Deterministic, offline, dependency-light.
• Independent ports — ports/: Node + Java (runnable, in CI) and Go, PHP, Rust (shipped, vector-checked). Interop harness in ports/conformance/.
• Toolchain integrations — integrations/: LangChain, n8n, Flowise, and a GitHub Action that gate/meter agents through a fabric node.
• Deployments — deploy/: Dockerfile, a two-node compose fabric, and GCP/AWS/Azure recipes for the node service.
• Conformance vectors — spec/vectors/: pinned input→output cases (pressure, fleet, envelope) that define the protocol independently of code.
• Family metadata — spec/iaiso-map.json, .smart.json.
• Tests — tests/: the public suite (59 green), including the live node harness.

Reading order

How it works (the honest version)

The IAIso trust boundary is inherited, not hidden: IFP bounds cooperating nodes and makes them measurable and attestable. Pressure is computed at the infrastructure level, outside the model (invariant 5), so a node can't game its own valve, and the fabric trusts attested infra telemetry, not model self-report. For adversarial containment you still bind thresholds to an out-of-process anchor (seccomp / container / VM / hypervisor FLOP cap) at substrate S0–S4 — and layer0_caps.hardware_attested is the wire-level claim that you did. FAB-I-006 fails any node that claims Layer 0 without it. Safety through structure, not hope.

Rule/check IDs are namespaced FAB-* so output looks kin to the rest of the family (SmartPangolin's SEC-*, SmartSeal's SEAL-*).

Part of the Smart* family

SmartFabric is the fabric layer of IAIso — the plane the other tools ride on. It stacks naturally with SmartSeal (provenance records on the observability plane), SmartRoute (trust-gated routing), and SmartLLMCost (the resource-accounting record — characteristic #23). Everything conforms to the open IAIso standard and bundles in SmartTasks.cloud.

Contact

Companies wanting hands-on integration of the fabric into their architecture, audit-ready: enterprise@smarttasks.cloud.