INTERNAL · STAGED PROPOSAL — 2026-08-21 5:02p SUBMISSION (THE ALTERNATING SET), AS RECEIVED (PIPELINE HYGIENE: SOURCE NOTES REMOVED) · NOINDEX & UNLINKED · SITE-MAP
A2go Map your priorities

Home · How ADIP works

How ADIP works, in more detail.

Five things the homepage states and this page explains: why nothing has to move, what coordination means when the alternative is centralization, where your business rules actually live, what a planner receives, and why the whole thing improves without another project.

No rip-and-replace

Nothing migrates. Nothing gets replaced.

Read it bottom to top. Your stack stays exactly where it is; everything A2go adds sits above it, and approved decisions come back down into your systems of record.

No migration, no central rewrite First domain live in weeks Start with one decision, expand on your roadmap Add or retire a system without interrupting the agents

What removing ADIP would leave behind

Your source systems, untouched and still transacting. Your data, in the open formats it was already in. The decisions your team made while ADIP was running, recorded in your own systems of record. The exit is real because there is nothing to unwind — no destination to migrate out of, and no process that was rebuilt around the platform.

Coordinated, not centralized

The data travels. The systems don't.

Centralization asks your systems to move into one place. Coordination leaves them where they are and moves only what a decision needs. That distinction sounds architectural, but it is the whole difference between an eighteen-month programme and a first result in weeks.

What actually happens, in order

  • PulledADOE reads from your existing systems where they already sit — multiple ERPs, planning, WMS, OMS, commerce, supplier feeds — through governed interfaces. No extract sits waiting for someone to refresh it.
  • PreppedEntities are reconciled across systems that name the same thing differently, hierarchies are aligned, and time series are put on one clock. Only the fields a given agent needs, in the shape it needs them.
  • UsedThe agents reason over that prepared data together rather than in isolation, so one agent's answer becomes context for the next, and what reaches a planner is one reconciled recommendation.
  • ReturnedThe approved action — and the reasoning behind it — writes back into the systems it came from. That becomes part of the operating record those systems hold, and part of the input for the next decision.

Why the loop matters more than the pull

A one-way integration is a pipe. What makes this a loop is the return leg: the decision goes back to the source, so the next time the same question arises, the systems already reflect what was decided. Nothing has to be reconciled twice, and no separate history builds up inside A2go that your systems don't know about.

This is also what keeps your systems the systems of record. ADIP holds the reasoning; your ERP still holds the order.

The practical test

Ask any vendor what happens to a decision after someone approves it. If the answer is that it lives in their platform and your systems find out later, that is centralization with extra steps.

The ontology

At the centre of ADOE is a model of how your company decides.

Data alone cannot tell an agent what a Tier 1 account is worth protecting, which supplier substitution is permitted, or who is allowed to approve a change that costs money. That lives in the ontology — the governed model at the centre of ADOE that carries your business rules, your guardrails, and your decision responsibilities.

What the ontology holds

  • Business rules. Allocation policy, substitution limits, minimum changeover, safety stock floors, service commitments — the standing logic that constrains every recommendation before a person sees it.
  • Guardrails. The limits an agent cannot act outside of, regardless of what the data suggests. These are set by you, they are explicit, and they are enforced rather than advisory.
  • Decision responsibilities. Who owns which decision, what each role may approve, and where a call must escalate. The ontology knows that a Tier 1 re-promise is not the same authority as a line reschedule.
  • Accountabilities. Which approvals are recorded against which role, so an audit answers not only what was decided but who was entitled to decide it.

Why it sits inside ADOE rather than inside each agent

If every agent carried its own copy of your rules, changing a policy would mean changing it in thirty places, and two agents could reason from different versions of the same rule. Holding it once, at the data layer, means every agent above draws on the same governed model — and a policy change takes effect everywhere at once.

It is also what makes a recommendation explainable. When an agent reports that an option was ruled out, it can name the rule that ruled it out and where that rule came from. An auditor can follow the same trail.

Where the rules come from

Some are already structured in your systems and are read directly. Others live in an SOP or in a planner's head, and get captured and validated with you during discovery. ADIP does not read legal contracts and turn them into executable rules — where a term is contract-specific, the authoritative source stays your own contract or the system that already extracts it.

The decision recommendation package

What a planner actually receives.

