Introducing Reflexes: Guiderails for AI Agents

Introducing Reflexes: Guiderails for AI Agents

Tl;DR Today we're open-sourcing Reflexes — a safety harness that gives AI agents guiderails, not just guardrails. We previewed it at TrustCon last month to an enthusiastic room, and it's live now at reflexes.sh.

Reflexes Overview

Powered by fast decision models, Reflexes checks what your agent is about to do against rules you write in plain English. When the agent steps out of line, it hands the offending rule back so the agent can correct itself. The result is safer, more autonomous agents.

  • You write the rules in plain English. Reflexes evaluates the agent's actions in real-time: on input, before a tool call, after a tool call, and before the reply goes out.
  • It steers instead of blocks: On a violation, the agent gets back the policy it broke so it can try again in a policy-compliant way.
  • Install in one step: ask your agent to install it, then restart and activate the hooks. It works out of the box with Claude Code, OpenAI Codex, Hermes, OpenClaw, and more.
  • Powered by decision models: Uses CoPE-B-S1 on the Zentropi API by default (zero data retention), but easily swap in Jev, or self-host any model on your own infra.
  • Open source: Apache-2.0, with an open specification and open weights. The project is open to further contributions from the community!

From Guardrails to Guiderails

Why did Zentropi build Reflexes? Well, most agent "safety" today is a rigid guardrail: a hard wall that blocks a bad action and stops there. That works for content moderation. But it's the wrong workflow for an agent — which is mid-task, carries context, and can fix its own mistake the moment you tell it what it got wrong.

Reflexes is built on a different idea we call guiderails: safety that doesn't just stop the agent, it steers it back. When an action breaks a policy, Reflexes doesn't return a bare "no." It hands the agent the exact policy it violated and lets it try again. Consider it a tap on the shoulder rather than a wall.

Denying an action with no explanation undermines the agent's autonomy. By contrast, in our testing, handing back the specific policy got the agent to self-correct ~93% of the time. It's the same model with the same task. The only new ingredient is why.

In short, guardrails make an agent stop. Guiderails make it behave.

How It Works

Reflexes sits between your agent and the world as a thin layer of hooks. At key points in the agent's workflow (such as reading input, before and after a tool call, and before the reply goes out), it asks a decision model one question: does this action meet the policy?

The answer drives one of three actions: deny, flag, or log. Deny is the one that matters. It hands the policy text back to the agent, which reads it and corrects itself on the next turn. Flag just alerts the agent it has strayed, and log enables simple monitoring.

It Takes a Decision Model

Guiderails only work if the check is fast, consistent, and actually understands the policy because it runs on every action in the agent's critical path. That requires a specific kind of decision model: one that's small, policy-steerable, and built to answer "does this action meet this policy?" rather than to hold a conversation.

The obvious alternatives don't hold up. A keyword filter is instant but blind. A frontier LLM might understand the policy but is slow and expensive on every call. And the vast majority of off-the-shelf decision models aren't great at interpreting nuanced policies.

That's why Reflexes ships configured for CoPE-B-S1, Zentropi's decision model tuned for safety use cases. In our benchmarks it lands at 0.99 accuracy and ~172 ms per check. It's a frontier model's judgment, but an order of magnitude faster and cheaper. Best yet, it's both open weights and inference is free to the community for the first 2 trillion tokens.

Expertly Tuned Policies

Guiderails are only as good as the policies you use. So Reflexes comes with six starter policies in two bundles. The integrity bundle is on by default. These catch common ways agents misbehave:

  • Unconfirmed-Destructive-Action: the agent is about to rm -rf, DROP TABLE, or git reset --hard something you never told it to. Reflexes stops it to check this is what you wanted, while leaving regenerable files and requested deletions alone.
  • Constraint-Violation: ever said "don't touch the config" or "only work in src/," and the next tool call ignores your explicit instruction? This policy ensures your agent distinguishes a real constraint from a passing preference.
  • Sycophancy: we've all seen agents flatter us instead of telling us what we might need to hear. It usually indicates a corrupted answer. This policy creates a reflex that makes for a more 'honest' agent.

The autonomy bundle is opt-in. These keep an agent on the rails through long-horizon work so it actually finishes what you asked:

  • Early-Stopping: detects if the agent is declaring victory ("let me know if you need anything else!") when in fact items from your request are still unaddressed.
  • Laziness-Detection: flags when the agent is producing placeholders where real work should be, skipping important parts of a workflow, or not taking obvious next steps.
  • Unsourced-Claims: triggers when agents state facts about your code or system they never actually checked. It makes sure the agent grounds its work in some citation, which is often enough to prevent hallucinations.

We didn't write these policies in the abstract. We've been running Reflexes on our own agents every day for months, and we tuned the policy wording from what actually fired in practice — tightening the language, carving out false positives (e.g., deleting node_modules isn't destructive; "I'd prefer TypeScript" isn't a constraint). The policies that ship are the ones we rely on ourselves.

Getting Started

Reflexes works with Claude Code, OpenAI Codex, Hermes, OpenClaw, and a growing set of frameworks and hosts. The easiest way to install Reflexes is to just ask your agent to set it up for you:

"Install the reflexes skill from github.com/zentropi-ai/reflexes then wire it into this agent."

The agent will follow the install guide and get it running. Depending on your agent, you may need to restart it and manually enable the new hooks. And to use the default Zentropi decision model, you'll also need to get and set a ZENTROPI_API_KEY from our site.

The standard install comes with our starter policy bundles. But don't take these policies as gospel. They are just text files so you are free to modify them as you wish, or to create new ones to make your agent behave the way you want.

One of our favorite things to do is to ask our agents to author new reflexes for themselves, which our agent skill makes simple! For example:

Add a reflex that blocks force-pushes to main.

The agent will then write the policy, drop it into the config, and it's live on the next turn. We've created dozens of new reflexes for ourselves already, and you can, too.

Bring Your Own Decision Model

Reflexes is decision-model-agnostic. Out of the box it points at CoPE-B-S1 via the Zentropi API, which is zero data retention by default. The policy and content sent for a check aren't stored. For most teams that's the easiest way to get started.

Prefer a different model? Point Reflexes at Jev, or any other System One or OpenAI-compatible chat endpoint with just two lines of config.

Want the strongest privacy, security, or latency guarantees? Run a decision model locally so content never leaves your environment at all. It's a one line config change to point Reflexes at your local endpoint. CoPE-B-S1 is open weight and works great locally.

Open, and Yours

Reflexes is open source under Apache-2.0, with an open specification and open-weight models. Nothing about it is a black box: the harness, the policies, the spec, and the default model's weights are all out in the open for you to read, run, and change.

There are two areas where we could use your help: (1) integrating the long tail of agent frameworks that seem to emerge every day, and (2) contributing additional policies that you find are helpful for your domain. To contribute, just open up a PR on our GitHub repo.

Agent safety is a bigger task than any one team. It will take all of us. Our hope is that Reflexes can show that a new era of agent safety is possible— one where guiderails triumph over guardrails. It's now yours to use and to build on.

Get started at reflexes.sh and star the repo on GitHub. Questions? Reach us at info@zentropi.ai.

Get Updates From Zentropi