Julep is a cloud platform for building complex AI agents, providing session management, memory persistence, multi-step task orchestration and MCP tool integration capabilities.

JulepAI

Core parameters and statistics

Parameters	Data
Product positioning	Composable and durable AI agent framework
Core Competencies	@flow arranges Reasoner, Reasoning Tool calls Durable Execution
Programming languages	Python (97.6%), TypeScript client
Open Source License	Apache-2.0
GitHub Stars	6.6k
GitHub Forks	971
Latest version	3.0.0rc3 (2026-07, RC stage)
Persistence backend	Temporal, DBOS/Postgres
Tool integration	MCP Server, native HTTP Tool, custom Python Tool
Core abstraction	@flow, Agent, Reasoner, Tool, Pure, Pipeline
Deployment method	CLI local run / Temporal Worker / Docker
Target users	AI application developers Agent engineers LLMOps team

Julep is not "another Agent framework", but an engineering solution that upgrades AI agent construction from "handwritten while loop + prompt splicing" to "compiled data flow graph". The core difference is that the agent process is compiled into a serializable intermediate representation (IR), which naturally supports crash recovery, step-level retries and complete execution trace tracking.

Unlike LangChain's DAG orchestration or CrewAI's role collaboration, Julep emphasizes "durability" - the agent crashes when running to step N and continues from the breakpoint after restarting instead of starting over. This feature gives it a clear engineering advantage in long-running workflows (e.g. continuous monitoring, batch data processing).

Users and market recognition of Julep AI

Julep is currently in a critical stage of transformation from v1 API platform to v3 open source framework, and market signals are clearly differentiated.

GitHub Community Popularity: The warehouse has received 6.6k Stars and 971 Forks, which is a medium-to-high level of attention in the AI ​​Agent framework category. There are 5 core contributors, and the recent submission activity is relatively high (last submission 2 days ago), but there is still an order of magnitude gap compared to LangChain (~100k Stars) or CrewAI (~30k Stars). The project adopts the Apache-2.0 license, and the threshold for community forking and secondary development is low.

Uncertainty caused by version transition: Julep v3 is a completely rewritten product from v1 (API cloud platform). The official statement clearly states that "there is no migration path - v1 and v3 are different products." This means that all v1 users cannot upgrade smoothly and need to relearn and adapt to the @flow declarative paradigm of v3. This kind of "generational" upgrade is relatively radical in open source projects and may divide the community base.

Enterprise adoption status: Relevant enterprise-level deployment cases and customer lists have not been made public. Judging from GitHub Issues and discussion forums, the project is still dominated by individual developers and early technology verifiers, and there has yet to be a large-scale public production case. Please refer to the official real-time page and community announcements.

The cost advantage of Julep AI

Julep's cost structure is divided into three levels: open source self-hosted v1 platform legacy solution and enterprise support. The explicit and implicit costs of each are significantly different.

C-side/individual developers: The framework itself is completely open source (Apache-2.0), and there is zero cost for local development. Running @flow only requires the basic Python environment and does not rely on external services. In lightweight scenarios (without Temporal), development and testing can even be completed on a single laptop. Hidden costs: Learning curve - v3's @flow declarative programming paradigm and CLI tool chain require hours to days of learning time. For developers who are accustomed to the traditional Agent framework (directly writing while loops without calling LLM), the cost of thinking conversion cannot be ignored.

Developer/API Calls: If using the v1 platform (legacy API), undisclosed pricing is per session and memory storage. The v3 open source version is completely self-hosted, and the only runtime cost is the LLM API call fee (such as OpenAI, Anthropic) and optional Temporal cloud service fee (self-built Temporal Server will increase operation and maintenance costs). Hidden costs: Self-hosting Temporal requires maintaining a distributed workflow engine cluster, which may exceed the boundaries of operation and maintenance capabilities for a small team of 1-2 people; using Temporal Cloud requires paying a SaaS subscription fee.

