Governed delegation: the future of business software
· Prabhu Eshwarla
Most of the AI being added to business software today makes each application easier to operate. A copilot in the CRM drafts the follow-up email. An assistant in the ERP fills in the form. Useful, but it automates the work people already do inside each system. That was never the hard part.
The hard part is the work between systems.
An invoice arrives by email. Someone reads it, works out which purchase order it belongs to, notices the amount is slightly off, decides whether that matters, asks the right person, follows up two days later, and finally records the payment. The ERP stores the transaction. Email carries the conversation. A person does everything in between: reading, interpreting, deciding, chasing.
That glue has never been automated, and not for lack of trying. RPA and workflow tools like n8n have connected systems for years. But they follow fixed rules, and they break the moment an invoice arrives in a new format, an amount is slightly off, or a case needs a judgment call. So the glue stayed with people.
What's new is that AI can now do the glue. It can read an unstructured document, interpret what it means, and make the routine judgment calls that rules never could.
That changes the question. Automation used to ask: can software execute this step? Now it asks: can we let software exercise judgment on our behalf?
That is not an intelligence problem. It's a delegation problem. Delegation requires authority, boundaries and accountability. Nobody hands a new employee the company chequebook on day one, however capable they are. They get a defined role, limits, someone to approve exceptions, and a record of what they did. Software needs the same. I call this governed delegation.
Consider what happens when we try to delegate today. Agents built into individual software suites inherit the boundaries of those suites. Public chatbots invite employees to bring sensitive work into environments the organisation doesn't control. Do-it-yourself automations connect systems and execute actions, often with no coherent model of authority, exceptions or accountability.
Each solves part of the problem. None establishes who is allowed to do what, under which conditions, and with what evidence.
Don't we already have this?
Enterprise software already has approvals, permissions and audit logs. So what is actually new? Three things.
Who acts. Today's controls were built for people clicking buttons. Permissions decide who may open a screen or press "approve". They say nothing about what software may decide when it reads an email and interprets what it means.
Where the work happens. Each application governs only itself. The ERP controls the ERP. Nothing governs the invoice's journey from email to ERP to bank, and that gap between systems is exactly where people do the chasing today.
What the record shows. An audit log records what happened: a user approved at 10:42. When software makes the decision, you also need to know why: which document it read, which rule it applied, and who authorised the exception.
Governance has to move from inside each application, built for people, to a layer above them, built for software acting on our behalf.
The infrastructure of governed delegation
It has three parts:
Policy governs actions. The system knows which actions it may take, which need approval, and which are prohibited. Privacy rules apply before sensitive information reaches a model, not after.
Deterministic systems execute them. AI interprets the invoice; code matches the amounts and moves the money. Judgment and arithmetic are kept apart, so the parts that must be exact are exact.
Evidence establishes what happened. Actions, approvals, policy decisions and the documents behind them are recorded, so any outcome can be reconstructed and challenged.
What it looks like
An invoice arrives by email. The system reads it, matches it against the purchase order, and checks the policy. If the amounts match and the payment is within its authorised limit, payment is initiated and the evidence recorded.
The next invoice is 4% higher than the purchase order. The system stops. It presents both documents and the discrepancy to the finance controller. She approves the exception with a note, and the work continues.
Later, finance reviews the history of these exceptions and decides whether to raise the threshold for manual approval. The AI didn't get smarter. The organisation delegated more, because it had defined the boundaries of that delegation and could see the evidence.
Beyond one company
The hardest workflows don't stop at the boundary of an application, and often not at the boundary of an organisation. Governed delegation makes it possible to coordinate work across applications and across organisations without anyone surrendering control of their systems or their data.
Where Forge fits
Forge is our implementation of this thesis. We are building it as a layer above existing systems of record, not another one. Personal data is masked before it reaches any model. Administrators set a privacy floor that no individual can lower. Programs run deterministically, and every action is recorded. Between organisations, one party can already run its method on another party's data without either exposing its side of the process.
Forge will evolve. The thesis will hold. AI makes the action possible; the infrastructure of authority and evidence makes it viable.
The goal isn't to remove people from every decision. It's to stop requiring people to carry every process.
Keep the hard calls with people. Remove the chasing.
Where would you let software act on its own, if you could prove afterwards exactly what it did, why it did it, and who authorised it?
