Single-process execution
Run the API and execution engine in a compact, single-process setup. Use the same workflow definitions and tool contracts as your deployment grows into separate owner and worker processes.
Durable Execution for AI Agents
Pyrodit Agentic Runtime
Durable Agentic Orchestrator · Discuss your deployment
Durable execution for AI agents: preserve progress through interruptions, wait for human decisions and coordinate long-running work across your systems.
Product interface · Sample workspace · English UI
From the flow to the work behind it.
Design the workflow, then inspect coordination, execution activity and model usage in the same workspace.
Make the workflow visible
The procurement example connects structured input to two quote calculations. The node library and runtime inspector sit beside the canvas, keeping the flow and its controls together.
A view of the work in motion
The overview brings workflow activity, model spend and the admission, run-owner, queue and execution layers into one view. The figures shown belong to this sample workspace.
Is this the right product?
- Built for
- Platform teams building custom agentic applications and business processes.
- What it helps you do
- Coordinate models, tools and people in workflows that keep state and can resume after interruption.
- Its role in your stack
- An execution foundation for custom systems. Choose Essentials for a focused AI workspace; add Scan Lab and Guard for assessment and runtime protection.
Scope & availability
Configure durable execution, human approvals, scheduled waits and MCP/A2A connections within your organisation’s data and permission boundaries. Deployment, models and integrations are matched to the process you operate.
- Starts with
- Typed flow definitions, agent configuration, approved tools and events.
- Produces
- Persisted run state, a structured result and a record of steps, decisions and permitted actions.
- Deployment
- Single-process or distributed deployment with API, Run Owner and Task Workers, sized for your workload and continuity requirements.
Follow the work
Keep a long-running process understandable.
An assistant prepares a recommendation, waits for a reviewer and continues with a permitted action. The workflow keeps an inspectable record between those steps.
Illustrative workflow · not a live result
Compose the flow
Define typed nodes for preparation, model work, review and the downstream tool. Give each step its inputs, timeout and failure path so orchestration is explicit.
Example output
- Flow definition
- Prepare context → produce a recommendation → await review → call the permitted tool.
Pyrodit Agentic Runtime gives AI agents a persistent execution foundation. Workflow state, recorded results and decision history stay with the run as work moves between models, tools and people. Define recovery, waiting and action permissions as part of the process.
01
Resume from persisted progress
Store workflow state and checkpoints beyond the life of a request or worker. Recover interrupted runs from recorded progress, with explicit retry and continuation rules for the work that remains.
02
Agents working toward one decision
Bring finance, operations or other specialist roles into bounded review rounds. Check recommendations against explicit budget, deadline and eligibility rules before presenting a result.
03
Control actions and repeat calls
Separate a recommendation from permission to act. Apply tool policies, use invocation identities and reuse recorded results when idempotency is enabled. Define retry and reconciliation rules for each external integration.
04
A record behind every outcome
Follow steps, attempts, agent review rounds and state changes in the same run. Give operators the context to explain a recommendation, investigate a failure or decide how to continue.
05
Wait for people and external events
Persist approval and event waits so the workflow can outlive its original request. The waiting step releases its worker; the recorded decision or incoming event determines when the process can continue.
06
Bring the right models and tools
Connect each step to the model, approved knowledge and tools it needs. Keep inputs and outputs structured so the next step can use the result without relying on free-form conversation.
Execution architecture
Start in one process. Distribute the work as needed.
Choose single-process or distributed execution to match your workload. The API handles application requests, the Run Owner coordinates each workflow and workers carry out its steps.
Distributed execution with clear ownership
The Run Owner coordinates each workflow while Task Workers execute its steps. Persisted state and time-limited ownership support recovery and takeover. In distributed execution, completing a task and scheduling the next ready work share the same state transition.
A request can finish before the work does
When the configured response wait expires, the API returns HTTP 202 and the workflow continues in the background. Your application follows the run by its identifier and retrieves the result without keeping the original connection open.
For engineering teams
Build Pyrodit into your own product.
Use the Python Client SDK to connect your application to Pyrodit, the Plugin SDK to add your own tools and the Enterprise SDK to apply organisation-specific controls. Applications in other languages connect through the HTTP API; live events keep your interface informed as work progresses.
Python Client SDK
Start work from your application, follow progress through live events or status checks, and retrieve the result. Bring approval, cancellation and resume actions into your own interface, using the same run identifier throughout.
Workflows as code
Define steps, branches, inputs and outputs with typed workflow contracts. Manage workflow versions through the SDK and deploy the selected version for an environment, organisation or business domain. Inspect registered tools and their schemas before connecting them.
Plugin SDK
Turn your internal APIs and business functions into reusable workflow tools. Define and validate inputs, outputs and configuration; test the tool independently, then package it for an authorised runtime host or serve it through an HTTP adapter.
Enterprise SDK
Add organisation-specific checks before an action, capture results after execution and observe failures. Trusted extensions run inside the runtime host and are explicitly enabled for the deployment; the runtime retains control of permissions, retries and execution.
From your procurement screen to an approved decision.
A buyer starts a supplier review in your application. A tool built with the Plugin SDK reads the permitted supplier data; the runtime coordinates the comparison. The Python client brings progress and the approval step back to the same screen, then retrieves the result for your existing process.
Use cases
Enterprise challenges. Coordinated decisions.
Keep goods moving, production running and banking operations accountable. Explore workflows across business units, systems and approval boundaries.
Balance inventory across stores, warehouses and digital channels.
When campaign demand diverges from stock, evaluate store and online orders in one allocation plan. Balance availability, margin and logistics capacity.
Explore the workflow →Contain supply disruption before it stops production.
Assess a delayed critical component against plants, production schedules and customer commitments. Compare alternative sourcing, inter-site transfers and rescheduling in one decision file.
Explore the workflow →Accelerate financial close with coordinated intercompany reconciliation.
Bring intercompany transactions, deliveries and accounting records across ERPs into one exception queue. Prioritise close blockers by exposure, materiality and accountable team.
Explore the workflow →Coordinate payment incident response around business impact.
Connect a payment-channel disruption to transaction queues, reconciliation and customer commitments. Bring operations, technology and risk into one response plan.
Explore the workflow →In practice
What happens in day-to-day use?
Explore the working steps, operational controls and evaluation boundaries behind the product.
How do agents reach a business decision?
Assign specialist roles, define the business constraints and bring their findings together in bounded review rounds. In procurement, finance reviews cost while operations checks delivery dates. The runtime checks the recommendation against these constraints and returns the reasoning with the result. Ordering is a separate, explicitly authorised action.
How do waiting and resuming work?
The workflow records its progress before waiting for a person, an external event or a scheduled time. It releases execution resources during the wait and resumes from the saved state when the condition is met. Operators can see what is being awaited, its expiry and the action needed to continue.
How does Pyrodit fit our environment?
Configure deployment, model providers, tool connections and organisational permissions around your process. Define who can approve which actions, how long work may wait and how exceptions reach the responsible team. Follow execution, decisions and results through the API and operational records.
Enterprise orchestration
From approval to outcome, in one continuous workflow.
Bring scheduled waits, verified approvals, connected agents and quality checks into the same execution. Pyrodit preserves the context as work moves between people, models and systems.
Wait without keeping work in memory
A workflow can wait days or weeks for an approval, an external event or a scheduled time. Its state is stored and execution resources are released during the wait; when the condition is met, work resumes from the saved state.
Trusted approvals and organisational boundaries
Approval is tied to a verified person, organisation and specific action. The runtime checks the authoritative approval record, validates inputs and applies sensitive-data controls before execution. A model recommendation alone does not grant permission.
Connect workflows, tools and remote agents
Use MCP and A2A in both directions: expose workflows to other applications and connect external tools or remote agents to your runs. Identity, permissions and interface checks stay at the boundary; delegated work remains linked to its parent run.
Review, improve and ask when needed
Check drafts against quality criteria and return them for revision when needed. Ask structured questions when information is missing, preserve essential context during long tasks and manage model choices centrally for each organisation and agent.
Works alongside
Give each product a clear responsibility.
Combine the capabilities your process needs. Define how products share context, permissions and results across your workflow.
Mission Control
Coordinate work orders, plans and approvals with Mission Control; use Agentic Runtime to carry out the workflow and track its progress.
Pyrodit Guard
Apply Guard policies to model outputs and tool actions. Carry protection decisions and execution records alongside the workflow.
Build with Mindtro