We run this company on a directed graph that survives across sessions and model generations, with the state, the provenance and the governance carried on the graph itself rather than in the window. The model is a component we swap. The graph is the company.
The proof is not architectural, it is historical: the same graph has already carried this company through engine releases and through changes of the underlying model, with the work in flight, its provenance and its governance intact.
A chat assistant answers the request in front of it. That is the right shape for a question with an answer and the wrong shape for work that runs for weeks: the window closes and the state is gone, nothing moves unless a person types, and the decomposition, which is where most of the judgement sits, stays with the person. The assistant is fast at every step and absent from the sequence.
We build the sequence. The engine is the latest graph engineering architecture, and a direct extension of the work it is built on: the graph and tree structured reasoning published by research groups since 2023, and the harness patterns published by frontier labs in 2025 and 2026. Those describe a graph inside one session. Ours persists.
Nodes are units of work, decisions, checks and events, each with a declared owner. Edges are conditions: a node becomes eligible when its dependencies are satisfied, not when a schedule happens to come around. Checker nodes sit in front of anything that counts as an outcome, so a report that fails a deterministic precheck never reaches an integrator. Fan-in points are explicit, which is what stops the classic failure of parallel agents that all wait in line behind the slowest one.
Two directions matter more than speed. Backwards: from any result you can walk the graph to the decision, the rule and the role that produced it. Forwards: from a goal you can walk to the branches that are actually moving it, and to the ones that have gone quiet. A board that cannot do both is not governing, it is only working.
The gain is measurable, and we measure it. Replacing a scheduled hand-off with an event edge took the time between a unit of work finishing and its result being integrated from a sixty minute polling cycle to forty one seconds, in production, on 2 August 2026. The polling watchdogs stayed in place as a safety net and count what they catch; the target for that counter is zero.
Every action is recorded to the ledger before it runs, and the ledger is hash-chained. The record carries who acted, in what role, under which rule, and the chain makes silent retro-editing detectable rather than merely discouraged. Memory follows the same discipline: facts are stored so they can be found by meaning rather than by filename, each one carries who stated it and on what basis, and a nightly pass marks superseded facts as out of date instead of letting two versions of the truth sit side by side.
Recurring branches run inside a stamped wrapper that records the job identity, result and duration on every execution. This inverts the usual monitoring mistake: instead of alerting on old log lines, we alert on a missing stamp. A job that never started leaves no log to look old.
The engine is versioned and released like software, with rollback to any earlier tag, and a manifest that reports drift between what is running and what was declared. Outbound sales email, publishing and deployments pass a gate before they leave the system. Changes are classified by risk, and a high risk change stops until the owner approves it from his own phone, behind a device lock. That confirmation channel holds its own secret, separate from the system's telemetry: a leaked telemetry key does not buy the right to approve a change.
One behavioural rule is worth stating publicly, because we learned it the expensive way: the check and the release are never in the same call chain. A verdict is read, and only then is a release decided as a separate step. That holds at four in the morning too.
Six board members run this engine, each answering for one domain: strategy, finance, commerce, product, integrity, marketing. Work is routed to the owner of the domain it belongs to, a separate critic reads it against the register before it counts as decided, and outputs are scored afterwards against what actually happened. That last part is what makes a later version better rather than only newer, and it is the difference between a system that runs and a system that improves.
Because the board owns the engine, the engine changes itself. Findings from its own audits become specified work with measurable criteria and a rollback condition, and the fixes are released through the same gates as everything else.
The engine is reviewed by an external AI auditor from a different model family, on a scoped brief that contains no credentials, no file paths and no customer data, and with no access to the system. An internal critic catches drift from a written constitution, but it cannot catch a false assumption it shares.
The auditor's findings come back as tasks with baselines, acceptance criteria and a rollback condition attached, which is what turns an audit into work instead of a list of opinions.
Thinking rooms. A bounded deliberation layer, opened per question rather than run by default. The research is unambiguous about why: multi-agent debate with identical inputs does not improve expected correctness, weaker participants conform to the majority instead of holding a correct minority view, and self-reflection stops producing new knowledge once a model is confident in its first answer. The design follows from that. Heterogeneous framings and asymmetric information per participant, a judge that protects the minority signal, mandatory dissent and a premortem on every significant decision, and tree-shaped exploration with pruning and backtracking on high stakes calls. The room's output goes to a bounded store, not into the general backlog: an idea generator attached to a system that already creates work faster than it closes it would amplify exactly the wrong thing.
A local identity model. A small model on our own hardware whose task is not to produce work but to hold continuity: who we are, what we decided, what we believed and on what evidence. Identity that depends on one vendor's model generation is rented, not owned. This one waits for hardware, and hardware waits for revenue.
Sources actually used in building what is described above. Open access only. The architecture above extends this work; it does not restate it.
Graph and tree structured reasoning, and agent orchestration
Besta et al., "Graph of Thoughts: Solving Elaborate Problems with Large Language Models" (AAAI 2024, arXiv:2308.09687).
Yao et al., "Tree of Thoughts: Deliberate Problem Solving with Large Language Models" (Princeton / Google DeepMind, 2023, arXiv:2305.10601).
Anthropic, dynamic workflows and harness design for agentic systems (2025-2026): industrial reference for parallel sub-agents and a check before output. Their harness is one session; ours is a standing organisation, so the patterns are transferable, not copyable.
The 2026 practitioner discourse on graph engineering for agents: node and edge discipline, the false-edge test, checker nodes, static versus dynamic graphs, topology as a cost lever.
Deliberation, and its documented failure modes
Du et al., "Improving Factuality and Reasoning in Language Models through Multiagent Debate" (2023, arXiv:2305.14325).
Liang et al., "Encouraging Divergent Thinking in Large Language Models through Multi-Agent Debate" (Degeneration-of-Thought, arXiv:2305.19118).
Zheng et al., "Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models" (Google DeepMind, arXiv:2310.06117).
Zhou et al., "Self-Discover: Large Language Models Self-Compose Reasoning Structures" (Google DeepMind, arXiv:2402.03620).
Memory, structure and precedent
Sumers et al., "Cognitive Architectures for Language Agents" (CoALA, 2023, arXiv:2309.02427).
Swanson et al., the Virtual Lab: an AI agent team with a principal agent, specialists and a critic agent producing real research output (Nature, 2024).
UC Berkeley RDI, Agentic AI F25 (Fall 2025): multi-agent structures, agent memory, production deployment, evaluation design.
Governance and security
NIST AI RMF 1.0 and the Generative AI Profile (NIST-AI-600-1).
OWASP Top 10 for LLM Applications 2025, in particular prompt injection, excessive agency, and vector and embedding weaknesses.
EU AI Act (Regulation (EU) 2024/1689), Article 50 transparency.
Architecture details, internal process mechanics, timing of automated operations, and anything that would allow a direct replication of the system. The test before any disclosure: could a competitor build the same thing from this information? If yes, it does not go out.
Our products are the visible proof. The engine conceives, builds, ships and supports real software, end to end. What sits underneath is more general than any single product. An agentic system that reads a company's own data, continuously and in full, straight from the source, sees what sampled, once-a-year reviews cannot.
That points at something larger than rental software. Point the same engine at a company's financial and operational systems and it does continuously, on the full data, what due diligence and business analysis reach for once a year on a sample: a standing, independent read on how a business is really performing and where the risk sits. We already run Offsite itself this way.
We fund this from what our products earn. We are not raising, and the engine is not for sale. We build in the open.
Sources and a general description: methodology.