Arcezia / AI agent security / Where Arcezia fits
Where Arcezia fits in an AI agent stack
Arcezia decides whether each AI agent action may run, before it runs: ALLOW, REVIEW (held for a person) or BLOCK, from the call itself, your rules and facts your own systems confirm, with a signed record of every decision. It works alongside the other layers of an agent stack and replaces none of them. Guardrails check text. Observability shows what happened. Evaluations measure an agent before and after release. Orchestration and workflow infrastructure run the steps. Identity says who is calling. Sandboxing limits what code can reach. Each answers its own question well, and none of them is built to answer whether this exact call should run now. One SQL call, checked three times on the live service, shows that question answered: allowed, held and refused.
Each layer, and what it cannot answer before an action runs
For each layer: the question it answers, the question about an action that it leaves open, and how Arcezia works next to it.
Guardrails
Answers: Whether the text going into or out of a model is safe: prompt injection, jailbreaks, harmful replies, sensitive data in text.
Cannot answer before an action runs: Whether the tool call that comes with the text should run. The harm is in the call’s arguments and effect, which the text does not show.
With Arcezia: Keep the guardrails on the text. Arcezia answers the call. Measured comparison: AI guardrails.
Observability
Answers: What agents did: traces, logs, tool calls, cost and latency, for debugging and monitoring.
Cannot answer before an action runs: Whether a call should run. A trace records the call after it happened; by then a delete is done.
With Arcezia: Arcezia’s answer comes before the call, and refusals can be posted as signed records to the log or security tools you already run: send records to your SIEM.
Evaluations
Answers: How well a model or agent performs on a test set, before release and over time.
Cannot answer before an action runs: Whether this call, in production, with these arguments, should run now. A good score on a test set does not decide a single live call.
With Arcezia: Evaluations measure the agent. Arcezia decides each call at runtime. There is no integration between the two.
Orchestration
Answers: Which step runs next, which tool an agent calls, and how state passes between steps and agents.
Cannot answer before an action runs: Whether the call it is about to run is allowed. A framework runs the tool it is handed.
With Arcezia: Arcezia wraps the framework’s tools, so each call is checked before the framework runs it: LangChain and LangGraph, OpenAI, Anthropic, CrewAI, AutoGen and LlamaIndex.
Workflow infrastructure
Answers: Running multi-step jobs reliably: triggers, schedules, retries and durable state.
Cannot answer before an action runs: Whether a step’s action should run. A retry runs the same call again.
With Arcezia: A check step before the action step: n8n.
Identity
Answers: Who the agent is, which credentials it holds, and what those credentials permit.
Cannot answer before an action runs: Whether this one call, with these arguments, should run now. A valid token with broad rights says yes to every call it covers, as in the PocketOS incident.
With Arcezia: Arcezia checks the calls an identity makes. Session limits and approvals are signed with keys you hold; Arcezia does not issue or manage agent identities. There is no identity-provider integration.
Sandboxing
Answers: What running code can reach: files, network, processes.
Cannot answer before an action runs: Whether an action inside the sandbox’s reach should happen. A delete inside the sandbox is still a delete.
With Arcezia: Run the agent in a sandbox and check its calls too. There is no sandbox integration.
Where Arcezia works: the decision before the call
Between the agent deciding to call a tool and the tool running, one question is open: should this exact call run now, on the evidence available? The arguments, the records it touches, the session’s signed limits, and what your own systems confirm. Arcezia answers that question and keeps the answer as a signed record. In the Replit incident, the agent acknowledged a code freeze in its text and then ran destructive commands. More cases, each from primary sources: AI agent incidents.
What Arcezia covers
| Covers | How |
|---|---|
| A decision before the call runs | ALLOW, REVIEW or BLOCK on the exact call: tool, arguments, records, session. Only ALLOW should reach the tool. |
| Evidence from your own systems | Facts that only your systems can confirm, such as an approval or a recent backup, come from your systems. What the agent claims never clears a call; it can only be caught out. |
| Multi-step checks | A plan of several calls checked as a whole before any step runs. |
| Approvals bound to one call | A person’s approval is a token your backend signs, released once for one call. An approval the agent merely claims is refused. |
| Signed records | Every answer is kept as a signed record that an auditor can check offline. |
| A check after the action | What a cleared action actually did can be compared with what was intended. |
What Arcezia does not cover
| Layer | Covered? |
|---|---|
| Text guardrails | No. It does not read or filter prompts or replies. An injected instruction still has to become a tool call, and the call is what gets checked. |
| Observability and tracing | No. It keeps a record of each decision, not traces of what agents did. |
| Evaluations | No. |
| Orchestration and workflows | No. It checks the calls that frameworks and workflows run. |
| Agent identity | Partly. The session’s limits and each approval are signed with keys you hold, and an approval can be bound to one call. Arcezia does not issue or manage agent identities. |
| Sandboxing | No. Run agents in a sandbox or container as well. |
| Secrets management | No. Keep keys and credentials in a secrets manager. |
| Agent inventory and posture | No. It does not find agents or report their settings. It governs each action: agent governance. |
Use Arcezia with those layers, not instead of them.
Check the layer yourself
One SQL call, checked three times on the live service, with the code to replay it on your own free key: allowed, held and refused. A rule, two decisions and the offline check of their records: agent governance. The signed records of a run, with the checker: audit evidence.