julep-ai/julep

Julep — durable, composable AI agents. Flows that crash and resume, retry safely, and explain every step.

What it solves

Julep addresses the fragility of AI agents built with ad-hoc loops, which often crash or fail silently. It provides a framework for creating durable, composable AI agents that can crash and resume, retry operations safely, and provide a clear explanation of every step taken during execution.

How it works

Instead of simple loops, Julep treats agent logic as composable dataflows. Developers define these using a @flow decorator in Python, which compiles the logic into a frozen wire-format intermediate representation (IR). This allows the system to track state and progress.

Key components include:

  • Reasoners: Defined LLM configurations (model, system prompt, output schema).
  • Tools and Pures: Registered functions that the agent can call, with "pures" being deterministic logic.
  • Durable Execution: Optional integration with Temporal or DBOS allows flows to persist their state, enabling them to resume from where they left off after a failure.
  • MCP Integration: Support for the Model Context Protocol (MCP) for standardized tool interaction and safety checks.
  • Control Plane: A CLI and server for managing, deploying, and tracing agents across different environments.

Who it’s for

It is designed for developers building production-grade AI agents who require reliability, strict tool access control, and the ability to audit or trace complex multi-step agentic workflows.

Highlights

  • Durable State: Flows can crash and resume without losing progress.
  • Safe Retries: Built-in support for retries and timeouts on tool calls.
  • Strict Tooling: Agents are denied any tool they were not explicitly allowed to call via a frozen surface.
  • Developer Tooling: A terminal-native CLI for listing, running, linting, testing, and deploying agents.
  • Deployment Pipeline: Support for immutable S3-artifact releases and Kubernetes-based reconciliation via Helm.

Related

  • Project
    dapr/dapr-agents

    Dapr Agents is a Python SDK built on the Dapr runtime that lets developers create scalable, fault‑tolerant AI agents. It provides durable workflows, actor‑based execution, built‑in data source bindings, multi‑agent communication, and automatic tool discovery, all with Kubernetes‑native deployment and strong security.

  • Project
    agentspan-ai/agentspan

    A durable runtime for AI agents that prevents execution loss during process crashes and supports long-running, event-driven workflows with human-in-the-loop approvals.

  • Project
    conductor-oss/conductor

    An open-source durable execution platform for microservices and AI agents that turns complex workflow graphs into persisted, inspectable, and recoverable executions.

  • Project
    AgentEra/Agently

    An AI application runtime framework that provides structured outputs, observable actions, and signal-driven workflows to build reliable, production-ready AI service backends.

  • Project
    Agent-Field/agentfield

    An open-source control plane that turns AI agent logic into production-ready REST APIs with built-in scaling, observability, and cryptographic identity.