Enterprise / Private Deployment: Using the v3 open source version + self-hosted Temporal + self-built LLM gateway, there is zero license fee at the software level, but the infrastructure costs (GPU server Temporal cluster, network bandwidth) and operation and maintenance manpower need to be borne by the enterprise. For companies that are already using Temporal, the integration cost of Julep is low; for teams without Temporal infrastructure, additional investment in building and operating Temporal needs to be evaluated. The official real-time page and business quotation shall prevail.

Main features of Julep AI

The functional system of Julep v3 revolves around the core concept of "persistent data flow agent". Instead of providing a preset Agent template, it provides a set of underlying primitives for developers to build their own agent logic.

• @flow declarative orchestration: Use Python decorators to transform ordinary functions into persistent and recoverable data flow graphs. @flow compiles to IR when defined, | operators merge records, h["key"] extracts fields, think() calls Reasoner, cond()/switch() implements conditional branching, each() implements parallel fan-out. The runtime is executed by the IR interpreter and naturally supports breakpoint resumption. Applicable tasks: Complex agent processes that require multiple steps, have branches, and may interrupt recovery.

• Reasoner: Abstracts LLM calls into reasoning nodes with typed output. The developer specifies the model and output type (TypedDict), and Reasoner automatically handles prompt assembly, structured output parsing, and retries. Compared to calling the LLM API directly, type constraints allow the compiler to detect output field mismatches at definition stage rather than crashing at runtime.

• Tool system and MCP integration: Register Python functions as proxy tools through the @tool decorator, support effect="read/write" and idempotent=True annotations, and the framework will automatically generate a permission list accordingly. Compatible with MCP protocol, any MCP Server can be mounted as a tool source. [Expert View]: The double annotation of effect + idempotent not only declares "what can be done", but also declares "can it be redone if it is done", which provides a safety boundary for the automatic retry of Durable Execution.

• Durable Execution: Integrate Temporal (or DBOS) to achieve persistence of agent workflow. If any step of the process crashes, the Worker will automatically resume from the breakpoint after restarting. Engineering meaning: Improve agent reliability from "best effort" to "exactly once execution" level, suitable for production scenarios such as payment review and data migration that require execution guarantees.

• CLI tool chain: Provides life cycle management commands such as agent discovery (ls), display (show), dependency graph analysis (graph), local execution (run), static verification (lint), testing (test), trace playback (trace), preflight (doctor), and deployment (deploy). Selector syntax (tag:support, +agent graph traversal) supports cross-agent batch operations.

• Pipeline application model: Application + PipelineSpec combination, supports bounded isolation (staging/production), MCP snapshot management Capability Manifest statement and capability verification. Suitable for production scenarios with multiple contexts and grayscale release.

Comparison with mainstream Agent frameworks:

Dimensions	Julep AI (v3)	LangChain	CrewAI	AutoGen
Orchestration paradigm	@flow declarative IR compilation	DAG chain call	Role + task declarative	Conversational multi-Agent
Persistent execution	Native support (Temporal/DBOS)	No built-in, need to be integrated by yourself	No built-in	No built-in
Tool permission model	effect + idempotent declarative	No built-in permission model	No built-in permission model	Partially supported
MCP support	Native support	Support through integration layer	None	None
CLI Toolchain	Complete Lifecycle Management	Basic Command Line	Limited	Limited
Learning curve	Medium-high (needs to understand the @flow paradigm)	Low (chain calls are intuitive)	Low (role declaration is intuitive)	Medium (dialog design is complex)
Production Readiness	RC Stage	Mature	Moderate	Moderate

Julep AI model and version evolution

Julep's version history has undergone a fundamental transformation from an API cloud platform to an open source framework between 2025 and 2026, with the version number jumping directly from v1 to v3.

v1 era (2025-2026): API cloud platform

• Julep v1 Alpha (~2025-10): Hosted AI Agent API platform, providing session management, memory persistence and task orchestration, with RESTful API + WebSocket access.
• Julep v1 Beta (~2026-04): Adds multi-step task orchestration and MCP tool integration, but API stability and documentation coverage limit mass adoption.

