🧵 pi-fabric

Fabric gives Pi one programmable tool called fabric_exec, which composes core tools and MCP servers with captured extension tools in a checked TypeScript program. That program can call agents or actors, use durable coordination, and run inside QuickJS. Trusted workloads that exceed WASM32 memory may use the unsafe Node process. After execution, the conversation receives the result of the program's branches, loops, fan-out, and data flow.

1. You ask in plain language.
2. Pi writes one program that calls the required tools and agents.
3. The type checker validates the program before execution.
4. The result returns to your conversation. Intermediate work stays in the sandbox and appears in the activity panel and dashboard.

The model can write this program:

const [manifest, sources] = await Promise.all([
  pi.read({ path: "package.json" }),
  pi.find({ pattern: "**/*.ts", path: "src" }),
]);
return {
  package: JSON.parse(manifest).name,
  sourceCount: sources.split("\n").filter(Boolean).length,
};

Independent calls run in parallel, and the returned object enters the model context. Known providers support concise direct calls such as mcp.fal_ai.get_model_schema(...), memory.recall(...), state.get(), schema.status(), and compact.status(). Refs found or computed at runtime use tools.call({ ref, args }).

Requires Node.js 24+ and Pi 0.80.6+. Fabric also checks a detectable Pi host version at startup and warns when an older host may ignore continuation APIs such as actor triggerTurn.

pi install npm:pi-fabric

pi install git:github.com/monotykamary/pi-fabric

pnpm install
pnpm build
pi install /absolute/path/to/pi-fabric

pi -e /absolute/path/to/pi-fabric

Pi loads advanced patterns after direct user invocation. Run /skill:fabric-guide for one recommendation, or invoke the exact /skill:<name> yourself. An ordinary coding task keeps Pi on the core fabric-exec path.

The foundation is the fabric-exec reference skill: the model loads it before its first fabric_exec call and again when a call errors on argument shape.

Fabric includes a live activity surface in Pi:

• A compact widget above the chat (like pi-supervisor) whose header follows the current phase while its rows show active/completed agents, active actors, and their recent nested tool or code-change activity.
• /fabric (or /fabric dashboard): opens the Activity and Topology views. The user-facing Pi session appears as Main. You can queue or steer participants and inspect the project topology.
• /fabric settings: mirrors Pi's /settings and writes changes to fabric.json. TUI hosts get the searchable settings component; RPC hosts get the same nested sections, value/input/model pickers, list editors, and project/global save scopes through native dialog primitives.
• Tool display (compact by default, or full) is configured under /fabric settings → UI; compact elevates the declared display intent, hides the outer TypeScript, and applies to the current transcript immediately. Pi's tool-expand keybinding (ctrl+o by default) expands a compact card to the full transcript.

See the interface & commands reference for every view, keybinding, and slash command.

• Configuration: fabric.json, code modes, tool capture, approvals, and budgets.
• Interface & commands: dashboard, settings, keybindings, slash commands, and headless runs.
• Agents, actors & mesh: model handoff, /fabric prewalk, runners, transports, actors, councils, recursive queries, and durable coordination.
• Durable residency through Pi: background host lifecycle and the Pi-runtime launcher boundary.
• Components & committed capabilities: supervised effects, exact requirements, external per-model guidance and execution-profile replacement, rolling provider generations, actor commitments, and both formal calculi.
• External providers: the versioned provider protocol for extensions.
• Architecture & security: the host bridge, sandboxing, tool-call robustness, and limits.
• Catalog repairs: unique extra keys and unknown actions promoted into silent schema maps.
• Tool entropy: the deterministic entropy meter, on-demand session measurement, reduction proposals, the autonomous compile loop with its ratchet gate, and certify:entropy.
• Speculative PTC: pre-launching literal read calls while the program streams, with epoch + freshness guarantees.
• Skills: the core-first invocation policy and user-invoked advanced patterns.

pnpm install
pnpm typecheck
pnpm test
pnpm build

The test suite covers:

• configuration and schema validation
• provider dispatch, registered-tool execution, QuickJS isolation, and Pi built-in calls
• agent fixtures for Claude and Veda
• workflows, durable mesh state, actor mailboxes, subscriptions, and actor restoration

Claude and Veda fixtures use local test processes with zero billable requests.

• Thanks to @hazrid93, whose request for a token-efficient LLM advisor pattern led to Fabric's advisor.
• Thanks to Chad Gibson at Neuralwatt, who supported extended tests of long MCR sessions and the related debugging work.

MIT