Catalyst · The engine

Zero Trust, as architecture, for the first time ever.

Catalyst is the system you move your stack onto so that zero trust stops being a policy people are asked to follow, and becomes the only way anything can connect. Every piece plugs its ontology into one engine. The engine computes, enforces and records every relationship. It does not push you through the scaling wall. It brings you back to your baseline, fast, and keeps you there however much you build.

If we can compute the relationships, does that mean the architecture itself can govern and secure those automatically as well?
Dylan CarterThe question behind Catalyst

01 · The problem

The old way has holes because it is wired by hand.

Every system you add gets connected to everything it talks to. Twenty systems is up to 190 connections. That is the integration tax, and for a security team it is also the attack surface: each connection is a line somebody has to guard.

190 lines to guard, each one wired and checked by hand
  1. Where the holes come from
  2. 01Every connection carries its own check

    In hand-wired software each endpoint needs its own auth check, written and remembered by a person. One forgotten check is a breach.

  3. 02Trust outlives its use

    A role that trusted a vendor stays trusted after you stop using the vendor. Nobody is looking at that line anymore.

  4. 03Nobody can see all of it

    The relationships live in code, config and people's heads. You cannot defend the space between lines you cannot see.

02 · Where it goes

Every system returns to its baseline. The only question is how.

The integration tax rises with every piece added, and it never stops rising. Catalyst does not push a system through the wall at the top of that curve. It flips the curve: the fastest way back down to baseline, with the ontology showing what to carry on the way. At the bottom, control is established, sorted between people and agents, and that is the race: gain control before an attacker does. Pick an option to follow its path.

What it costs to sustain capabilitiesBaselineTimeReachablefor 6 yearsThe integration tax6 years agoTodayWhere it is headedThe crashDown to the lastpoint that can beproven clean.Without a map,that is nothing.And it starts over, from nothing.So much has been built, and yetwhat it takes to sustain thosecapabilities keeps growing.How long can this keep goingbefore it crashes?Controlled dropControl established.Sorted between people and agents, known and total.From here, forward with clarity.Sustained at baseline, with everything it needsToday

Go find the truth, or an attacker will show it the hard way.

Two options from here

Either way, every system comes back down. All systems need to come back to truth. And in this landscape, either the truth hurts, or the truth sets the system free to grow. The only difference is whether anyone went looking for it.

03 · The answer

Stop wiring relationships. Compute them.

On Catalyst nothing is wired to anything. Each piece declares its ontology and plugs it into the engine once. The engine works out every relationship from those declarations, so a connection is something you look up, not something you build and then have to remember to guard.

20 connections, each one through a gate
  1. A piece's ontology, in three declarations
  2. 01What it is

    Its identity and its owner.

  3. 02What it offers

    Its capabilities, each with a contract.

  4. 03What it needs

    The capabilities it calls. That list is its entire permission set.

The integration tax and the attack surface are the same lines. Remove one and the other goes with it.

04 · The math

The curve does not go away. It changes sides.

Software has a scaling law: the more you have, the more each new thing costs. Catalyst does not repeal the law, and it does not break through the wall the law builds. It moves the curve, from the cost of building to the value of what you have built, so you stop climbing toward the wall at all. Coming down from the breaking point or starting from zero, each piece costs what the first one did, and you stay at your baseline. Drag the slider to see it.

2 pieces40 pieces
Wired by hand
190 connections to build and guard
On Catalyst, what you pay
20 connections, one per piece
On Catalyst, what you get
190 ways those pieces can work together
  1. 01The law today

    Every piece you add has to be wired to the pieces it works with. So each new piece costs more than the last, and the total grows with every pair.

  2. 02What Catalyst changes

    A piece connects once, to the map. The tenth piece costs what the first did, and so does the hundredth.

  3. 03Where the curve goes

    The pairs do not disappear. They are still there, as the ways your pieces can work together. The curve moves from what you pay to what you get.

