Build AI agents that can only do what your rules allow.

Change a rule and it applies in seconds, with no redeploy.

Zarel is a platform for building AI agents. Their rules aren't in a prompt the model can ignore, or in code you redeploy every time they change. They live in a contract your team writes. The model proposes each action, but it only runs if the contract allows it: code checks that, not an AI.

Zarel Desk
Record a $30,000 withdrawal from account 4417.

Done, it's recorded.

── new rule, approved and published with no deploy ──

If the destination account changed recently, the back office verifies it first.

Record a $30,000 withdrawal from account 4417.

It couldn't be recorded: the destination account changed recently.

── refused · recent_destination_change ──
Talk to us → How it works
The problem

Your agent works.
Until a rule changes.

AI agents went from answering to acting: they file requests, change records, move money. And they act under a business's rules, which change: a limit, a deadline, who has to approve. Where those rules live decides what changing them costs, and whether they're always followed.

01

How long does changing a rule take?

If it's in the code, it goes through a ticket, a release and a deploy.

02

Is it followed?

If it's in the prompt, it's a request to the model. A pushy customer or a well-crafted text can bend it.

03

Which rule applied when it acted?

Logs record what happened. Rarely which rule was checked, in which version, and who approved it.

How it's solved without Zarel

Today an agent's rules live in three places, and each one has a different cost.

01

In the code

You build the agent with a framework. That's enough for a pilot. But every rule change is a deploy, and only engineering can read what changed.

02

In the prompt and in filters

You build it with an agent builder, and it changes fast. But the prompt asks the model to behave, and the filter checks what the model says, not what runs.

03

In a vendor's prompt and code

You buy it built, and it ships in weeks. But the rules aren't even yours: they're still in a prompt and in code, and the vendor owns them. You depend on the vendor to change them, and you can't see how they're enforced.

What it should take

The rule is yours, and it lives outside

Outside the code and outside the model, in a contract your team writes. You change it whenever you want, without asking a vendor or waiting for a deploy.

Test a change before publishing it, and have the right person approve it

Before publishing it, you see what would have happened to the last 90 days of requests. If the contract requires it, someone else has to approve it.

Every action is checked before it runs

The model proposes each action. Whether the contract allows it is decided by code, not an AI.

When a rule changes

Changing a rule, or the data it uses, stops being a project.

Your team changes the rule, without asking anyone outside. It edits the contract, tests it against the last 90 days and publishes it. It applies within seconds, without touching code. If the rule needs new data, that goes in the contract too, without asking engineering to change the database.

An example. After a fraud, compliance sets a new rule: if the destination account changed recently, the withdrawal waits until the back office verifies it. How many days it waits depends on each account’s policy.

First, the data the rule needs

The contract gets each policy’s hold in days, and when each destination account changed and was verified. The back office fills them in. Meanwhile, nothing changes for anyone.

Test the rule against what already happened

Before publishing it, the rule is tested against the last 90 days of requests. In the demo, against 1,090 synthetic requests, 46 would have been refused and 918 would have gone through anyway. It could not judge the other 126, and it says so. The test checks the rules, but it doesn’t run the model again.

If the contract requires it, someone else approves it

Until it’s approved, nothing changes. The approver also sees how many accounts still lack the data the rule needs.

The rule applies from the next request

The same withdrawal is now refused. The record says which rule refused it, and in which version. Once the back office verifies the account, the withdrawal goes through. Changing the hold is editing a value, not publishing a new rule. In the demo, Zarel records the request, but it moves no money.

Run on 3 November 2026 on a demo contract in a local stack, by the API and the zarel CLI.

How it works

If the contract doesn’t allow it, it doesn’t run.

The model doesn’t touch the data. What it does is build a request, like recording a withdrawal. Before it runs, code checks it against the contract and looks at four things:

If the customer pushes the model, or writes something to trick it, it makes no difference: the check is always done by code, against the contract.

The model proposes, it doesn’t execute

What the model writes is a request in a fixed format, not an order. Zarel takes nothing the model writes as valid until it has checked it.

The values that matter come from your data, not the model

Who gets paid and up to how much comes from the business’s data. If the contract sets where a value comes from, that one is used and the model’s is discarded. If the model proposes a value that breaks a rule, the request is refused.

