miramarlabs.ai
Architecture Overview

A reasoning engine in the stream.

Catalyst places bounded frontier-level reasoning directly in your data path. Raw events in; reasoned, validated, audited decisions out — within the latency budget the domain allows. The same architecture serves markets, payments, and operations because the hard parts — reasoning on raw data, validating it, and keeping humans on the high-stakes trigger — are the same everywhere.

The reasoning engine

A frontier LLM agent operates as the decision authority. It's implemented as a directed stateful graph; state is checkpointed to a persistent store after every node execution. Full crash recovery. Full replay. Full audit.

Its distinguishing choice: the agent receives raw source values with human-readable annotations — a metric with its threshold notes, a trend with its classification, an event record with its context — never a pre-cooked composite score. This lets the reasoner apply domain knowledge directly to live data rather than inheriting brittle threshold tuning from a scoring layer above it. It reasons in a bounded loop with a tool registry over that data, so every conclusion is traceable to the tools it called and the values they returned.

Streaming context pipeline

Behind the decision loop sits a continuous pipeline of specialist reasoners — each a purpose-built component producing a structured artifact — that collectively maintain the context the engine reasons over. The engine doesn't fetch the world at decision time; it inherits a pre-digested, always-fresh view that the pipeline keeps current as the stream flows. A synthesis step reads across the specialists and produces a ranked briefing the reasoning engine consumes as tool-callable context.

Isolation by construction. The context specialists never take actions and never touch the state the acting path depends on. Their output is structured artifacts. A stale or failed context run is visible — the briefing simply reflects the last successful pass — but cannot cause a bad action. It can only fail to inform a good one.

Dual-pass validation

Every decision the reasoning engine produces passes through an independent rule-based validator. The LLM catches qualitative issues: weak signal quality, adverse conditions, contradictory evidence. The rule layer catches quantitative constraint violations: hard limits, exclusion lists, confidence floors, policy bounds. Neither layer alone is sufficient; a decision ships only when both agree.

Latency and cost by construction

Realtime means the reasoning has to fit a budget. Catalyst routes by tier — fast models at the edge for triage and the common case, a frontier model reserved for the decision that genuinely needs deeper reasoning — so reasoning depth scales to what each event is worth. Loops are bounded and every decision carries a per-call budget; an event can't spend unbounded compute, and the system degrades predictably under load rather than stalling the stream.

Risk-tiered human-and-rule gateway

The human gateway is non-bypassable on high-stakes actions and creates a friction gate plus audit trail — but it is not the primary defense. Structural limits run first: allocation and exposure caps, per-entity guards, identity and environment verification, and hard bounds that hold even under operator override. Every force-override is audit-logged with the system's chosen value, the operator's value, and the operator's stated reason. This matches the risk-tiered human-in-the-loop pattern that regulated domains — and frameworks like the EU AI Act's high-risk obligations — increasingly require for AI acting on consequential events.

Trace-based evaluation and self-learning

The engine's audit trail isn't just for forensics — it's the input to a post-hoc evaluation that grades every decision against what actually happened.

Judge over the trace

Once outcomes settle, an LLM judge re-reads the original decision trajectory — the tools invoked, the raw data returned, the reasoning steps recorded, the validator verdict — alongside the realized outcome, and scores whether the reasoning path was defensible in retrospect. Not merely "was the outcome good," but "given what the engine saw and how it reasoned, was the decision sound?"

Learning without retraining

Aggregate verdicts feed a calibration document injected into the reasoning engine's system prompt at start. Yesterday's misses inform today's decisions: patterns the judge consistently flags as poorly reasoned become explicit guidance at the top of the next cycle. No fine-tuning, no gradient updates, no model retraining. Behavior shifts by editing the context the reasoner reads — which is auditable, versionable, and reversible in a way weight updates are not.

The through-line: Catalyst treats structural correctness — reasoning over raw data, independent validation, trajectory-recorded state, pre-action guards — as the primary substrate. Human review and reflection are the slower, higher-quality outer loops. Neither layer is asked to do the other's job.


AI safety: the architecture, turned outward

Everything above is a safety architecture. Bounded reasoning over raw data, an independent validator, a non-bypassable human gateway on high-stakes actions, and a complete replayable audit trail are exactly the controls you want supervising an AI system in production — so Catalyst applies them to one.

Pointed at another model or agent, Catalyst reasons over the live stream of its inputs, outputs, and tool calls and renders a verdict on each: allow, block, or escalate. Because the supervisor reasons rather than matching a blocklist, it catches what static filters miss — jailbreaks, prompt injection, data-exfiltration attempts, and off-policy or unsafe behavior no one has written a rule for yet.

Input screening

Prompt-injection and jailbreak reasoning before the protected model ever sees the request — not a regex blocklist, a judgment on intent and context.

Output adjudication

An explainable allow / block / revise verdict on every generation, with the reasoning path recorded alongside it — so a block is defensible and a false block is diagnosable.

Agent-action gating

High-stakes tool calls and agent actions route through the same non-bypassable human-and-rule gateway the trading and operations paths use. Nothing irreversible fires unsupervised.

Governance audit

Every supervised decision lands in the append-only ledger, replayable node-by-node — the evidence base AI-governance regimes and the EU AI Act's high-risk obligations ask for.

Safety is the substrate, not a bolt-on. The platform that supervises your AI is built from the same controls it enforces: independent validation, structural guards before human review, and an audit trail complete by construction. The dogfood is the demo.


Where it runs

Catalyst is designed to sit next to your data. It ingests from your existing streams, reasons in place, and emits decisions and a full audit ledger back into your systems — with the frontier model and the human gateway configured to your latency, compliance, and risk posture. The verticals differ in their signals and their guards; the engine does not.


← Back to home  ·  About →