v3 era (2026-07 to present): open source @flow framework

• Julep 3.0.0rc1 (early 2026-07): Completely rewritten, building an open source framework with the Python @flow decorator as the core, introducing primitives such as Reasoner, Tool, Pure and serializable IR compilation model.
• Julep 3.0.0rc2 (mid-2026-07): Optimize @flow compilation performance, add cond()/switch() conditional branches, and improve the debugging experience.
• Julep 3.0.0rc3 (around 2026-07-15): Introduces the Application + PipelineSpec production deployment model, adds MCP Snapshot management Capability Manifest and Temporal complete integration.

Release Notes

Julep's version naming adopts semantic versioning (SemVer) but has the feature of "dating" - v3 and v1 are completely architecturally incompatible. The current 3.0.0 series is still in the RC stage, and backward-incompatible changes to the API and IR format may occur. Before the official 3.0.0 stable version is released, it is not recommended to put the current RC version into production environments with extremely high stability requirements.

Julep AI’s technical advantages

Julep's technical design revolves around the goal of "making AI agents as reliable as traditional software." Its core innovation lies not in the LLM capability itself, but in transforming agent behavior from "uncontrollable text generation" to "predictable, recoverable, and auditable data flow graphs."

Compiled @flow instead of interpreted chained calls: Most Agent frameworks interpret execution step by step at runtime, and the same input may lead to completely different execution paths due to small differences in LLM output. Julep's @flow is compiled into an IR once when it is defined, and the entire execution graph is fully determined before running. Developers can statically analyze all possible paths of the agent during the definition phase. Compile-time verification can also detect issues such as tool parameter type mismatch and missing output fields in advance, moving errors from runtime to the development phase.

Natural affinity between IR serialization and Durable Execution: The IR generated by @flow compilation is a serializable pure data structure that can be persisted to the Temporal event store. When the process crashes and restarts, Temporal replays the IR and its execution progress from the event store, restoring exactly to the breakpoint position. The agent's "state" is no longer an implicit context in the LLM conversation history, but a deterministic progress marker stored explicitly in the IR execution trace.

Security model of tool permissions: Through the double declaration of @tool(effect="read", idempotent=True), Julep establishes the security boundary of tool calls at compile time. The framework automatically generates a Capability Manifest based on the declaration, and at runtime LLM can only call tools that match the Manifest. Compared with LangChain's "tool as function list" model, Julep provides compile-time guarantees rather than run-time monitoring, reducing the risk of prompt injection leading to tool abuse.

Deep integration with Temporal: Each step of @flow is mapped to a Temporal Activity, and scheduling, retries, timeouts, and recovery are all managed by Temporal. Developers only need to declare retries=2, timeout_s=5 without writing persistence code. DBOS (Postgres native) serves as a lightweight alternative backend, suitable for scenarios that do not require a Temporal cluster.

Guide to engineering pitfalls:

1. Dead-end loops and Token inflation control: When using think() to call Reasoner in @flow, if the prompt design is improper and the model is constantly replanned, there may be a scenario where the number of reasoning steps increases infinitely. Solution: Set the max_steps global step limit (configured in PipelineSpec), or set a timeout for each Reasoner call through the timeout_s parameter. For processes suspected of looping, first use julep run --dry-run to observe the execution path and then run it officially.

2. Context overloading of MCP tools: After mounting the MCP Server, the data returned by the tool is directly injected into the LLM context. If a tool returns very long results (such as a database full table scan), it is easy to burst the context window. Solution: Cut the data inside the tool function (return only summary or paging results), or use the timeout_s and retries parameters of @tool to control the tool execution boundaries. For tools known to return large amounts of data, it is recommended to add the max_results parameter to the tool function.

