Skip to content

Architecture in three layers

The software in an engagement sits in three layers: the system of record you already have, and the operations layer and the agent layer that our forward-deployed engineers build on top of it. This page says what lives in each, how they connect and the rule that holds them together: your ERP stays the system of record.

+--------------------------------------------------------------+
| 3. Agent layer |
| AI agents that work the queues, under the autonomy ladder |
+--------------------------------------------------------------+
| take work from the queues, act inside their limits
v
+--------------------------------------------------------------+
| 2. Operations layer built for you, owned by you |
| screens, queues, rules and integrations |
| your people approve work and handle exceptions here |
+--------------------------------------------------------------+
| reads and writes only through interfaces the ERP supports
v
+--------------------------------------------------------------+
| 1. System of record |
| your ERP and other core systems: the source of truth |
+--------------------------------------------------------------+

Read it from the bottom up. Your ERP holds the transactions. The operations layer is the software built around your workflows, and it is the only layer that talks to the ERP. The agents sit on top and reach the ERP only through the operations layer.

Layer What lives there Who works in it
System of record Customers, items, price lists, sales orders, purchase orders, inventory balances, invoices and the ledger Your people, as they do today
Operations layer The screens, queues, rules and integrations built for your workflows, and the working data they produce: source documents, drafts, approvals, exceptions and the audit trail The people who do the work: the order desk, buyers, AP, customer service
Agent layer AI agents, each tied to one workflow, with its limits and its level on the autonomy ladder Agents. People supervise them from the operations layer

The operations layer has four kinds of parts:

  • Screens: where your people do the work and check it. For example, an order screen that shows the customer’s purchase order next to the order being entered.
  • Queues: lists of work waiting for someone, such as purchase orders to enter, invoices to match and exceptions to resolve. People and agents take work from the same queues.
  • Rules: your policies, written as checks the software runs. The price must match the price list. The order must fit the credit limit. An invoice must match its purchase order and receipt within the tolerance your controller sets.
  • Integrations: the connections that read from your ERP and write finished transactions back to it.

Some of the operations layer comes from our reusable tooling: the work queue, the approval screens, the audit trail and the stop switch. Everything specific to your workflows is written for you, and your contract gives you the right to keep running and changing the tooling inside your software after we leave.

Your people keep using the ERP itself for everything the operations layer does not cover.

Where the operations layer and the agent layer are hosted is agreed in the contract. Data ownership and portability covers that, and what you own.

The operations layer must never turn into a second ERP that disagrees with the first. Our engineers build to four rules that prevent that.

  1. A transaction is real when it is in the ERP. The operations layer holds work in progress: the email, the draft, the approval, the exception. When the work is finished, it writes the transaction to the ERP and keeps the ERP’s document number as the link.
  2. Master data is maintained in the ERP. Customers, items and price lists are read from the ERP. The operations layer may hold a read-only copy for speed, refreshed from the ERP, but the ERP’s version always wins.
  3. We use only interfaces the ERP supports. We read from the ERP and write to it through those interfaces, and we never write to its database tables directly. Attaching to your existing ERP lists them in order of preference.
  4. The operations layer keeps only what the ERP has no place for. The original purchase order PDF. The corrections the order desk made to a draft. Which contact at a supplier answers follow-ups.

There is a simple test of whether the rule holds. If the operations layer were switched off tomorrow, the ERP would still hold every finished transaction, and your people could go back to keying into it directly. The work would be slower, and work in progress would have to be picked up by hand, but no finished transaction would be missing.

Our engineers build the agent layer so that agents have no route of their own into the ERP. An agent takes a piece of work from a queue and gives back a result: a draft, a prepared transaction or, at the higher levels of the autonomy ladder, a completed one. Before anything is written to the ERP, the operations layer checks it against your rules. Those rules apply the same way whether a person or an agent did the work. For an agent, the operations layer also checks the action against the agent’s limits.

This is why approvals, exceptions, the audit trail and the stop switch all live in the operations layer. There is one place to look, for the work people did and the work agents did. It also means the work does not depend on the agent. If an agent is stopped, the work stays in the queue and your people do it by hand.

Much of a workflow calls no AI model at all. Looking up a price or checking a credit limit is done by the rules. Which model an agent calls, and what data a step sends to it, is covered in AI providers and your data.

As an illustrative example, here is sales order entry at Level 2 (Prepared), where an agent builds each order and a person approves it.

  1. A customer emails a purchase order. The operations layer puts it in the order queue with the original attachment.
  2. An agent takes it from the queue and builds the complete sales order from the customer, items and prices that the operations layer reads from the ERP.
  3. The rules check the order against the price list and the credit limit, and look for an open order with the same purchase order number.
  4. Someone on the order desk opens it, sees the purchase order next to the order and approves it.
  5. The operations layer writes the sales order to the ERP through a supported interface and stores the ERP’s order number.
  6. The audit trail records what the agent did, and the operations layer records who approved the order and when.

If the ERP is missing, at end of life or cannot be extended, the operations layer includes an ERP-like core that covers orders, inventory, purchasing and invoicing, and you own it. The agent layer works the same way on top of it. See When there is no usable ERP.