TL;DR: Most "AI governance" today is text: a system prompt asking the model to behave, and a policy PDF asking the company to make it. A model can ignore both. Cyan Eclipse Technologies, a software firm, takes the opposite position — an agent's limits should be hard, code-level guardrails sitting directly inside its execution path, enforced whether the model cooperates or not. Its architecture runs in three phases the company maps to the NIST AI Risk Management Framework: mandates and pre-flight checks before the agent acts, fail-closed enforcement while it acts, and cryptographic receipts after.

Agent Brief: Cyan Eclipse Technologies builds agent-governance tooling organized as Before / During / After. Before: machine-readable written mandates (spending caps, domain allowlists, expiration times) plus pre-execution verification — Cluster checks cryptographic signatures and provenance before code runs; Eclipse Test Bench and Eclipse Bazaar audit third-party MCP tools for schema safety and security flaws before agents connect. During: fail-closed execution that blocks on any anomaly, the Monocle governed browser (pre-approved domains and permitted actions only), and the Eclipse Agent Wallet (hard spending limits, human approval above thresholds, instant kill switch), with zero background telemetry by design. After: every action and every regulatory or sanctions record read generates an append-only, hash-chained receipt; Eclipse Thread (Evidence Weaver) and Burnline let compliance officers independently recompute hashes from raw source data, so a single altered byte produces an explicit verification failure.

Why do prompts and policies fail?

A prompt is a request. It lives in the same channel as everything else the model reads — including the web page the agent just opened, the document it was asked to summarize, and the tool output it cannot distinguish from instructions. When a malicious page tells the agent to ignore its earlier directions, the "guardrail" and the attack are made of the same material: text. Which text wins is a coin the model flips.

A written company policy is weaker still. It binds the humans who signed it. It does not execute. Nothing in a PDF stops an agent from visiting a domain it should not visit, spending past a limit it was never technically given, or calling an API nobody approved. The policy describes the compliance; it does not perform it.

This is no longer an academic gap. As The White Report covered in October, the major banks have begun writing agent liability into their customer agreements — Wells Fargo's Section 15 deems anything your agent does to be initiated and authorized directly by you, mistakes included. When the liability lands on the user either way, "the model was told not to" is not a defense. It is an epitaph.

Why do regulated companies stall on agents?

Not for lack of appetite. Most regulated companies want agents exactly where the manual cost is worst — screening, checking and re-checking, the analyst hours that grow with every new rule and every new counterparty. The projects die anyway, in legal and security review, on the same two grounds: the model hallucinates, and when it acts, it leaves no audit trail an examiner would accept.

Read the architecture against those two objections and it resolves into two deliverables. First, verified global sanctions and regulatory data straight from official gazettes and primary sources, so the agent's answers are grounded in records that carry their own proof. Second, a locked-down browser and agent environment in which every action comes back with a cryptographic receipt. That pairing is what unblocks deployment: high-stakes work, automated — without failing an audit.

The same two objections govern defense and federal work, at higher stakes — and there the environment itself is the concern. Sensitive workflows cannot run on tooling that phones telemetry home to a vendor's cloud. A mandate-locked environment with zero cloud telemetry, where every domain visited, file merged and dollar spent is bound to a written mandate and stamped with a receipt that verifies offline, without calling any server, is what lets those teams take the speed without opening a new breach path.

What happens before the agent acts?

The first phase replaces instructions with authority. Before an agent can browse a website, spend money, or call an API, its exact authority has to exist as a machine-readable mandate: what it may do, where it may do it, how much it may spend, and when the permission expires. No mandate, no action. The mandate is not advice to the model; it is the boundary the machinery enforces.

The same phase vets everything the agent is about to touch. Cluster, the container verification gate, checks cryptographic signatures and provenance before code is allowed to run at all — unsigned or unverifiable code does not get a warning, it gets refused. Eclipse Test Bench and Eclipse Bazaar audit third-party Model Context Protocol tools for schema safety and security flaws before agents connect to them, so the tool supply chain is examined before it is trusted, not after it misbehaves.

In NIST AI RMF terms, this is the Govern and Map work done in advance and in writing — except the writing is structured data the system can check, not prose a person can file.

What happens while the agent acts?