The agent can’t change the rules

Changing the rules and using the agent go through separate services. And each customer’s data is kept apart in the database.

A $700 withdrawal, when the cap is $500, waits for a supervisor to approve it, whatever the client says.

The proof

Every change leaves proof anyone can verify.

Every change the agent makes through Zarel is recorded with the version of the rules that allowed it. The record also says who approved that version. An auditor or a partner bank can verify it without calling us, with an open-source program.

If someone alters the record, the check detects it and shows where.

$ zarel verify bundle.tar.gz --keys trust-keys.json
✓ Audit chain bundle.tar.gz verified and attested.
Attested seq: 1..30
Checkpoints verified: 1
Signed by: k_1c3770f5d8450a57
Anchoring: no external timestamp anchor in range (self-asserted time only).
Transparency log: none in this bundle.
Decisions: 1 contract version(s) cited, 1 resolved offline to their bytes.
dd7b8e7116d6 — 30 event(s) from seq 1
approved (flows: approver@example.com as approver, four-eyes), proposed by author@example.com, publications seq 6
Publications chain attested seq 1..6.
 
$ zarel verify bundle-rewritten.tar.gz --keys trust-keys.json
✗ Audit chain verification FAILED (2 anomalies):
seq 26: event_hash_mismatch
seq 27: prev_hash_mismatch
Anchoring: no external timestamp anchor in range (self-asserted time only).
Transparency log: none in this bundle.
Decisions: 1 contract version(s) cited, 1 resolved offline to their bytes.
dd7b8e7116d6 — 30 event(s) from seq 1
approved (flows: approver@example.com as approver, four-eyes), proposed by author@example.com, publications seq 6
Publications chain attested seq 1..6.

Real output of zarel verify, on 19 October 2026, with demo data on a local installation. Above, the record untouched: one person proposed the contract version and another approved it. Below, the same record with event 26 altered and signed again: the check fails at that point. The verifier runs with no internet connection.

If you're thinking of building it

“I could build this myself.”

You could. But besides the rules, you’d have to build the data, the users and roles, the approvals, the protection of private data, the channels and what it takes to run in production. Here they come included.

Users and roles

Who uses the agent and what each role may do, defined in the contract.

Approvals and scheduled tasks

An action can wait for a person to approve it. A task can run on its own, every day at 9 for example, under the same rules.

Private data

The personal data the contract marks never reaches the model.

Connection to your systems

The agent uses the systems you already have, under the same rules.

Topic filter

Keeps the agent on its subject, by keywords or by meaning.

Several customers, one installation

Each customer’s or business unit’s data is kept apart from the others.

Channels

A web console, the terminal, an interface for developers and an MCP server. WhatsApp is on the way, not shipped.

Your AI provider

You use your own account with the provider and choose the region.

What production needs

The database, the isolation between customers, the keys and the signed record come ready.

Where we actually are

The limits, stated plainly.

What Zarel does not do yet, and where each guarantee stops.

You have to write your contract. You can build or change it from the Dashboard, with our AI assistant, or work on the file from the terminal with our command line.

The record shows if someone altered it, but it can’t prevent it. The last hour isn’t sealed yet, so an alteration there wouldn’t be detected.

No certifications yet. We hold no SOC 2, ISO 27001, PCI DSS or HIPAA. The architecture is designed toward those controls, but it hasn’t been audited.

The Design Partner Program is opening. We don’t claim customers or references we don’t have.

The documentation and the platform videos aren’t public yet. They come with our new site, along with how Zarel is delivered: run by us, or self-managed in your AWS account. Neither has run in production yet.

Who it’s for

For any business that wants an agent that acts by its rules.

It shows most where a wrong action is expensive: it touches money, customer data or an obligation to someone else.

"Mostly right" is expensive

An agent that's usually right isn't enough when the rule it has to follow just changed.

Someone outside will ask

A regulator, an auditor or your customer's customer. When they ask which rule applied, the answer is already in the record.

Let's talk

Tell us what you want your agent to do.

We’re working with our first teams, whether they have an agent running or are about to build one. If that’s you, write to us.