How long does changing a rule take?
If it's in the code, it goes through a ticket, a release and a deploy.
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.
Done, it's recorded.
If the destination account changed recently, the back office verifies it first.
It couldn't be recorded: the destination account changed recently.
── refused · recent_destination_change ──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.
If it's in the code, it goes through a ticket, a release and a deploy.
If it's in the prompt, it's a request to the model. A pushy customer or a well-crafted text can bend it.
Logs record what happened. Rarely which rule was checked, in which version, and who approved it.
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.
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.
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.
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.
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.
The model proposes each action. Whether the contract allows it is decided by code, not an AI.
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.
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.
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.
Until it’s approved, nothing changes. The approver also sees how many accounts still lack the data the rule needs.
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.
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.
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.
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.
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.
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.
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.
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.
Who uses the agent and what each role may do, defined in the contract.
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.
The personal data the contract marks never reaches the model.
The agent uses the systems you already have, under the same rules.
Keeps the agent on its subject, by keywords or by meaning.
Each customer’s or business unit’s data is kept apart from the others.
A web console, the terminal, an interface for developers and an MCP server. WhatsApp is on the way, not shipped.
You use your own account with the provider and choose the region.
The database, the isolation between customers, the keys and the signed record come ready.
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.
It shows most where a wrong action is expensive: it touches money, customer data or an obligation to someone else.
An agent that's usually right isn't enough when the rule it has to follow just changed.
A regulator, an auditor or your customer's customer. When they ask which rule applied, the answer is already in the record.
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.