That is compounding: every piece you add makes every other piece worth more.

What growsWhat stays flat
Connections

One declaration per piece.

Integration code. There is none to write.

Requests

Nothing.

The path of a call: gate, bus, gate, at any size.

Failure

The size of the system.

The blast radius of one broken piece.

Nesting

How deep systems sit inside systems.

The rules. The same gates apply at every level.

The numbers are arithmetic: possible pairs among the pieces. They describe the design, not a benchmark.

If we removed integration tax from the software, which is what consumes a ton of resources, budget, and time to build and maintain, what does that mean for the vendors we are relying on? What does that mean for the people in our departments and teams?

With an engine like Catalyst, that means we can centralize everything to a zero trust architecture, have full control and observability at the core, and bring home what we thought shouldn't belong within our own perimeters, faster, more secure, than ever before, and pave the way to withstand the threats that lie in the agentic era, and get back our time, budget, resources, processes, and above all, our clarity on what we have become.

Catalyst does not break the wall. It is the fastest way back down from it: to your baseline, carrying only what the ontology says you need, and free to build up again from there without climbing back toward it. Whether you are coming down from the breaking point or starting from zero, it is a system you can trust, observe, and grow on without paying more for every piece you add.

05 · The engine

One engine. Every piece's ontology plugs into it.

Here it is with a real app on it. The engine assembles each piece's ontology into the map of the whole system, and that map is where everything is governed: not through a policy document, but through the architecture itself.

registrythe ontologyweb/consolesurfaceidentity/sessionworkerdirectory/idpadaptercloud/iamadaptertrust/mapworkerreviews/queueworkerdrift/watchschedulenotify/owneradapterspecialist/securityagent

The app on the engine

Trust Review

A full-stack app that finds vendor trust nobody has used in 30 days, puts it in front of an owner, and revokes it on approval.

Nine modules make up the full stack: a web surface, three workers, three adapters to outside systems, a nightly schedule and a specialist agent. None of them is wired to another: each plugs its own ontology into the engine.

Hover or tap a module to read its ontology: what it is, what it offers and what it needs.

  1. 1
    Registry

    The ontology of the whole system, assembled from every piece. It is pushed to every gate and never carries a call.

  2. 2
    Event ring

    Facts, said once. Subscribers are matched by meaning, not by who sent it.

  3. 3
    Call bus

    Carries every request between modules. There is no second path.

  4. 4
    Trust boundary

    Nothing crosses it without passing a gate.

  5. 5
    Trust gate

    One per module. Checks every call against the ontology: who is calling and what they may do. Deny by default.

The moving dot is a request. It always takes the same path: gate, bus, gate. Trust Review is an example app, drawn to show the shape.

06 · What it enforces

Governed by the architecture, not by a policy document.

A call the ontology does not describe cannot be made. These seven checks live in the core of the engine, on every call, where nothing built on top can switch them off. The needs a team declares so its module works are its permission set, so speed and security push in the same direction.

  1. 01Who is calling

    Every call carries a verified identity. Even a scheduled job runs as someone.

  2. 02What it may do

    Only what it declared it needs, and never more than the calling user is allowed.

  3. 03One gate, no side doors

    Browsers, the CLI, modules, schedules, events and queues all pass the same checks.

  4. 04Blast radius

    Every module runs in a WebAssembly sandbox with its own limits. Broken, hostile or AI-written, it stays in its box.

  5. 05Secrets

    Modules get handles, never values. Secrets never reach a log.

  6. 06The outside world

    Outbound only where declared, never to internal addresses.

  7. 07Evidence

    Signed modules only, and a hash-chained journal of every call and decision, where tampering shows.

07 · When a module goes bad

A compromised module stays one compromised module.

This is what the engine does, step by step, when a module is taken over. The moment it reaches for something its ontology never declared, the breach is known.