3. Security and unauthorized governance: If the effect="write" tool lacks input validation, the model may generate dangerous parameters (such as DELETE FROM users) through prompt injection. Solution: Perform parameter whitelist verification inside the tool function, and force manual confirmation points for irreversible operations (deletion, payment, release). You can declare the allowed operation range through capabilities=CapabilityManifest.from_file(...) of PipelineSpec to prevent the registration of unauthorized tools at compile time. In the production environment, it is recommended to enable dry-run mode for all tools with effect="write", and only switch to actual execution after manual confirmation.

How to use Julep AI

The access path of Julep v3 is divided into three levels: local development CLI management and production deployment, which are respectively oriented to different usage stages.

Installation and Quick Start: The current Julep 3 is still an RC version, and the --pre flag is required when installing.

pip install --pre julep

The base installation only contains the author tools and IR compiler (depends on PyYAML). Select extras as needed to extend runtime capabilities:

pip install --pre "julep[temporal]" # Temporal persistence execution
pip install --pre "julep[dbos]" # DBOS/Postgres persistence
pip install --pre "julep[http]" # Native HTTP tool call
pip install --pre "julep[langfuse]" # Langfuse observability export
pip install --pre "julep[store]" # S3 product distribution and signing
pip install --pre "julep[wasm]" # Wasm sandbox execution Pure

3 Minutes to Get Started: Here is a complete example of a ticket triage agent that can be run without an API Key (using a local fake Reasoner).

from typing import TypedDict
from julep import Reasoner, deploy, flow, pure, think, tool

class SupportReply(TypedDict):
    reply: str

@tool(effect="read", idempotent=True)
def lookup_ticket(ticket: str) -> dict[str, str]:
    return {"ticket": ticket, "queue": "billing", "summary": "Use the duplicate-charge runbook."}

@pure("ticket_prompt")
def ticket_prompt(hit: dict[str, str]) -> dict[str, str]:
    return {"queue": hit["queue"], "context": hit["summary"]}

support_reply = Reasoner(
    name="support_reply",
    model="anthropic:claude-haiku-4-5-20251001",
    system="Draft one concise support reply as JSON.",
    reply=SupportReply,
)

@flow
def triage(ticket: str) -> dict[str, str]:
    hit = lookup_ticket(ticket, retries=2, timeout_s=5)
    prompt = ticket_prompt(hit)
    answer = think(support_reply, prompt, timeout_s=10)
    return hit | answer

deployment = deploy(triage, tools=[lookup_ticket], reasoners=[support_reply])
result = deployment.dry_run("Customer was charged twice.",
    reasoners={"support_reply": lambda v: {"reply": f"{v['queue']}: {v['context']}"}})
print(result.value)

CLI workflow: After installation, manage the Agent module through the julep command:

julep ls # List all Agents
julep show triage # View single Agent details
julep graph # Display inter-Agent dependency DAG
julep run triage --input '"TICKET-42"' # Local execution and streaming output trace
julep lint +triage # Static verification of Agent and its dependencies
julep test triage # Run pytest test
julep trace <run-id> # Play back the cached execution trace
julep doctor # Pre-check Youjing (Git, Langfuse, Temporal)
julep deploy triage --env staging # Solidify→Publish→Record to deployment book

Production deployment: For formal production scenarios, use Application + PipelineSpec to declare deployment configuration, and manage multi-boundary releases through julep plan/apply/status. The Application model supports contextual variable injection, MCP snapshot management, capability inventory verification, and Helm release orchestration. For configuration examples, see the official documentation and the examples/ directory.

Product Pricing for Julep AI

Julep's pricing system presents a "coexistence of old and new" pattern due to historical faults in product form. Currently, two pricing lines should be distinguished: v1 legacy platform and v3 open source framework.

v1 Platform (Legacy API): In Beta stage, free trial credit available. The official pricing has not been disclosed, but it is expected to be billed based on the number of sessions, memory storage and API calls. The Developer Edition and Small Team Edition may adopt a fixed monthly fee + excess pay-as-you-go model. Enterprise version (private deployment, customized memory storage strategy) requires contacting sales. Note: v1 is no longer actively developed, new projects should adopt the v3 open source version directly.