The second phase assumes something will go wrong mid-task, and decides in advance what "wrong" does. The answer is: stop. Fail-closed execution means an unverified data field, a price that changes during checkout, or a network error blocks the action outright. The agent does not get to guess, improvise, or proceed on vibes. In a prompt-governed system, an anomaly is an invitation to hallucinate a way through it. Here it is a wall.

The workspaces are bounded the same way. Monocle, the governed browser, restricts an agent to pre-approved domains and permitted actions — the open web becomes a list, and anything off the list does not load. The Eclipse Agent Wallet enforces hard spending limits, requires human approval above set thresholds, and carries an instant kill switch, so the maximum damage a compromised or confused agent can do with money is a number somebody chose beforehand.

And the tools phone nothing home. Zero telemetry by design means no background usage data is collected or transmitted — a property that matters most exactly where agents are being asked to work: inside enterprises and governments whose data cannot leak to external servers as the price of using the software.

What happens after the agent acts?

Most agent systems end the story with a log — a file the same system wrote, which the same system can quietly edit. The third phase replaces the log with evidence. Every action an agent takes, and every regulatory or sanctions record it reads, generates an append-only, hash-chained cryptographic receipt: each entry bound to the one before it, so rewriting history breaks the chain in a way anyone can detect.

The receipts are built to be checked by people who do not trust the system that produced them. With Eclipse Thread (Evidence Weaver) and Burnline, a compliance officer can independently recompute the hashes from the raw source data. If a single byte of a record or a log was altered after the fact, the recomputation does not shrug — it throws an explicit verification failure. The auditor does not have to take the AI's word for what happened. That is the entire point.

What is the agent reading?

Guardrails on actions are only half the problem. The other half is what the agent believes. Ask a model whether a counterparty is sanctioned or what a new rule requires, and it answers with the same confidence whether it knows or not. That is hallucination, and in compliance work a confident wrong answer is worse than no answer.

The Witness catalog is the data side of the same architecture: official public records from governments around the world — sanctions lists, official gazettes, laws and filings — taken from their primary sources and sealed at the moment of collection. It already runs at scale: over 200 official sources live, more than 1.65 million records sealed. Every record carries its provenance inside the same hash-chained receipt system that logs the agent's actions, and the seal is independently verifiable: recompute the hashes from the raw source, and the record either matches or the check fails, in the open. Audit-proof global data, not a scrape you have to take someone's word for.

Used live, that is grounding: an agent's sanctions check resolves against the sealed list itself, not against what the model half-remembers, and a compliance team questioned a year later can produce the exact list a screening decision was made against — and prove it has not changed by a single byte since. Used as data, the sealed corpora give AI builders training and evaluation material whose contents are provable: what was in it, when it was captured, and that nothing has been altered after the fact. Clean input, verifiable forever — the before, during and after discipline applied to the data itself.

The stack at a glance

| Tool / Layer | What It Does for AI Safety & Compliance | |---|---| | Eclipse Agent Wallet | Stops rogue spending with hard caps, allowlists, approval thresholds, and kill switches. | | Monocle & Workspace Apps | Keeps AI browsing, notes, and schedules inside a mandate-locked environment with action receipts. | | Eclipse Test Bench / Bazaar | Vets external MCP servers for security and schema compliance with revocable trust badges. | | Codex, Verbatim & Data Feeds | Prevents AI hallucinations on sanctions and laws by serving cryptographically witnessed source records. | | Plumb, Parity & Thread | Provides AI-native static code analysis, proof-sealed file merges, and tamper-evident audit packages. |

What happens next?

The argument underneath the product list is the part worth watching. The industry is splitting into two theories of agent safety. One says the model itself will get aligned enough that instructions suffice — governance as literature. The other says agents are software acting in the world, and software is governed the way it has always been governed: permissions, sandboxes, spending limits, and audit trails that survive the auditor's distrust.

The banks have already voted with their contracts: the risk is yours. If that is the world agents are entering, then the difference between an agent with a prompt and an agent with a mandate is the difference between a promise and a proof. Cyan Eclipse is betting the market eventually asks for the proof — before the agent acts, while it acts, and after, when someone finally checks.


Disclosure: The White Report and Cyan Eclipse Technologies LLC are under common ownership. This article describes the company's own stated architecture and product claims.