Not an alert and not a dashboard. A defined artifact with required fields, assembled once, carrying its own reasoning — which is what makes it both actionable and auditable.

  • Recommended actionThe specific call, stated so it can be executed without interpretation — not a direction, an instruction.
  • TriggerWhat changed, when it arrived, and from which system. Every package traces back to a signal with a timestamp and a source.
  • Alternatives consideredThe other options the agents evaluated and what each one would have cost, so the planner sees the shape of the tradeoff rather than taking the answer on faith.
  • Expected impactThe projected outcome in the metric that matters — service, working capital, avoidable cost — stated before the decision, so it can be measured after.
  • Rules appliedThe business rules and guardrails from the ontology that constrained the reasoning, named individually rather than summarised.
  • Coordinated withWhich other agents and domains contributed, so it is clear the recommendation reconciles across the chain rather than optimising one corner of it.
  • Audit recordWho approved or rejected it, when, under which rule set version, with the full stage trace retained.

Seven required fields · every package carries all of them

Query-ready, through Ask Arti

A package is not a static document. Every line in it can be interrogated in plain language through Ask Arti — where a number came from, which rule permitted an action, what would change the answer, why an alternative was ruled out.

Ask Arti is the user interface to ADIP. It is not the AI engine and it does not make the decisions; the coordinated agents do that, on governed data, under the ontology. Ask Arti is how a person asks the platform to explain itself.

Why the artifact is defined rather than free-form

A recommendation with required fields can be audited, compared against the outcome it projected, and replayed months later against the rule set that was in force at the time. A paragraph of generated text cannot.

It also means the planner's review is the same shape every time. The trigger is always in the same place, the alternatives are always listed, and nothing arrives without the reasoning attached — which is what makes a fast decision a defensible one.

Approval-ready recommendations

What lands on a planner's screen.

All of it — the data, the agents, the judgment — arrives as one artifact a person can act on. Not an alert, and not a dashboard to go interpret. A decision package, with the reasoning attached.

  • Judgment stays human. Full tradeoff visibility and override authority at every step. We remove the friction around the decision, not the decision-maker.
  • Approved actions write back. Straight into ERP, WMS, planning, and execution systems, with a full audit trail attached.
  • Promote what you trust. As projected outcomes prove out cycle after cycle, you choose which calls run without review. You set that line, and you can move it back.
A2go ADIP · Order promising & OTIF 1 decision waiting
01 Jeopardy 02 Explanation 03 Impact 04 Decision 05 Write-back
ORD-4471 Tier 1 1,240 units promised Thu 12 Sep ⚠ In jeopardy
Ontology in play Order identityPromise date Allocation policyCapacity calendar Inventory positionSupplier commit Customer tierService terms
Recommended action

Pull the Thursday run forward to Wednesday second shift, and hold the Tier 1 allocation intact.

A supplier moved a commit at 09:14 against sell-through running 18% above forecast. Four orders lost cover.

4 orders
Promise dates protected
OTIF held
Every Tier 1 commitment
Decision package · DP-4471-06
Triggered by ▸
Supplier commit moved on a bound component at 09:14, against sell-through 18% above forecast. Either alone was absorbable.stage 01–02
Permitted by ▸
Changeover window open Wednesday second shift · 8-hour changeover minimum respected · safety stock floor unchanged.stage 03
Alternatives ▸
Expedite after the outage — misses two promise dates, adds freight. · Partial allocation — leaves three accounts short.stage 04
Expected impact on the order
  • Promise on ORD-4471held at 12 Sep
  • Orders taken off risk4 of 4
  • Days recovered2
  • Expedite freightavoided
  • Tier 1 accounts shortnone
  • Commitments brokennone
Rejecting the recommendation

Nothing is written back until you say why. The reason is what the Judgment Layer learns from.

Reason for rejection
Approved · what moved, and where

    Illustrative configuration · figures anonymised

    Capture · accumulate · apply

    Why it gets better without another project.

    Most software is as good on day one as it will ever be for you. This runs the other way: the layer is fed by the work your team already does, so each turn of the cycle leaves it sharper than the last.

    A four-stage circle labelled capture, accumulate, apply. More usage produces more traces; more traces sharpen the agents; sharper agents produce better decisions; better decisions drive more usage.
    Capture · accumulate · apply

    One turn of the cycle

    Nothing in this loop asks your team to do anything they are not already doing. That is the point — the input is the ordinary work of reviewing and deciding.

    • 01More usageYour planners work the way they already work — reviewing, approving, overriding.
    • 02More tracesEvery one of those calls is captured with its reasoning, including the rejections.
    • 03Sharper agentsThe next recommendation reflects the decisions your company actually made.
    • 04Better decisionsWhich earns more use — and the cycle starts again, one turn further along.

    Specific to you, retained by you. Your Judgment Layer carries your company's own decision logic — the approvals, the rejections, and the reasoning behind them. It is never shared across customers. Without it, AI is just automation; with it, expertise compounds instead of retiring. This is the piece no chatbot or generic assistant delivers.