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?
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.
- Where the holes come from
- 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.
- 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.
- 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.
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.
- A piece's ontology, in three declarations
- 01What it is
Its identity and its owner.
- 02What it offers
Its capabilities, each with a contract.
- 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.
- 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
- 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.
- 02What Catalyst changes
A piece connects once, to the map. The tenth piece costs what the first did, and so does the hundredth.
- 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.
One declaration per piece.
Integration code. There is none to write.
Nothing.
The path of a call: gate, bus, gate, at any size.
The size of the system.
The blast radius of one broken piece.
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.
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.
- 1Registry
The ontology of the whole system, assembled from every piece. It is pushed to every gate and never carries a call.
- 2Event ring
Facts, said once. Subscribers are matched by meaning, not by who sent it.
- 3Call bus
Carries every request between modules. There is no second path.
- 4Trust boundary
Nothing crosses it without passing a gate.
- 5Trust 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.
- 01Who is calling
Every call carries a verified identity. Even a scheduled job runs as someone.
- 02What it may do
Only what it declared it needs, and never more than the calling user is allowed.
- 03One gate, no side doors
Browsers, the CLI, modules, schedules, events and queues all pass the same checks.
- 04Blast radius
Every module runs in a WebAssembly sandbox with its own limits. Broken, hostile or AI-written, it stays in its box.
- 05Secrets
Modules get handles, never values. Secrets never reach a log.
- 06The outside world
Outbound only where declared, never to internal addresses.
- 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.
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.
Relationships live in configs, code and people's heads.
Every relationship is on one map, including the vendors.
Each one adds lines, and trust that outlives its use.
They plug in as modules: declared, sandboxed, never trusted by default.
An attacker is one more alert in ten thousand.
A quiet baseline, where an intruder is the loudest thing in the room.
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.
You wait on the vendor's roadmap.
You build the fix yourself, fitted to your gap.
You reconstruct what happened from logs.
You hand the auditor the record.
Two ways to bring everything home.
- 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?
- 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.
- 01Map
The Ontology Audit lays out what you run today: every system, vendor, identity and relationship, and every hole between them.
- 02Cut
Each vendor and each trust gets one question: needed, not needed, or can we build it from what we already have?
- 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.
- 04Enforce
The relationships form from the ontology, and the map becomes the registry. Anything it does not describe cannot connect.