What makes the workflows run.

The framework for building multi-stakeholder digital ecosystems. Every app built on Frame speaks the shared conventions by construction, so the data it captures is a tradable unit the moment it is recorded.

Where agents build and maintain apps against the framework they are given, DAF, Frame, or another substrate, under human supervision. The unit of production becomes an agent that builds a class of apps, so output is bounded by agent capability, not engineering headcount.

The agentic web-crawling engine: it scans scattered public sources, corroborates what it finds, and organises the result. Its leading derivative is the navigable, source-rated reference hub, a public good and supply the market can buy; the mandate is web crawling in the general case.

The agentic conformance engine. It renders any source (a document, a feed, a legacy database) into schema-conforming records, owning the reconciliation and commoditisation that make messy frontier reality comparable.

The cross-system protocol. It makes data from any participating system discoverable and exchangeable across boundaries, while it stays at its source. Spine-compatibility is what puts an app, or any system, in the ecosystem.

Agent-led builder of the suite’s public face, marketing sites, Crawl hub front-doors and print-ready export sheets, stood up from config-driven templates, then maintained: every build teaches the template the next property forks from. This site is one of its builds.

Takes a raw outside signal and resolves it into a bearing. A demand signal, a client problem, an RfP, a topic of interest, becomes which Solution answers it and the instructions to stand it up; a leverage opening, a partnership, an engagement, a moment to respond, a contact, becomes a hypothesis for how DAAC puts it to work. It proposes; Mason renders the artefacts and the other Tools deliver.

One surface onto the whole suite: every product’s progress, authored here, the single source of truth, and its performance, read live from a telemetry shape each product emits. Console watches; it never controls what it watches.

Maps each tool’s spec ↔ code ↔ the solutions built on it, reports where they have drifted apart, and proposes the reconciliation. Surface-both, propose-only: it hands changes on, and writes nothing itself.

Runs what the suite builds and checks how it behaves: parity against a reference build, regression, the release gate. Concord reads the source; Gauge exercises the running thing, and its verdicts sharpen as humans correct them. It proposes the fix, and writes nothing itself.

The always-on, remote control plane that dispatches governed work to remote workers, holds it to the suite’s own guardrails at launch, and surfaces results for asynchronous review. It ends work being laptop-bound.

Autonomous DevOps: provisions, patches, backs up and keeps healthy the infrastructure the suite runs on, the standing job nothing else owns, kept its own tool so Helm need not carry it.

Keeps the suite’s learning loop honest: work is logged where it happens, and every log names who reads it and when, so nothing captured goes unread. A log nobody drains is a finding it raises, never a quiet loss. Each tool keeps its own corpus; Tally audits the loop.

The one gateway between the estate and the external model market: every Tool routes its model calls through this single contract, so which vendor answers is a config line, not a code path. A role asks for a capability tier; Manifold resolves the vendor at the edge, and swapping one is an edit, never a rebuild. Crawl and Scribe already call through it.

The shared OAuth and session contract every tool calls through to authenticate a sign-in, so which identity provider verifies it is a config line, never a per-tool rebuild. It secures a session on the right key and releases it on sign-out, the way its namesake secures and releases a door.

A read-only instrument that lets the estate query and census a live database without a human hand-running an ad hoc script each time. Structurally read-only: no write verb is reachable through it, so a second place data could be mutated from never opens.

Watches the model market and the suite’s own run telemetry, and proposes evidence-backed remaps of which model each agent role runs on. No role is left on the wrong model as the market shifts; the Tool it targets disposes.

Owns how a recurring manual practice becomes a self-hosted tool: it reads the corpora the suite already keeps for the signature of a missing tool, then guards the playbook a new one is born from. It proposes the graduation; Helm dispatches the build.

A read-only projection of everything the estate has written, rebuilt from scratch rather than patched, joining text search to the links the authors drew by hand. Any seat can find what is already known and how it was reached, so a settled question is answered from the record instead of asked again.

Hands a worker a named grant instead of a secret, so no interface, log or transcript can emit the value even by accident. When it is unavailable, authenticated work stops and escalates rather than reaching for an unsafe path.

One governed door for everything the estate sends out, so no tool holds a mail provider itself. Templates that may send on their own are separated structurally from the ones a human has to release, and every departure is recorded.

Takes a user report the moment it lands, checks it against what is already open and already ruled, and routes it: an operational fault to the board that owns it, a feature ask to the demand side. Feedback stops depending on somebody reading an inbox.

Presents one decision at a time and records the verdict against it, so a judgment call is captured where it was made instead of scattered through conversation. It shows and records; it never acts on what was decided.