🧵 omp-fabric

A programmable tool and agent runtime for OMP

One type-checked program for tools, MCP, agents, workflows, actors, mesh, councils, and recursion.

Fabric gives OMP 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.

Why Fabric?

| | Capability | What it unlocks | | :-: | ---------- | --------------- | | ⚡ | Code mode | One flat tool schema; branching, loops, fan-out, and data flow live in checked TypeScript. | | 🧰 | Capability routing | Call OMP core tools, MCP servers, captured extension tools, or Fabric providers through one runtime. | | 🧑‍🤝‍🧑 | Agent runtime | One-shot workers, durable resident agents, persistent event-driven actors, councils, and bounded recursive queries. | | 🕸️ | Workflows + mesh | Phased progress plus durable topics, shared tasks, and compare-and-swap state. | | ⚖️ | Typed judgment | Calibrated choice, bool, and score answers about one state, ergonomic guest helpers for batch semantic triage, and four optional gates. | | 🛡️ | Guardrails | Approvals, isolation, timeouts, concurrency, recursion depth, and shared cost budgets. | | 🎛️ | Native TUI | Live activity, an interactive dashboard, and settings without leaving OMP. |

How it works

1. You ask in plain language.
2. OMP 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([
  omp.read({ path: "package.json" }),
  omp.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(), compact.status(), and judgment.ask(...), alongside judge.filter(...) for batch evaluation. Refs found or computed at runtime use tools.call({ ref, args }).

Install

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

omp install npm:omp-fabric

From GitHub:

omp install git:github.com/tickernelz/omp-fabric

From a local checkout:

bun install
bun build
omp install /absolute/path/to/omp-fabric

For one development run:

omp -e /absolute/path/to/omp-fabric

What you can ask for

OMP 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 OMP on the core fabric-exec path.

| You want | Run | | -------- | --- | | Help choosing the smallest advanced mechanism | /skill:fabric-guide Choose a mechanism to audit every auth file and verify the findings. | | Parallel audits, migrations, or research with verification | /skill:fabric-workflow Audit every auth file and synthesize verified findings. | | Work too big for one context window | /skill:fabric-rlm Produce a compact architecture map of this repo. | | A persistent watcher for one measurable goal | /skill:fabric-supervisor Watch this migration until it is complete and tested. | | A strict auditor for one feature design spec | /skill:fabric-spec Implement docs/specs/checkout.md to the tee; nothing missing, nothing extra. | | A quiet decision-point reviewer | /skill:fabric-advisor Focus on migration correctness. | | Same-model independent reviewers and one decision | /skill:fabric-council Review this design for correctness, security, and operability. | | Multi-model compare-not-merge deliberation or act mode | /skill:fabric-fusion Deliberate this design across models. | | One command that chooses advisor or supervisor | /skill:fabric-ambient advisor Focus on migration correctness. | | A durable team coordinating through versioned tasks | /skill:fabric-swarm Coordinate this migration across owned task partitions. | | Evidence-gated edits with postconditions | /skill:fabric-schema Make this parser change only if focused tests stay green. |

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.

Agent conversations

Press Ctrl+Shift+A or run /fabric chat <agent-id-or-name> to open a live, full-screen child conversation with a multiline editor. Send steering or follow-ups directly, switch between nested agents, and return to Main without stopping its work. Drafts and scroll positions stay with each conversation. Completed one-shot agents are read-only; persistent actors accept further messages. See focused conversations for controls and current limitations.

The dashboard

Fabric includes a live activity surface in OMP:

• 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 OMP session appears as Main. You can queue or steer participants and inspect the project topology.
• /fabric lcm: opens the LCM ledger dashboard with health checks and one-key repairs, the summary node graph, branch coverage, and maintenance jobs.
• /fabric settings: mirrors OMP'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. OMP'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.

Measured against OMP without Fabric

A resume task, seeded as a paused session, run three times per arm on claude-opus-5 through the same provider. The baseline arm is OMP with no extension loaded; the Fabric arm loads dist/index.js and compacts the session with LCM before resuming. Both arms receive the same fixture, the same prompt, and the same host configuration, and a run counts as a success only when the fixture's own verify.mjs exits zero with the forbidden files untouched.

| | Baseline | Fabric | Delta | |---|---|---|---| | Task success | 3/3 | 3/3 | equal | | Tokens | 585,197 | 356,542 | -39% | | Tool calls | 14 | 6 | -57% | | Wall time | 67.6 s | 59.1 s | -13% | | Cost | $0.6987 | $0.2356 | -66% |

Per-run tokens were 208,595 / 209,619 / 166,983 for the baseline and 118,751 / 119,387 / 118,404 with Fabric, so the reduction is stable across runs, not an artifact of one lucky sample. Read the cost row with care: the baseline's first run cost $0.4710 against $0.1271 and $0.1007 for its later two, because a cold prompt cache is charged at full rate. The token column is the honest measure of the difference, and cost follows it once caches are warm on both sides.

Reproduce it with your own model and provider:

OMP_FABRIC_REAL_RESUME=1 \
OMP_FABRIC_BENCH_MODEL=claude-opus-5 \
OMP_FABRIC_BENCH_PROVIDER=sub2api-claude \
OMP_FABRIC_BENCH_KEY_ENV=YOUR_KEY_VARIABLE \
OMP_FABRIC_BENCH_REPEATS=3 \
OMP_FABRIC_BENCH_MAX_USD=8 \
bun run benchmark:real-resume

The command bills your provider and stops at OMP_FABRIC_BENCH_MAX_USD. Without those variables it reports SKIP and spends nothing.

Reference

• Configuration: fabric.json, code modes, tool capture, approvals, and budgets.
• Code map: the native symbol index, token-budgeted disclosure, and git co-change ranking.
• Judgment: calibrated choice, bool, and score answers over one state, batched into a single backend request, and the four gates that read them.
• Memory & recall: compact ranked hits, uniform follow calls, lossless expansion, and guest-local memory.walk computation.
• 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 OMP: background host lifecycle and the OMP-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.

Development

bun install
bun typecheck
bun test
bun build

The test suite covers:

• configuration and schema validation
• provider dispatch, registered-tool execution, QuickJS isolation, and OMP built-in calls
• agent fixtures for Claude and Veda
• workflows, durable mesh state, actor mailboxes, subscriptions, and actor restoration
• the judgment lane, its provider, the guest surface, and the four gates

Claude and Veda fixtures use local test processes with zero billable requests. The judgment tests use scripted judges and spend nothing either.

bun run benchmark:skill-router measures the skill gate against a fixture of labelled turns. It needs TYPESAFE_API_KEY and makes real requests, so it is not part of bun test.

Acknowledgments

• 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.

License

MIT