Julep → memory.store

A one-sentence summary

Julep is an open-source AI agent and persistent workflow platform designed for developers, while Memory Store, which is currently developed by the same team, organizes conversations, meetings, decisions, and work contexts across different applications into shared memories that can be accessed by multiple AI clients.

Current product status

The term “Julep or memory.store” mentioned in the records now refers to two related products that serve different purposes. The Julep platform has been fully open-sourced, and the team’s official website states that the main focus of development has shifted to Memory Store.

Just because the Julep code is open source does not mean that the Memory Store hosting service and its data backend are also fully open source. The licenses for the product repositories, connector repositories, and plugin repositories should be indicated separately in the directory.

What problem does Julep solve?

Traditional agent prototypes often consist of temporary iterative models and tools; once their operation is interrupted, it is difficult to resume, and it’s not easy to audit each step of the process. Julep represents agents as persistent, composable data streams, enabling long-running tasks to maintain their state, be retried, and have their execution process explained.

• Define AI agents with clear configuration and tool permissions.
• Maintain cross-session conversations and user context.
• Orchestration involves tasks such as conditional logic, loops, parallel processing, and function calls.
• Log the execution status, step outputs, and errors.
• After a failure, retry or recover in a secure manner according to the strategy.
• Retrieve relevant information from documents and historical records.
• Accessible via Python, Node.js, APIs, or self-hosted services.

Agents

An agent stores the model, name, purpose, instructions, system templates, default generation parameters, metadata, documentation, and the tools that can be used. The same agent can handle multiple sessions or tasks.

Sessions status session

Sessions are used to store the continuous interactions between the agent and the user, including historical messages, context, system templates, metadata, and context overflow policies. Dialogue memory is part of the session, rather than being permanently incorporated into the agent’s definition.

• Create multiple isolated sessions for the same agent.
• Bind users and agents to a specific conversation.
• Save historical messages and the current context.
• Set truncation or adaptive context policies.
• Vector, text, or mixed search to control document retrieval.
• Decide whether to execute or forward the tool call automatically.
• Use metadata to save non-sensitive business states.

Long-term memory and RAG

Julep can associate documents with agents or users, and it enables vector, text, or hybrid retrieval during sessions. Document storage, embeddings, and historical messages together provide agents with long-term context.

The results of the retrieval are merely relevant materials; they do not guarantee accuracy, timeliness, or suitability for use in the current task. The application still needs to implement mechanisms for determining the validity period of the materials, applying permission filters, and citing sources for answers.

Tasks: multi-step tasks

A Task is similar to a workflow template in the GitHub Actions style; it describes the input structure, the tools used, and a series of steps. It is suitable for automating tasks that require long-running processes and a clear control flow, such as research, document processing, customer service, and data pipelines.

• Verify the input structure of the task.
• Pass the output from the previous step to the subsequent steps.
• Execute conditional branching based on intermediate results.
• Process collections using foreach or mapping.
• Invoke models, system tools, integrations, and external APIs.
• Set retry, timeout, and error handling options for the steps.
• Use the Execution object to query task status and results.

The document advises against including very large objects of several MB or more directly in the workflow inputs. Large files should be uploaded and their references passed on, or they should be processed in a paginated or segmented manner.

Persistent execution

Julep ensures that tasks can be resumed after process crashes, network failures, or temporary service errors, and it implements strategies for handling retryable errors. Each execution saves information on status changes, step outputs, points of failure, and error messages.

Flow programming model

Julep 3 organizes ordinary Python names into composable flows, supporting pure steps, reasoners, tools, branches, fanouts, retries, and timeouts, and compiles them into a unified linear representation. The current 3.x version is still available as a candidate release; installation requires the pre-release option.

The interfaces of candidate versions may change; therefore, production projects should rely on fixed versions, run integration tests, and establish an upgrade plan. Old Tasks documents and the new Flow API should not be used interchangeably in the same code examples.

Toolset

