The holy grail of agentic orchestration
Is an agent that can design itself and its workflow activities, orchestrate the workflow, and respond to change during workflow orchestration.
ZFlow has built its reputation by orchestrating workflows that cut across an organization and the supply chain— across teams, across functions, across enterprise systems. Many leading manufacturing organizations run demanding cross-functional processes on it: complex supply chain processes, new product introduction (NPI), and master data management, among others.
These are long-running processes that weave together cross-functional team decisions, integrations with enterprise systems like ERP, data validation, enrichment, reviews, and approvals. Below is an example of such a process – quote-to-cash.
For many of these types of processes, the standard operating procedure either exists or is designed as part of workflow, and followed reliably during orchestration. And that is what most organizations and teams want – to reliably follow a plan that is designed as workflow. The immediate wins when companies orchestrate these types of processes using a solution like ZFlow are reduction in cycle time, elimination of non-value added work and errors.
Predefined Agentic Orchestration
Agentic orchestration, as promoted by the major ERP and CRM vendors, takes predefined workflows and introduces agents as performers, most commonly in customer service, purchasing and sales. The agent handles a step or two, picking from a menu of pre-built topics and actions, while the workflow itself follows a plan designed in advance. It’s a real improvement, but a bounded one.
And the early results are disappointing. Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027, citing unclear business value, inadequate risk controls, and unpredictable costs. MIT’s NANDA study found only 5% of enterprise GenAI pilots delivering measurable P&L impact. Our read on why: there’s a structural mismatch between a probabilistic agent and the rigid, pre-drawn space it’s forced to operate in, and difficulty of designing harnesses and context that the agent can use to perform reliably.
Everybody has a plan until they get punched in the face
Aside from being a world champion, Mike Tyson is also credited with the famous line: “Everybody has a plan until they get punched in the face.”
The 2020s have been one punch after another — pandemics, wars, unexpected tariffs, shortages, inflation. Teams, organizations, and entire supply chains are constantly thrown into situations where no standard operating procedure exists: supply chain disruptions, first-of-their-kind product introductions, unique suppliers, one-off orders, tariff turbulence, sudden shortages.
These unpredictable scenarios are where the effort, the risk, and the cost concentrate — and by definition, they’re the workflows you can’t design in advance. They’re also where advanced agents and models can deliver the greatest value: synthesizing solutions across a multi-dimensional space that traditional approaches can’t easily navigate.
Autonomous agentic orchestration: Freedom inside a boundary
So here’s what we propose: a different approach for dynamic scenarios. Autonomous agent orchestration inside a boundary. Instead of handing the agent a predefined flow to follow, you hand it a goal and a bounded space to operate in, and let it design and drive the process at runtime, one real activity at a time.
The boundary is what makes this safe to use in controlled and regulated environments. It’s made of four things:
- A goal. What “done” looks like. The outcome the agent is working toward, in the context of the specific case in front of it.
- Tools. The systems and actions the agent is allowed to use: ERP calls, data lookups, document analysis, designing its own sub agents, and creating human data preparation, review and approval activities. It can use what’s in the toolbox and nothing else.
- A harness. The execution scaffolding that turns each of the agent’s decisions into a real governed workflow activity, running it on your engine, routing human steps to the right inbox, capturing the audit trail.
- A budget. Hard limits on cost, compute, and number of steps. An agent designing a process is more expensive than a precompiled flow, so the budget keeps it scoped and keeps the economics honest.
Inside that boundary, autonomous orchestration runs in one of two modes:
- Plan and review (suggested). The agent first proposes a plan, the sequence of activities it intends to run. A human reviews it, edits it in plain language, and approves. Best when an owner wants to set direction before any work begins.
- Emergent. The agent starts immediately and designs the process as it goes. Best when the path is genuinely unknown and there’s nothing to plan against yet.
Here’s the crucial part, the plan is a plan and the agent reserves the right to change the plan when it comes in contact with reality. The agent always retains the flexibility to design its own next best action based on what actually happened and what it just learned. An approved plan is guidance, not a straitjacket.
If that sounds familiar, it should. It’s the OODA loop: Observe, Orient, Decide, Act. The decision cycle that fighter pilots and military strategists use to operate in fast moving, uncertain environments. Observe the result of the last step, orient against the goal and the new information, decide the next move, act, and loop again. That continuous reevaluation is exactly what a rigid predefined workflow can’t do, and exactly what dynamic scenarios demand.
How we implemented autonomous agent orchestration in ZFlow
We didn’t build a new runtime for this. The agent stands on the same battle-tested process orchestration that leading manufacturers already trust for their supply chain, NPI, and master data work — which means it inherits, for free, everything that platform already does well: identity, role-based access, task inboxes, notifications, escalation, SLAs, reporting, and a complete audit trail. The agent doesn’t reimplement orchestration. It writes a real ZFlow workflow forward, one activity at a time.
The process template and its context become the harness. When a process is instantiated in ZFlow, it carries everything the agent needs to orient itself: the goal it’s working toward, the structured and unstructured information attached to the case (records, documents, history), tools it can use, and the limits on cost, compute, and scope. Together these give the agent its harness and its context. It isn’t reasoning in a vacuum; it’s reasoning inside your process, about your data.
The agent determines the next best activity. Given the goal and everything that’s happened so far, it chooses the single next move — and carries it out using ZFlow’s existing activity types, the same building blocks your modeled workflows already use:
- external integration — a call into ERP, PLM, or another system
- RAG over the structured and unstructured information in scope
- bounded scripts for deterministic logic
- an AI agent activity for a reasoning sub-task, or to design a sub-agent of its own
- human activities for data preparation, review, and approval
The agent observes the activity results and what new information it surfaced, and uses that to design and perform the next activity — each one chosen in service of the higher goal set when the process was instantiated. That’s the OODA loop, that the agent is running within the process instance.
What you end up with is a ZFlow process instance: queryable, auditable, with a full activity history and results of each activity the agent and humans performed in the OODA loop.
How autonomous agentic orchestration differs
| Approach | What the agent actually does | Where it belongs |
|---|---|---|
| Classic BPM | Nothing. A developer designs the workflow and the engine runs it | Known, high-volume, and standard workflows |
| Agent SDKs | Your developers code a loop or graph; the agent runs inside it. You build governance, human-in-the-loop, audit, and UI yourself. | The toolkit layer for engineering teams building bespoke tools. |
| Predefined agentic orchestration | Picks from predefined topics and actions inside an agent a human configured. Governed and no-code, but the process is still designed in advance. | Structured service and CRM scenarios with a known action menu. |
| Autonomous agentic orchestration | Designs and drives the process itself at runtime, one real governed activity at a time. What it discovers can be codified into a standard template. | Dynamic scenarios: complex, novel, exception-heavy work no one could model up front. |
A concrete scenario: Quote to Fulfillment
Picture a request that lands on your desk: a customer wants a quote for a 1,000-node Blackwell AI cluster — call it a few hundred million dollars of GPUs, networking, storage, power, and cooling, delivered and stood up on a deadline. There’s no standard operating procedure for this, and there couldn’t be. A deal this size is shaped by a different customer, a different site, a different allocation picture, and a different regulatory footprint every time. It’s the definition of a dynamic scenario.
The deal lead instantiates the process in ZFlow with a goal: produce a complete, governed quote-to-fulfillment package — configuration, phased delivery schedule, pricing, and a risk register — for this customer and this RFQ. They attach the RFQ documents and point the agent at the systems it’s allowed to use. No flow drawn. Just a goal and a boundary.
Then the agent goes to work, one activity at a time.
It reads the situation first. It pulls the customer and the opportunity from CRM and ERP, then runs RAG over the attached RFQ to extract what actually matters: node count and interconnect, the power and cooling envelope at the customer’s site, the delivery window, the destination country.
It checks reality against the goal — and takes a punch. An integration into supply and allocation comes back short: only 600 nodes are allocatable inside the customer’s window; the rest slip a quarter. A predefined quote workflow would either stall here or quote a date it can’t hit. The agent re-orients and redesigns the rest of the process around a phased delivery, adding activities to model two tranches and their schedules.
It fills its own gaps. To validate the configuration it needs the site’s power and liquid-cooling readiness, which lives in no system. So it creates a human data-preparation activity and routes it to the solutions architect’s inbox. The process waits for a real answer rather than guessing.
It stops where it must. The destination triggers an export-control screen, so the agent inserts a mandatory trade-compliance review — and that approval fires regardless of the autonomy setting; the agent cannot route around it. The deal’s size trips the credit threshold, creating a finance approval. The phased terms and a margin exception route to the deal desk for sign-off.
It synthesizes. With the configuration validated, the tranches scheduled, compliance cleared, and approvals in hand, the agent assembles the package: a buildable cluster spec, a two-phase delivery plan with honest dates, pricing with the approved exception, and a risk register flagging the allocation dependency and the cooling-unit lead time — ready to hand to fulfillment.
What comes out is a complete, auditable quote-to-fulfillment record that no one templated: every external call, every human decision, every re-plan captured in one ZFlow process instance you can open and inspect.
The takeaway
Predefined workflows, with and without AI Agents are the right answer for standard business processes. But the dynamic scenarios, the complex, novel, exception-heavy work where most of your real difficulty lives, have never had a good answer, because there was never a defined process to draw in the first place.
Autonomous agentic orchestration is a promising answer: let the agent design and drive the process at runtime, inside a boundary it can’t leave, with your people at every important checkpoint.
That’s the holy grail we set out to describe: an agent that designs its own workflow, orchestrates it, and adapts as reality changes.