Orkes Conductor

One Platform.
Agents and Workflows.

Your business processes need to span agents and deterministic workflows. Build and scale durably across both.

Start for free
50,000+
Orkes Developers
1,200+
Companies using Conductor
32,000+
Github stars

Everything you need to run Agents and Workflows in Production

Deterministic

Native Platform for Humans, AI, and Services

Real business processes don’t live entirely inside an agent. They span people, AI, and microservices. Orkes Conductor brings them together on a single platform where workflows and agents are first-class citizens that work seamlessly together.

Explainability

Bring Determinism to Your Agents

Agents are inherently probabilistic but business processes cannot be. Orkes combines AI reasoning with deterministic workflows and helps harden repeated agent behaviors into predictable execution paths over time, making agents more trustworthy, efficient, and production-ready.

Durability

Agentic Workflows That Never Fail in Production

Production processes can’t start over because a worker crashed or an approval took three days. Every workflow and agent execution runs durably, preserving state across failures, restarts, outages, and long-running interactions.

Explainability

Explainability Beyond Observability

Tracing shows what happened. Explainability reveals why. Orkes lets you inspect agent decisions, data, and tool usage to quickly understand failures and improve outcomes. Every step, payload, and decision is captured—view it in the dashboard, ask the Orkes Assistant for an explanation, or export it to your auditing systems.

Build using Coding agents, SDK, or UI. Visualize It in Action.

Build using your preferred coding agent, frameworks, and development practices. Then watch workflows, agents, approvals, and tasks come to life through an end-to-end operational view of every execution.

Live Orkes workflow view — assistant, LLM call, and HTTP tool tasks with success badges

import os
import time

from conductor.ai.agents import Agent, AgentRuntime, resume, tool
from conductor.client.configuration.configuration import Configuration

SERVER_URL = os.environ.get("CONDUCTOR_SERVER_URL", "http://localhost:8080/api")
LLM_MODEL = os.environ.get("CONDUCTOR_AGENT_LLM_MODEL", "openai/gpt-4o-mini")


@tool(approval_required=True)
def deploy_to_production(service: str, version: str) -> dict:
    """Deploy a service to the production environment. Requires human approval."""
    # Stand in for your real rollout, e.g. pipeline.rollout(service, version)
    return {"service": service, "version": version, "status": "rolled out"}


agent = Agent(
    name="production_deploy_agent",
    model=LLM_MODEL,
    tools=[deploy_to_production],
    instructions=(
        "You roll out production changes. "
        "When asked to deploy, call deploy_to_production "
        "with the service name and version."
    ),
)


if __name__ == "__main__":
    config = Configuration(server_api_url=SERVER_URL)

    with AgentRuntime(config) as runtime:
        runtime.deploy(agent)
        handle = runtime.start(agent, "Deploy 'payments-api' v2.4.1 to production now.")
        execution_id = handle.execution_id
        print(f"started: {execution_id}")

    ## …weeks later, from anywhere

    with AgentRuntime(config) as runtime:
        handle = resume(execution_id, agent, runtime=runtime)

        while not handle.get_status().is_waiting:
            time.sleep(1)

        call = handle.get_status().pending_tool["toolCalls"][0]
        print(f"awaiting approval: {call['name']}({call['args']})")

        handle.approve()
        handle.join().print_result()

Enterprise-Grade, Open Source, and Battle-Tested

Governance, open foundations, and production maturity — on one platform.

Governance Built for the Enterprise

As AI becomes part of business-critical processes, governance can’t be an afterthought. Manage access, approvals, audit trails, secrets, compliance controls, and operational policies across workflows and agents from one platform.

Open Source at the Core

Built on the foundation of Conductor and Conductor SDK, Orkes combines the flexibility and transparency of open source with the security, governance, and operational capabilities required by modern enterprises.

Battle Tested in Production

Originally built and open sourced by Netflix. Organizations trust Conductor to orchestrate their mission critical business processes. The same reliability, scalability, and operational maturity now power both Agents and Workflows on a single platform.

The future runs on agents and workflows. Build with Orkes.

What our customers say

"Orkes has been instrumental in increasing developer agility, creating cost efficiencies, and building highly reliable and secure applications. We’re so impressed with the results that we are migrating more workflows from other platforms to Orkes and initiating all flows on Orkes."

Thisara Alawala,
Thisara Alawala,
Lead Architect, Foxtel

"We didn’t want data management; we wanted a powerful microservice orchestration engine. After a careful analysis, Normalyze chose Conductor delivered by Orkes Cloud."

Ravi Ithal,
Ravi Ithal,
Founder & CTO, Normalyze

"I can’t stress enough how much Orkes Cloud has helped us over the past year to get our microservices efforts off the ground and accelerate this process. And our development teams love Orkes because they can quickly make the microservices they need. Our development teams can automate anything they want. It’s very empowering,"

Andy French,
Andy French,
AVP of Platform Automation, United Wholesale Mortgage

"One of the things that really attracted me to Orkes Conductor is that the infrastructure is already in place. As a CTO, I want my team to build very specific tasks and applications rather than spend the time building infrastructure, which Orkes Conductor allows them to do."

Andres Garcia,
Andres Garcia,
CTO, Florence Healthcare

Ready to Build Something Amazing?

Join thousands of developers building the future with Orkes.