Models can only use tools that have been explicitly granted access to, but the list of allowed tools might still be too broad. Tools that are used for sending messages, making payments, or deleting or modifying production data should incorporate approval mechanisms, idempotent keys, and audit logs.

MCP integration

The Julep agent can connect to public or private servers that are compatible with MCP, in order to dynamically discover available tools. The documentation supports two types of data transmission: request-response and server event streams.

1. Confirm the MCP server operator and deployment location.
2. List the tools and actions that the agent truly needs.
3. Place the authentication token in Julep’s secret storage.
4. Connect to the testing environment and check the tools that were identified.
5. Restrict write operations and the transmission of sensitive data.
6. Simulate timeouts, repeated calls, and server unavailability.
7. Record each tool invocation along with its business outcome.
8. Regularly revoke old credentials and unused connections.

Secret management

Secrets is used to store model keys, third-party API tokens, and other sensitive values, which can be referenced by name within tasks and tools. The documentation states that these keys are encrypted using AES-256 in a static manner, and they are isolated according to each developer’s account.

• Do not write keys in code, YAML, or logs.
• Different credentials are used for development, testing, and production.
• Assign the minimum permissions based on integration and purpose.
• Regularly rotate and document the persons in charge of credentials.
• Upon detecting a leak, it should be revoked immediately rather than simply deleting the code.
• Check whether the workflow output contains keys unexpectedly.

Models and suppliers

Julep uses LiteLLM to provide a unified connection to Anthropic, OpenAI, Google, Groq, OpenRouter, Amazon Nova, as well as various embedded models. Developers can switch between different model providers through the same proxy interface.

The platform may provide keys for development and testing purposes, but for production deployment it is necessary to use one’s own supplier’s keys. Costs related to models, rate limiting, data retention, and regional policies are determined by the respective supplier or by the self-hosted environment.

Python and Node.js SDKs

Julep offers Python packages and a Node.js SDK for creating proxies, users, sessions, documents, tasks, and executions. API keys should be retrieved from environment variables or a secret management system.

1. Choose the stable version or a specific candidate version.
2. Install the SDK for the corresponding language.
3. Create an isolated development environment and API Key.
4. First, create a single-responsibility proxy.
5. Create sessions and test users for the agent.
6. Add minimal tools and example documents.
7. Create a task and poll the Execution status.
8. Verify for errors, retry, check permissions and costs before going online.

Open Responses

Open Responses is an open-source, self-hosted interface compatible with Responses, provided by Julep; it enables connection to various model backends and allows existing SDKs to be integrated by modifying the base address. It is suitable for teams that need local or private deployment in order to reduce dependence on specific models.

Self-hosted architecture

The full Julep can be run in single-tenant or multi-tenant mode using Docker Compose; its components include an API proxy, memory storage, integration services, model proxies,Temporal, object or Blob storage, monitoring tools, and a gateway.

Single-tenant and multi-tenant

The single-tenant mode allows the use of the SDK directly without requiring an API key, and it is suitable for local development or controlled internal environments. The multi-tenant mode requires the generation of JWTs in order to isolate developers’ resources at the gateway layer.

The fact that a key is not required does not mean that a single-tenant service can be exposed to the public network. A reverse proxy, authentication mechanisms, network isolation, backups, and auditing are still necessary in a production environment.

What is Memory Store?

Memory Store is the team’s current key product; it is described as a Dropbox-style solution tailored for the context of agents. It organizes meetings, messages, notes, decisions, contacts, and project details into a readable form of memory for individuals or companies.

• Synchronize content from work platforms such as Slack, Gmail, Granola, and Fathom.
• Organize the conversations and notes into characters, projects, and decisions.
• Generate Living Briefs that are updated as new memories arise.
• To save personal preferences, notes, and long-term context.
• Retain the discussions and reasons behind the decisions for the team.
• Use MCP to enable different AI clients to retrieve the same context.
• Users are allowed to view and delete memories.

Sharing memory across tools

