The intelligence layer of Microcelium
The workforce
that never sleeps
Loom is Microcelium's AI fabric. It runs your agents and workflows with identity, retries, audit and cost tracking already in place — so your team ships automation, not plumbing.
Stop rebuilding the same plumbing
Every team wants to ship AI-powered workflows. Without a fabric, each one re-invents the same plumbing.
Re-invented foundations
Auth, identity, retries, dead-letter handling and audit rebuilt per workflow, per team — glue code and point integrations instead of product.
Unattributable cost
LLM spend that can't be traced to a tenant, a workflow or a trigger. Nobody can say what a process costs to run, or whether it should.
No live surface
Work happens inside queues and cron jobs with no way to watch it: no queue depth, no cost meter, no picture of what the system is actually doing.
With Loom you inherit the plumbing, and much more
An agent joining Loom writes one handler. Everything each team used to rebuild arrives with the envelope — carried once, by the fabric, for everyone.
Foundations, inherited
Identity, signed delivery, retries, dead-letter recovery and audit are woven into every message the fabric carries. No workflow re-implements them; no team can forget them.
Cost, owned
Every AI call is priced the moment it happens and attributed to a tenant, a workflow and a trigger. The spend report isn't reconstructed at quarter-end — it's a query.
Work, visible
Queues, agents, runs and failures surface on live operator consoles fed by the audit stream — watch any request end to end, replay what died, act on what you see.
Ship the handler. The fabric ships the rest.
The middle of the pyramid
Loom runs on the Microcelium substrate and serves everything above it. It isn't a boxed product — it's the intelligence layer the rest of the platform gets to build on.
Experience — what users touch
Applications, portals, APIs and interfaces.
Intelligence — the workforce that never sleeps
Agents · transducers · Cortex · vault · planner · consoles
Foundation — the substrate you own
Control plane · machines · networks · stacks. micro‑substrate.com
The machinery every workflow inherits
One system, six working parts. Everything hangs off the message bus — pick a part of the diagram to see what it carries for every workflow.
Adaptors
Connect a data source once and every workflow can use it. External feeds and internal events stream onto the mesh — 11 live sources today, from national environmental networks to the platform's own events.
Orchestrator
The control plane: registration, heartbeats and a queryable capability index. It knows what exists and whether it is alive — and it is never in the hot path. Messages route by capability, not by address.
Planner
Describe a goal; the planner composes a candidate transducer from the capability catalogue, validates it structurally, and persists a draft for operator approval. Autonomy proposes; operators publish.
Tenancy Vault
Provider-agnostic AI per tenant: provider, model routing and billing mode resolved per request, API keys AES‑GCM‑encrypted at rest. Agents stay thin, OpenAI-compatible clients — swap the provider, not the code.
Inference Specialist
Curated open models behind an OpenAI-compatible surface — embeddings and small specialised tasks at fabric quality without cloud-provider rates, dispatched by opaque model name.
Cortex
See what the fabric is actually doing. Cortex turns the audit stream into live views — activity, cost, patterns — on operator consoles you can act from.
Three independent scaling axes
The fabric grows in three directions at once, and none of them pulls on the others — each axis below scales on its own rhythm.
Throughput
Stateless workers behind competing-consumer queues. Backlogs are normal; capacity is elastic. Scale replicas, not architecture.
Capability
New agents self-register into the catalogue; transducers and the planner discover them immediately. Adding capability never means re-plumbing.
Tenants
Per-tenant provider config, per-tenant keys, per-tenant cost attribution — chargeback-ready from day one, with no single chokepoint.
Two kinds of actor, one fabric
Everything that does work in Loom is an actor. Agents are atomic; transducers compose.
Agents — black boxes, openly described
Self-contained actors with declared capabilities — typed inputs and outputs, implementation private. Inside may be pure code or a model-driven pipeline; callers only ever see the contract. Replicas compete on a queue, so throughput is a scaling decision, not a rewrite.
Transducers — graph-defined
Named, versioned graphs of nodes that transform inputs into outputs — authored visually, validated against the capability catalogue, and executed by a runtime. Ports are typed by JSON Schema; an edge that connects incompatible shapes is refused at authoring time.
Agents do one thing well. Transducers chain agents — and other transducers — into business processes.
Where the iceberg breaks the surface
In the Pyraburg architecture — pyramid foundations, iceberg visibility — Loom is where the visible platform meets the invisible one.
Some of this layer is seen: operator consoles, the transducer studio, the planner's drafts awaiting approval. Most of it is not — envelopes, queues, heartbeats, the vault, the audit stream. The threads spread from here: down into the substrate that runs the containers, up into the applications that users touch. Most of the system is invisible. All of it is observable.
What is on the loom today
Measured 2026-09-05 from the Loom source, origin/develop as of 2026-09-02. Hover a figure for the method.
Six scenarios, in motion
A flood warning becoming an operator brief. A hot rack raising an alarm. A ticket enriched before anyone opens it. Six real-world flows drawn as they run on the fabric.
Put the plumbing behind you
Talk to the engineers building Loom about your AI workflows — what the fabric would carry for you, and what it deliberately wouldn't.