v3 Open Source Framework: completely free (Apache-2.0 license), no usage restrictions. Developers only need to bear the following external costs:

• LLM API fee: Billed according to the actual model called (such as OpenAI, Anthropic), regardless of the Julep framework.
• Temporal Fee: Optional. Self-hosted Temporal Server is free but requires investment in operation and maintenance; Temporal Cloud is billed based on the length and number of workflow executions (refer to Temporal official pricing, about $0.01-0.10/thousand workflow executions).
• Infrastructure Charge: Production deployments require GPU/CPU server, storage, and network resources depending on concurrency and data size.

Enterprise Support: Optional enterprise technical support contract costs are undisclosed, please contact the Julep team for a quote. Enterprise editions may include priority technical support, custom feature development, and deployment architecture consulting. The official real-time page and business quotation shall prevail.

Julep AI application scenarios

Julep's Durable Execution and compiled @flow design give it clear advantages in agent scenarios that require execution guarantees, auditability, and long running times, as opposed to general-purpose conversational AI.

• Production-level work order processing: Customer service work orders often require multiple rounds of human-computer interaction, cross-system query and approval processes from creation to closure. Julep's @flow can model work order processing as a determined sequence of steps. Each step calls different tools (CRM query, knowledge base search, work order system writing), and automatically recovers from the breakpoint after the process crashes. Compared with the traditional solution: The agent process without persistence must restart from step 1 after the crash in step 3; Julep can continue from step 4, which directly translates into SLA improvement in scenarios with large volume of work orders and high system stability requirements.

• Automated data pipeline and audit: Execution monitoring and exception handling of data migration ETL pipeline are typical long-running tasks. Julep's Durable Execution can ensure that the pipeline automatically retries and resumes progress after encountering exceptions such as API current limiting and database connection interruption. The distinction between effect="read" and effect="write" allows the review process to be clearly divided into two stages: "read-only inspection" and "actual change", without any side effects before approval.

• Compliance and Approval Workflow: Business processes that require multiple people to confirm, such as contract review and permission approval, are naturally suitable for Julep's @flow orchestration - each approval node is mapped to a think() call, and the approver's decision is used as a process branch condition. The complete persistence of execution traces provides a non-repudiable evidence chain for auditing. Implementation Tips: In compliance scenarios, it is recommended to set up external confirmation points (manual confirmation through message queues or Webhooks) at key approval nodes, rather than relying entirely on LLM judgment.

• Long-running research and report generation: The agent retrieves information in multiple steps, cross-validates, and iteratively optimizes reports based on user needs. This type of scenario is characterized by long execution time (several hours), many intermediate results, and high fault tolerance requirements. Julep's crash recovery capabilities ensure that research progress is not lost even if workers are restarted. Unsuitable Boundary: For scenarios with high real-time requirements (such as real-time chatbots, streaming Q&A), Julep's compiled @flow startup overhead is greater than direct LLM calls, and is not suitable for interactive scenarios with millisecond response.

Applicable groups of Julep AI

The positioning of Julep v3 determines that it is not aimed at all AI application developers, but focuses on engineering teams that have rigid requirements for "reliability" and "recoverability."

• AI backend engineers and LLMOps team: core target users. They have the ability to manage Temporal infrastructure, understand the value of Durable Execution, and are looking for a more engineering approach to building Agents than handwritten state machines. Not suitable for boundaries: If the team has no experience in distributed system operation and maintenance, the learning and operation and maintenance costs of self-hosted Temporal may exceed the benefits; it is recommended to start with the julep[dbos] lightweight solution, or use Temporal Cloud directly.

• Experimental Agent Developer: Interested in researching the Agent framework, willing to accept the instability of the RC version, and pursuing a safer and more auditable Agent architecture. Julep's compiled @flow and permissions model provide them with a different technical perspective than traditional chain frameworks. Prerequisites: You need to be familiar with Python type annotations and decorator syntax, and understand the basic concepts of Temporal/DBOS.