Memory Store connects to compatible clients such as Claude, Codex, ChatGPT, Cursor, and Raycast via MCP, allowing the context recorded in one tool to be retrieved by another. The official website states that it is compatible with all MCP clients, with Claude having been tested the most thoroughly.

Sharing memories across clients expands the reach of data. Users should distinguish between personal and team spaces, and avoid storing confidential client information, credentials, or private conversations in inappropriate shared memories.

Living Briefs

Living Briefs are thematic documents that are updated as new information becomes available; they can consolidate decision logs, team status, customer requirements, project background information, or brand guidelines. Instead of simply accumulating all original conversations, they help maintain a relatively stable understanding of the work at hand.

• Define a clear theme and responsible person for each Brief.
• Retain the key evidence behind the conclusion.
• Mark decisions that are outdated or have been overturned.
• Avoid turning every temporary event into a permanent rule.
• Major changes require manual confirmation.
• Regularly clean up duplicate and conflicting memories.

Memory Store installation method

Hosts that lack a plugin system, such as Claude Desktop, can connect directly to Memory Store MCP. Claude Code and Codex, on the other hand, can install Memory Store workflow capabilities through public plugin markets and then obtain MCP certification.

Memory Store plugin market

The mem-plugins repository is released under the Apache-2.0 license; it includes the basic memory-store plugin as well as the separate gtm-agent plugin. The code for these plugins is available under an open-source license, but for normal use it is still necessary to rely on Memory Store to handle MCP authentication.

The GTM Agent may also rely on search, email, calendar, and automation connectors, and it is capable of carrying out outreach workflows. Before installing any extensions, it is necessary to check the required permissions, approval processes for sending messages, suppression lists, and the costs associated with external services.

Price and cost

The price information was verified on August 23, 2026; the actual amounts, taxes, exchange rates, and discounts may vary, and the final figures will be those displayed on the settlement page.

The open-source code for Julep can be used and modified freely, but self-hosting is not cost-free. The personal version of Memory Store allows for a free trial, while the team version requires an appointment for a demonstration; at present, there is no publicly available list of fixed pricing plans.

When purchasing Memory Store, it is necessary to obtain written confirmation regarding the number of slots, connectors, storage capacity, the number of recall operations, data retention policies, export options, support services, and deletion procedures. For self-hosted Julep, the costs related to models, cloud resources, backups, security measures, and personnel needed for upgrades must be taken into account as part of the total cost.

Data and security considerations

• Establish tenant isolation for agents, users, sessions, and projects.
• Apply permission filtering that is consistent with the business to document retrieval applications.
• Only send the data required to complete the operation to the tool.
• Treat the model and third-party integrations as separate data processing entities.
• Set the retention periods for messages, documents, execution history, and logs.
• Encrypted databases, object storage, backups, and network traffic.
• Add manual approval for deletion, sending, and payment tools.
• Regularly test backup restoration and credential rotation.

Full Julep self-hosting allows teams to take control of the infrastructure, but the responsibility for security also shifts to the person who deploys it. Memory Store is a product that operates in a shared context; before using it, it is necessary to confirm the location of hosting, the sub-processors involved, and the relevant enterprise contracts.

Open-source license

Apache-2.0 permits commercial use and includes patent licensing terms; however, the license and relevant statements must be retained when redistributing it. Deployers are also required to comply with the licenses of the models, databases, dependencies, and third-party tools.

Which users are it suitable for

• AI application developers who need to persist long-running tasks.
• A backend team that needs branching, loops, retries, and tool orchestration.
• Companies that wish to have a self-hosted proxy platform and data layer.
• Product teams that require session-crossing RAG and user memory.
• Developers who wish to switch model suppliers using a unified interface.
• Individual users who need tools such as Claude and Codex to share context.
• There is a desire to create teams that handle company decision-making and project documentation.
• Community members who develop the Memory Store plugin and agent workflows.

Product advantages

