Does Unmeshed work with LangChain or CrewAI?

Yes. Agents built with LangChain, CrewAI, or plain SDK calls run inside Unmeshed workers, using the Python, TypeScript, Java, or Go SDKs. Your framework keeps handling the agent's reasoning and tool wiring, while Unmeshed wraps each step with durable state, automatic retries, and a full audit trail. Prefer to keep it inline? You can run your agent code directly in Unmeshed's built-in Python step node, no separate worker to deploy.

How does human-in-the-loop work?

Add a human task to your workflow wherever a person needs to review or approve something. The run pauses durably, since the engine persists its state, so it can wait minutes or even weeks, and resumes the moment the reviewer acts. Nothing risky ships unattended.

Can we self-host Unmeshed?

Yes. Run Unmeshed fully managed in our cloud, or on-prem in your own infrastructure. Both options use the same engine, SDKs, and observability tooling, and the same deployment scales with you, from a low-volume pilot to high-throughput production, with no re-architecting.

Which languages are supported?

Official SDKs cover Java, Go, Python, and TypeScript. You can also trigger workflows by events and schedules, and since Unmeshed is MCP-native, your agents and tools can speak a standard protocol.

How does pricing work?

There's a free tier to start, no credit card required. Pricing has no per-action fees, so costs stay predictable as your agents scale in production.

AI Agent Orchestration, built for production.

Combine deterministic workflows with agentic steps. Your agents get durable state, automatic retries, human-in-the-loop approvals, and full observability, straight from the creators of Netflix Conductor.

Start Free Contact Us

Free tier · No credit card required

By the team that built Netflix Conductor

agent_flow.py

# agent_flow.py — an AI agent step inside a durable workflow
from unmeshed.sdk.configs.client_config import ClientConfig
from unmeshed.sdk.unmeshed_client import UnmeshedClient
from unmeshed.sdk.apis.workers.worker import Worker
from unmeshed.sdk.common.process_request_data import ProcessRequestData

def fetch_context(input_dict: dict) -> dict:
    # Deterministic step: gather the data your agent reasons over
    return {"account": load_account(input_dict["account_id"])}

client = UnmeshedClient(ClientConfig())
client.register_worker(
    Worker(execution_method=fetch_context, name="fetch-context")
)
client.start()

# The "agent-triage" process chains this worker with an `llm` step
# that drafts a fix from {{fetch-context.output}}, plus a review
# step a human approves before anything ships.
# Failed steps retry per error policy:
#   { "action": "RETRY", "retryCount": 2, "retryInterval": 5000 }
# TODO: confirm SDK method names for programmatic approvals
result = client.run_process_sync(ProcessRequestData(
    name="agent-triage",
    namespace="default",
    input={"account_id": "acct_204"},
))

The Problem

Frameworks get you a demo. Production needs an orchestrator.

State that survives crashes

An agent loop that holds its state in process memory is one OOM kill or redeploy away from losing the run. Unmeshed persists every step instead, so runs resume rather than restart from scratch.

Retries without duct tape

Retry policies are declared per step: count, interval, and backoff, instead of try/except blocks scattered across every LLM and API call.

Every step auditable

When an agent does something surprising, you get the exact inputs, outputs, and retries for every step. No scrolling through stdout to figure out what happened.

Capabilities

Everything your agents need to run in production

Durable agent state

Every run's state is persisted by the engine, so crashes, deploys, and restarts resume exactly where they left off.

Automatic retries

Failed steps retry on policy, with configurable count, interval, and backoff. You don't need to write retry logic into your agent code.

Human-in-the-loop

Pause a run for review and resume on approval, so agents never ship risky actions unattended.

Full observability & audit

Inspect every step's input, output, and retry history. It's a complete audit trail for every agent decision.

MCP-native tools

Unmeshed is MCP-native, so your agents and tools speak a standard protocol out of the box.

Multi-agent coordination

Coordinate many agents in one workflow, with standard cron scheduling down to one-minute intervals and event triggers.

Build and register workers in Java, Go, Python, or TypeScript. Explore the SDKs

How It Fits

Agent frameworks build behavior. Unmeshed runs it.

Agent frameworks (LangChain, CrewAI)

Prompting and reasoning loops
Tool wiring and function calling
Agent behavior and memory patterns
Runs inside a single process

Unmeshed

Durable execution with persisted state
Retries, timeouts, and error policies per step
Human approvals and governance
Observability, audit trail, and ops controls, cloud or on-prem

Use them together. Keep your framework for the agent's reasoning, and call it from a worker. Unmeshed makes each step durable, retried, and audited. See how workflow orchestration works →

Trusted by engineering teams at leading organisations