• Internal PoC team: is evaluating the feasibility of AI Agent in a production environment and has requirements for execution reliability. Julep's Durable Execution and Capability Manifest can serve as the cornerstone of technical verification in the PoC stage. Procurement Suggestion: First complete the PoC in non-critical scenarios (such as internal work order auxiliary processing, data pipeline monitoring), verify the compatibility of the @flow paradigm and the team's technology stack, and then gradually expand to the quasi-production process. The PoC phase should focus on testing: the actual RTO (recovery time objective) of crash recovery, the stability of the MCP tool under real network conditions, and the CI/CD integration cost of the CLI deployment process.

• Not applicable to people:

  • Teams that need to quickly build conversational Chatbots - Julep's focus is not on conversation management, but on workflow orchestration. For pure conversation scenarios, it is recommended to use LLM API + LangChain directly.
  • Non-technical users who have high expectations for the framework to work "out of the box" - v3 is still RC, and the coverage of documentation and examples is limited. Developers need to read the source code and GitHub Issues to solve problems by themselves.
  • Teams with strong binding requirements for the model layer - Julep's Reasoner abstracts model calls, but currently mainly supports Anthropic Claude and OpenAI, and does not have dozens of built-in model provider adaptations like LangChain.

Summary and Outlook

Julep has made the most systematic engineering attempt in the current open source community in the direction of "reliable Agent infrastructure" - a combination of compiled @flow, Durable Execution, and declarative permission models, building an Agent development paradigm that is closer to production requirements than the traditional chain framework.

Current core advantage: @flow's compile-time checksum and IR serialization design transform agent behavior from "black box text generation" to "precompiled, recoverable, auditable data flow graphs". Deep integration with Temporal increases reliability to "exactly once" engineering levels. Tool effect + idempotent double declaration has differentiated security value in open source frameworks.

Major Current Limitations: v3 is still in the RC stage, and there may be backward-incompatible changes to the API and IR format. Version discontinuation (v1 → v3 without migration path) may lead to community fragmentation. Document coverage and example richness lag behind mature frameworks such as LangChain and CrewAI. CLI and deployment tool chains are expensive to learn and not friendly enough to developers with non-Python background. The community only has 5 core contributors, and its long-term maintenance capabilities and issue response speed are questionable.

Follow-up observation points: The release time of the official version of 3.0.0 and the API stability commitment; whether there are production cases of v3 endorsed by major manufacturers or well-known enterprises; whether the ecological construction (third-party Tool library, pre-set @flow template IDE plug-in) can lower the entry barrier; the breadth of support for models other than OpenAI and Anthropic.

Procurement and Adoption Risk Assessment: For individual developers and technical verification teams, the RC version of Julep v3 is worthy of being included in the scope of technical assessment as a "second framework" - to experience the @flow paradigm in non-critical projects and accumulate engineering experience with Durable Execution, but it is not recommended to be used as the main framework for core business at this stage. For enterprises, it is recommended to wait for the official version of 3.0.0 to be released before making an evaluation; before the official version is released, you can try v3 in a sandbox environment to verify three things: whether the @flow compilation paradigm is compatible with the team's original code generation/code organization habits; whether the operation and maintenance costs of the Temporal/DBOS persistence backend are within the scope of the team's capabilities; whether the CLI deployment process can be smoothly embedded into the existing CI/CD pipeline. Before purchasing, enterprises also need to pay attention to the commercial use boundaries of the Apache-2.0 license and the Julep team's commitment to long-term maintenance of v3 (a common "stop maintenance after donation" risk for open source projects). In compliance-sensitive industries, you should confirm whether the execution trace storage of Durable Execution complies with data localization and audit retention requirements.

Related tools: CrewAI, langchain

Version Info

• Beta ：Beta version, supports multi-step task orchestration and MCP tool integration, no official precise date yet. （~2026-04）
• Alpha ：Alpha version, introducing session management and memory persistence, no official precise date yet. （~2025-10）