Receipts scale where rules can't.
You can't make complex work safe by writing down every good decision in advance. A few hard boundaries plus solid receipts keep you flexible and accountable.
The safest-looking agent design is a big pile of gates. Define every allowed action, every required review, every valid state change and every condition for continuing. The model gets to be creative inside a cage made of very predictable bars.
That works for things that genuinely must never happen. A model shouldn't be able to approve its own extra powers, blow through a hard budget, rewrite a receipt from the outside world or delete some vaguely specified big target. The trouble starts when every good habit gets promoted to that same level of law.
Open-ended work has way too many context-dependent choices to list. Trying to govern all of them up front makes the system rigid, out of date and, weirdly, less safe. Workers route around the machinery, owners approve meaningless exceptions, and internal state ends up with authority it can't keep current. Restless enforces hard rules at the real authority boundaries and relies on evidence, conventions, review, recovery and receipts everywhere else.
"This must never happen" is a very expensive claim
Calling something an absolute rule means the system will block useful work rather than let it be broken. That's right when breaking it causes harm you can't undo and you can check it reliably. It's not right just because the behaviour would be nice.
"Never spend more than the granted amount" can be checked against the real budget. "Always do enough research" can't. "Don't send the same payment twice" can be built with duplicate protection and checking back with the provider. "Always pick the right specialist" depends on the task, who's available and evidence that might not exist yet.
When an open-ended judgement gets dressed up as a hard rule, the complexity moves into proxies. Count the sources. Require two reviewers. Demand a particular team shape. Enforce a workflow stage. The proxy becomes the goal and the actual quality disappears behind ticking boxes.
Hard gates belong where authority lives
Restless saves strict, predictable control for identity and consequences. Logging in, checking permissions, enforcing budgets, tracking approvals, carrying out outside actions and keeping official receipts don't depend on a model deciding whether its own request seems reasonable.
The line is about consequences, not about touching the internet. Public research can happen straight from the company computer, because reading a page doesn't usually commit the company to anything. Sending an email, charging a card, publishing a deployment or registering a domain changes the outside world, so those need a stated intent and a receipt.
That keeps the hard layer small enough to trust. High-impact actions that aren't supported can just not have a connector yet. The system doesn't need a universal policy language for every tool. It needs exact enforcement where authority moves, and a lasting record of what happened.
A receipt isn't a log line
Logs describe what a process was doing from its own point of view. A receipt answers an accountability question. What consequential action was meant to happen? Who or what allowed it? Which tool or provider did it? What exact target and duplicate-protection key were used? What did the official source confirm actually happened?
That difference really matters when the process isn't sure what happened. A network timeout after sending a request doesn't prove it failed. Marking it failed and retrying might do it twice. Marking it successful makes up a fact about the outside world. The receipt goes into an "unknown" state until someone checks with the provider.
A receipt also survives restoring the computer. The company computer can go back to an older snapshot, but the outside world can't. Keeping receipts outside the computer stops a recovered agent from re-doing things that already happened.
Most internal work should stay flexible
Inside the authority boundary, a worker might need to dig through an unfamiliar repo, switch tools, reorder steps, try a different approach, throw away a draft or fix a weird environment problem. Writing down the allowed sequence in advance would need the designer to understand the work better than the worker actually doing it.
Restless records responsibility, exact attempts, outputs, evidence and important decisions without turning every file edit or model thought into official history. OrgIntel's running event stream can be compacted and repaired. Git records meaningful checkpoints, not every keystroke. Messages stay useful context, not permanent constitutional events.
That's a deliberate rejection of "record absolutely everything" governance. A permanent log of every internal action makes storage and review bigger while making the important consequences harder to spot. Accountability needs you to be choosy about what lasts.
Receipts let you be smart after the fact
Rules act before the work and have to be written for situations you guessed at. Receipts act after something consequential happens and keep what actually occurred. That record supports audits, reconciliation, owner review and learning, without needing every future situation to look like the past.
Say a company keeps using an outside service in a way that leads to expensive corrections. The receipts can show the pattern: target, purpose, cost, outcome and the Work that asked for it. The company might respond by changing the context, adding a review habit, narrowing permissions, or adding a hard limit if the failure is clear-cut and unacceptable.
The receipt doesn't decide which response is right. It makes sure the decision is based on evidence. That matters, because one failure shouldn't automatically become permanent policy. Repeated evidence might justify a rule. Until then, local judgement should stay local.
- Record what's meant to happen before it happens.
- Tie the permission, target, purpose and duplicate protection to that intent.
- Keep provider-confirmed, self-reported, failed and unknown outcomes clearly separate.
- Use patterns in receipts to inform policy, without turning every incident into a new absolute rule.
Rules get dangerous when their facts go stale
A hard gate feels safer than model judgement because it's predictable. But predictably using the wrong facts is still wrong. An internal policy can lag behind what the owner wants now. A dependency graph can say work is blocked after the real blocker has gone. A required workflow step can force a pointless handoff because the task doesn't fit the process any more.
Before enforcing an internal rule, Restless asks whether stale facts would block useful work and whether the failure is genuinely unacceptable. If the answer's unclear, evidence and recovery might be the safer design. A model can notice context the rule never captured, and the record makes its choice reviewable.
That's not permission for agents to ignore policy. It's a demand that each policy says what it's in charge of. Hard rules own identity, permissions, budgets and actions that can't be undone. Working habits guide the work and can be challenged through someone accountable making a call.
Accountability needs room to use judgement
There's a common worry that flexibility weakens accountability, because the worker can pick a path nobody approved. Human companies show the opposite every day. A good employee is accountable for an outcome partly because they can adapt when the instructions stop matching reality. Following a broken process to the letter isn't responsible behaviour.
Freedom becomes accountable when the goal, the person responsible, the evidence, the permissions and the consequences stay visible. A worker can pick a different implementation and still bring back the exact output and checks. A lead can replace a failed producer and keep the Work. An agent can use a browser instead of an API and the action still gets the same receipt.
The system controls what mustn't drift, and records enough of the rest to support judgement. That's harder to build than total freedom or total workflow control, because it needs a clear owner for every kind of truth.
Receipts have limits
A record after the fact can't undo harm. High-stakes actions still need permission checks up front, limited capabilities and sometimes your explicit sign-off. Receipts go alongside gates. They don't replace them.
Receipts can turn into bureaucracy, too. Recording stuff you don't need creates privacy risk. Treating every internal "reviewed, looks fine" as a consequential receipt floods the record. And a receipt written by the company that did the action is weaker than confirmation from the outside provider, so it should be labelled that way.
The standard is proportion. Keep enough to answer who meant to do what, with which permission, to which target, and what officially happened. Don't copy secrets or whole provider responses just because storage is cheap.
Push complexity towards evidence, not law
As an agent company does more varied work, the number of sensible behaviours explodes. Trying to write them all down gives you a policy system as complicated as the world it's governing. The policy becomes another fallible organisation, except its mistakes are harder to overrule.
Restless picks a smaller constitution. Keep identity and permissions firm. Let reversible work stay open-ended. Tie claims to evidence. Record anything that crosses into real consequences. Be honest about unknown outcomes. Look at the patterns, and change the organisation when real results justify it.
That's why receipts scale where rules can't. A rule has to correctly predict the situation before the work starts. A receipt can faithfully describe what happened in a situation nobody predicted. When machines are doing flexible work for you, that difference keeps you productive and keeps responsibility possible.