trust boundarycall bustrust::graphcloud::revokedenied · undeclaredwasm sandboxspecialist/securityagenthijackedtrust/mapworkercloud/iamadapternever reachedjournaldeny · specialist/security · cloud::revoke

08 · What it gives you

See everything. Build anything.

Because every relationship runs through one engine, two things come with the architecture: you can see the whole system, and you can build what your company actually needs, quickly, securely and without a growing maintenance bill.

  • Observability, built in

    Every call passes a gate and the bus, so every module is traced, measured and logged without adding its own monitoring. One trace follows a request end to end, and a failure arrives with an address: this piece, this gate, this missing permission.

  • Tailored to you

    When a new piece costs one declaration, building exactly what your company needs beats buying something generic. It is fitted to your gaps, not to a vendor's roadmap.

  • Fast, and safe to be fast

    People and agents can write modules quickly because they work inside the rules, never above them. A new module can only ever do what it declared.

  • Very little to maintain

    There is no integration code to keep alive. When an outside system changes, one adapter changes, and nothing that already worked is touched.

09 · For cybersecurity

From loud to quiet. How security wins the next five years.

Catalyst is software, but the problem it solves is yours. Security works in the most relationship-dense part of the company: every vendor, identity, tool and agent touches something else. Put those relationships on one map, governed by the architecture, and the whole ecosystem becomes something you can see, own and keep quiet.

TodayOn Catalyst
Visibility

Relationships live in configs, code and people's heads.

Every relationship is on one map, including the vendors.

Vendors

Each one adds lines, and trust that outlives its use.

They plug in as modules: declared, sandboxed, never trusted by default.

Alerts

An attacker is one more alert in ten thousand.

A quiet baseline, where an intruder is the loudest thing in the room.

Agents

A vendor's agent holds broad access. Hijack it and you inherit that access.

An agent gets a scope, a sandbox and a gate. Hijack it and you inherit a box.

Fixes

You wait on the vendor's roadmap.

You build the fix yourself, fitted to your gap.

Evidence

You reconstruct what happened from logs.

You hand the auditor the record.

Two ways to bring everything home.

  1. 01Build on it

    Bring home what you thought had to be bought. When a new control costs one declaration, a tool fitted to your gaps beats a generic one, and every vendor faces one question first: needed, not needed, or can we build it from what we already have?

  2. 02Convert to it

    Keep what you run and change how it is governed. Map the ontology, require one from every vendor so you can see whether a product fits or opens a hole before anything connects, and move systems under the same gates one at a time.

What it unlocks

  • Detection that starts at the first undeclared call, not at the first damage.
  • Third-party risk that shrinks as vendor sprawl does.
  • A record of every decision, ready for a regulator, an auditor or the board.
  • A moat nobody can rent or copy: your own ontology.

What it saves

  • Integration cost that stops growing with every new pair of systems.
  • Analyst hours spent on ten thousand alerts instead of the one that matters.
  • Spend on vendors that only exist to connect or watch other vendors.
  • The time your best people lose to hand-wiring and to cleaning up after AI.

10 · Migration

Move the value. Leave the wiring behind.

Migration should not mean rebuilding every integration somewhere new. You do not bring the relationships with you. You cut the business logic and value out of each system, drop it into the engine, and the relationships form on their own. Migration is a descent, not a climb: you come down from the breaking point of the integration tax to your baseline, as fast as possible, and build up again from there. The ontology is what tells you what to take with you on the way down. That is why it starts with the audit: you cannot enforce a map you do not have.

  1. 01Map

    The Ontology Audit lays out what you run today: every system, vendor, identity and relationship, and every hole between them.

  2. 02Cut

    Each vendor and each trust gets one question: needed, not needed, or can we build it from what we already have?

  3. 03Move

    Lift the business logic and value out of a system and drop it in as modules, one system at a time. The old wiring stays behind.

  4. 04Enforce

    The relationships form from the ontology, and the map becomes the registry. Anything it does not describe cannot connect.