Agentic Process Orchestration
The vision
Section titled “The vision”Orvanta is evolving beyond script and workflow execution toward agentic process orchestration — where autonomous AI agents, robotic process automation (RPA), and human workflows are coordinated across diverse, multi-language technical environments.
The shift is from “run this script” to “achieve this goal”: agents that interpret context, select tools, adapt to changing conditions in real time, and collaborate with each other and with humans — across legacy and modern platforms alike.
Core building blocks
Section titled “Core building blocks”Orchestrator (the conductor)
Section titled “Orchestrator (the conductor)”The orchestrator is the decision-maker. It decomposes complex goals into a task graph — with dependencies, constraints, and success criteria — and assigns sub-tasks to specialised agents. In Orvanta, the workflow engine serves as the orchestrator layer.
See Workflows and Multi-agent Patterns.
Specialised agents
Section titled “Specialised agents”Agents are software entities designed for specific roles:
| Agent type | Role |
|---|---|
| RAG agent | Retrieval-augmented data lookup and synthesis |
| Reasoning agent | Decision-making, planning, goal decomposition |
| Tool-using agent | API calls, database queries, external integrations |
| RPA agent | Legacy UI automation and process mirroring |
Polyglot runtime engine
Section titled “Polyglot runtime engine”Orvanta’s runtime runs agents written in different languages — Python, Node.js, Go — within the same workflow. Agents coexist in a containerised (Kubernetes) environment, communicate via APIs, and share stateful workflow context.
This is not lowest-common-denominator: the right language is used for the right task. Python for AI-heavy processing, Node.js or Go for API interactions and low-latency tasks.
Model Context Protocol (MCP)
Section titled “Model Context Protocol (MCP)”Orvanta is aligning with MCP — a standardised, open protocol that lets agents interact with external tools (GitHub, databases, Slack, internal systems) regardless of the agent’s implementation language. This is the integration layer that makes polyglot orchestration practical at scale.
How orchestration works
Section titled “How orchestration works”1. Deconstruction & planning
Section titled “1. Deconstruction & planning”The orchestrator receives an open-ended goal and produces a task graph: a directed set of sub-tasks with dependencies, constraints, and success criteria. Agents are assigned to tasks based on capability.
2. Autonomous tool calling
Section titled “2. Autonomous tool calling”Agents access external systems — APIs, databases, legacy platforms — dynamically via tool calling. Orvanta provides a tool registry that agents discover at runtime; no hardcoded integration contracts.
3. State management & persistence
Section titled “3. State management & persistence”Agentic workflows are long-running. Orvanta maintains durable run state so workflows survive agent failures, restarts, and human-in-the-loop pauses. State is shared across agents via the run context — an auditable key-value store.
For complex long-running orchestration, Orvanta’s roadmap includes native integration with durable execution engines (inspired by Temporal.io patterns).
4. Self-correction
Section titled “4. Self-correction”Agents use feedback loops to correct errors: analysing failed tool outputs, retrying with adjusted parameters, or escalating to the orchestrator when recovery is not possible autonomously.
Architecture: distributed & polyglot
Section titled “Architecture: distributed & polyglot”Asynchronous task queues
Section titled “Asynchronous task queues”Orvanta uses message-passing for asynchronous agent coordination. Internal routing is handled by the workflow engine; external queuing (NATS, Celery-compatible patterns) is on the roadmap for high-throughput enterprise deployments.
Cross-language interoperability
Section titled “Cross-language interoperability”The polyglot runtime means:
- Python agents for AI/ML inference and data processing
- Node.js agents for API orchestration and real-time interactions
- Go agents for high-throughput, low-latency system tasks
All agents within a workflow share state and can hand off results to each other seamlessly.
Self-healing infrastructure
Section titled “Self-healing infrastructure”Planned: agents that monitor their own performance metrics and trigger workflow-level self-healing — rerouting tasks, scaling agent pools, or flagging bottlenecks for human review.
Enterprise benefits
Section titled “Enterprise benefits”| Benefit | How Orvanta delivers it |
|---|---|
| Scale complexity | Break massive goals into managed sub-tasks handled by specialised agents |
| Human-in-the-loop | ConsentGate — approve critical actions before execution |
| Fault tolerance | Durable run state; agent failures don’t terminate workflows |
| Cost efficiency | Dynamic tool usage reduces reliance on expensive large-model calls |
| Auditability | Every agent action, tool call, and state change is logged in the run trace |
Frameworks & ecosystem context
Section titled “Frameworks & ecosystem context”Orvanta is designed to integrate with — and in some cases replace — existing tooling:
| Tool / Framework | Relation to Orvanta |
|---|---|
| LangGraph | Stateful agent workflow patterns; Orvanta provides the runtime |
| AutoGen | Multi-agent conversation; Orvanta adds polyglot execution + HITL |
| CrewAI | Role-based agent teams; compatible orchestration target |
| UiPath / Camunda | Enterprise RPA + BPM; Orvanta can orchestrate alongside or replace |
| MCP | Core protocol for tool connectivity across agents |
Roadmap status
Section titled “Roadmap status”| Capability | Status |
|---|---|
| Workflow orchestration (single-language) | ✅ Available |
| Multi-agent fan-out & sequential handoff | ✅ Available (early access) |
| ConsentGate (human-in-the-loop) | ✅ Available |
| Polyglot runtime (Python + Node.js) | ✅ Available |
| MCP tool integration | 🔄 In progress |
| Durable long-running agent workflows | 🗓 Planned |
| Self-healing infrastructure | 🗓 Planned |
| RPA agent support | 🗓 Planned |
| Agent pool scheduling | 🗓 Planned |
| Asynchronous message bus | 🗓 Planned |
Related
Section titled “Related”- Multi-agent Patterns — Orchestration patterns available today.
- ConsentGate — Human approval for agent actions.
- Workflows — How goals map to workflow graphs.
- Runs — Inspecting and debugging agent run traces.