Agent Trust Layer - Authority control for autonomous AI agents

The Agent Trust Layer is an AI-powered authority system I built and deployed for agentic workflow automation. It sits between an AI agent and the actions it takes, sorting every step into one of three levels of trust, so the agent runs autonomously on routine work and stops cold on anything a human needs to approve.

The Problem

AI agents can now run enterprise workflows end to end, hundreds of times over. The problem is nobody trusts them to. The standard answer today is monitoring, a full record of what the agent did after it ran. But that's a receipt, not a seatbelt. It tells you what already happened, it doesn't stop anything. The real question an enterprise asks isn't "what did the agent do," it's "what should the agent be allowed to do without me." Nobody was answering that one.

What I Built

A trust layer that assigns authority per step before the agent acts. Three tiers: Assert, where the agent is confident and the action is harmless so it just proceeds. Flag, where it's unsure, so it does the work but surfaces its reasoning for review. And Halt, where the action is irreversible, so it stops completely and waits for a human. One rule sits above all of it: anything that can't be undone always halts, no matter how confident the model is.

The agent also proposes rules as it goes. When it flags something and you agree with how it handled it, you accept the rule and it stops asking about that situation on future runs. Human review shrinks over time toward only the things that genuinely need judgment.

How It Works

Built in React, deployed on Vercel, powered by the Claude API. The model reads each workflow step and its context, assigns the authority tier against a fixed rubric, writes the reasoning in plain English an operations person can act on, and proposes a specific, testable rule for anything it flagged.

The demo runs an invoice reconciliation workflow across 200 invoices. 186 process automatically. 14 get flagged, including 11 where the supplier name doesn't match the records and the agent matched on tax ID instead, explaining that a name mismatch can sometimes signal fraud. Two separate halts fire for two separate irreversible actions, sending $47,000 in payments and writing those payments to the accounting books, each routed to a different approver because they're different responsibilities.

I also engineered a failure into it on purpose. A field gets renamed upstream and the update breaks. Instead of an error code, the agent says "the suppliers were paid, but the records still say unpaid," diagnoses the cause, proposes a fix, and recovers once you approve it. Every demo works. I wanted one that showed what honesty looks like when it doesn't.

Outcome

Built and deployed in a single night, start to finish. Nobody asked for it. I found the gap between what agentic AI can do and what enterprises will actually let it run unsupervised, and built a position on it rather than writing one.

Closing Thoughts

The Trust Layer is the clearest example of how I think about AI products right now. The gap between an agent that works and an agent people actually let run unsupervised isn't a model problem, it's a design problem. Adoption dies the first time a tool is confidently wrong in front of someone senior, so I build for that moment from the start. And I built the whole thing myself, in a night, because I'd rather show a position than describe one.