• The Julep core platform is licensed under the permissive Apache-2.0 license.
• Provide unified management for proxies, sessions, documents, tasks, and executions.
• It supports persistence, failure recovery, retry, and audit tracking.
• Deployment options include Python, Node.js, API, and Docker.
• Multiple model providers are supported through LiteLLM.
• Open Responses offers self-hostable compatible interfaces.
• Memory Store allows contexts to be shared across multiple AI clients.
• Living Briefs is suitable for maintaining up-to-date team awareness.
• The plugin market features open code and is scalable.

Main limitations

• Julep 3 is still in the candidate release phase.
• A complete self-hosted architecture involves numerous components, which raises the barrier to operation and maintenance.
• Calling the production model requires having the supplier’s key and incurs costs.
• Some old documents may coexist with the new version of the Flow interface.
• Open Responses is still in the Alpha stage.
• Providing compatible interfaces does not guarantee identical behavior.
• The details of the Memory Store fixed package, quota limits, and enterprise data terms are not available.
• Sharing memory across tools expands the scope of access to sensitive information.
• Open-source plugins do not imply that the backend is also open source when hosted by Memory Store.

Selection recommendations

Pre-launch checklist

1. Determine whether agent orchestration is required or memory sharing across clients is needed.
2. Select a stable Julep version and lock in the dependencies.
3. List the costs for models, databases, Temporal, and storage.
4. Define minimum permissions and side effect levels for each tool.
5. Design access control for tenants, users, projects, and documents.
6. Recovery from test failures, idempotency, timeouts, and duplicate calls.
7. Policies for data processing related to the integration of evaluation models with third parties.
8. Users of the Memory Store team provide written confirmation of the prices and terms related to the data.
9. Establish processes for memory error correction, deletion, export, and handover upon departure.
10. Conduct safety and cost evaluations using small-scale real-world workflows.

Frequently Asked Questions

Is Julep open source now?

Yes. The core repository of Julep is licensed under the Apache-2.0 license, allowing it to be used, modified, and hosted on one’s own server; currently, version 3.x remains a candidate release.

Is Memory Store also Julep?

They are managed by the same team but serve different purposes. Julep is a developer proxy platform, while Memory Store is a product that provides shared intelligent agent memories for individuals and teams.

Is Julep free?

The source code is available free of charge, but there are actual costs associated with models, databases, object storage,Temporal, networking, and maintenance. The prices from the old cloud service model should not be used as a fixed basis for pricing the current open-source products.

How much is Memory Store?

The official website states that individual users can try it out for free, while the team version requires an appointment for a demonstration; no fixed price or usage limits have been disclosed yet. It is necessary to consult the sales team to obtain the complete contract before making a purchase.

Does Julep support long-term memory?

Supported. Sessions save conversations and contexts; Docs along with embedded storage enable vector, text, or hybrid retrieval methods. The fully self-hosted architecture also includes a persistent memory service.

Does Julep support MCP?

It supports connection to MCP-compatible servers as well as dynamic discovery of tools. Memory Store, in turn, enables multiple AI clients to record and retrieve shared memories through MCP.

Can Julep be deployed privately?

Yes. Both the full platform and Open Responses provide Docker self-hosting options, but the deployer is responsible for handling authentication, data management, monitoring, backups, and upgrades.

Is Memory Store open source?

The market code for the Memory Store plugin is licensed under the Apache-2.0 license, but the hosted products and the backend are not fully open source. Making a plugin open source does not equate to making the entire SaaS platform open source.

Summary

Julep is suitable for AI application development teams that require long-term stability, complex control flows, failure recovery, RAG, and integration of multiple tools. Its Apache-2.0 license, self-hosting capability, and multi-model interface offer strong engineering control.

Memory Store addresses the issue of individuals and teams having to repeatedly provide context across various AI tools. When making a choice, it is necessary to distinguish between \"building an agent backend\" and \"purchasing a shared memory service\", and then evaluate separately the costs associated with open-source maintenance, hosting fees, data permissions, and the management of memory across different clients.