Julep AI is an open-source platform that lets developers compose and run sophisticated agentic AI workflows, providing a backend so agents can remember past interactions and orchestrate complex, multi-step tasks at scale. Founded by veteran AI builder Diwank Tomer, Julep targets teams that need multi-step reasoning, tool integrations, and rich context windows for their AI, all without wrestling with undifferentiated backend infrastructure. The platform manages long-term memory, branching logic, parallel tool calls, and real-time monitoring so developers can focus on their AI logic instead of reinventing plumbing.
However, building a production-grade AI system posed serious data challenges. As usage grew, Julep needed a data layer that could:
- Track state in milliseconds: Agent state can evolve rapidly (many events per second); the database must capture fine-grained events without slowing down.
- Enable vector “memory” search: Agents recall information via semantic embeddings, requiring fast similarity search over a growing knowledge base.
- Materialize context in real-time: Dashboards and debug UIs must refresh continuously, even under unpredictable, bursty workloads.
- Stay simple and Postgres-native: The team didn’t want a grab-bag of specialty databases for logs or vectors; everything needed to live in one familiar stack.
In short, Julep’s data architecture had to unify time-series event tracking and vector search, with high performance and minimal ops overhead. The typical approach for AI apps is to juggle multiple systems (analytics DB, vector DB, cache, etc.), but that introduces synchronization headaches and stale data. Diwank’s team was determined to avoid this complexity. As he puts it, “All roads lead back to Postgres,” so they set out to push Julep’s state, memory, and observability entirely into TigerData’s PostgreSQL platform.
“Other vector databases and logging platforms were either too rigid, too expensive, or didn’t allow us to keep things Postgres-native.” — Diwank Tomer, Founder of Julep
The Scale-Up Moment: When Millions of Agent Events Hit Postgres
Building Julep’s agent platform revealed several key requirements, each with its own challenges:
- Capturing Every Thought in Real Time: Every agent produces a firehose of events (messages, tool calls, decisions). A naive Postgres table would quickly bloat and make querying recent state painfully slow. Julep needed to ingest millions of events per agent and still query the latest state in milliseconds.
- Remembering What Matters with Semantic Memory: Agents rely on “long-term memory” – stored embeddings of past interactions or documents – to recall relevant context. Using an external vector DB (e.g. Pinecone or Weaviate) would add network latency, extra cost, and create consistency issues keeping embeddings in sync. Julep wanted semantic search built-in without sacrificing speed or consistency.
- Serving Fresh Context on Demand: To prompt an AI with relevant history or to power a live dashboard, Julep must continuously aggregate event data (e.g. summarizing the last N messages). These rollups must refresh in near real-time, even as new events pour in unpredictably. Traditional materialized views would lag or require constant refresh overhead.
- Keeping the Stack Lean & Familiar: As a small team, Julep refused to maintain a separate “sidecar” stack for logs or vectors. Every extra system would increase ops burden and complexity. The ideal solution had to keep everything in Postgres so the existing tooling and skills could be leveraged.
Building on the Fastest Postgres: A Unified AI Data Stack
Julep found its answer by building on TigerData’s PostgreSQL platform (TimescaleDB + pgVector/pgAI). Instead of spinning up new systems, they extended Postgres with time-series and vector capabilities to meet all the needs. Key building blocks of the solution include:
- Time-partitioned hypertables: All agent events are stored in a TimescaleDB hypertable partitioned by time. This allows inserting fine-grained events at high throughput, while keeping query performance high by partition pruning. Recent data stays on fast disk, and older partitions are automatically offloaded to cheap object storage (Amazon S3) for long-term retention. In practice, Julep keeps the last two weeks of hot data on SSD and seamlessly archives older history – cutting storage costs without losing the ability to query across weeks of activity in seconds due to TimescaleDB’s continuous aggregates. Timescale’s native compression further shrinks the storage footprint for cold data.
- Continuous aggregates: Julep uses TimescaleDB’s continuous aggregate views to power real-time summaries and rolling windows. For example, an agent’s entire conversation history or the last N interactions can be materialized continuously as new events arrive. These precomputed views ensure that when the AI needs a context window or when an engineer opens a dashboard, the relevant summary is ready with sub-second latency. (In Diwank’s words, his team hasn’t had to hand-optimize queries at all: “As long as we use the time column correctly, Timescale just handles it.”)
- In-database vector search (pgVector + pgAI): For the agents’ long-term memory, Julep turned to Tiger Postgres’ built-in vector capabilities. They use the pgvector and pgvectorscale extensions to store embeddings and perform similarity search. On top of that, Julep adopted the open-source pgai Vectorizer to automate the embedding workflow. Whenever a user uploads a document or an agent generates text to remember, a simple SQL call
ai.create_vectorizer(...) triggers the database to generate an embedding and store it alongside the source data. This replaced what used to be a complex offline pipeline. “Before pgAI, we had a whole Temporal workflow – 300–400 lines of code – just to generate and cache embeddings,” Diwank recalls. “Now it’s one SQL function.” By treating embeddings as derived data (like an index), the database keeps them in sync with the source text automatically, eliminating consistency bugs. - Unified observability: With time-series events and vectors co-located in Postgres, Julep engineers can run one SQL query to understand both “what the agent did” and “why it recalled that memory.” This unified view was impossible when data was siloed in different systems. Now, debugging an agent’s behavior, such as correlating a tool usage event with a semantic memory lookup, is trivial using a JOIN between the event table and the embedding table. As an added benefit, all of Julep’s existing Postgres tools (ORMs, admin UIs, cloud backups) Just Work™ with the new data types, since it’s all standard SQL.
Why go all-in on TigerData for these features? The decision was driven by familiarity and proven performance. The team had prior experience with TimescaleDB (created by the TigerData team), and they trusted Postgres’ reliability. Using extensions (rather than new external datastores) meant zero application refactoring; Julep’s code could continue treating the database as “the source of truth” for both logical state and vector memory. As Diwank puts it, “TimescaleDB is a toolkit that lets you do things in Postgres that weren’t previously possible for our use case.” By pushing more logic into the database, Julep minimized the moving parts in production. The end result is a lean, powerful data stack: one Postgres cluster (on Tiger Cloud) that handles event streaming, real-time analytics, and AI semantic search all together.
From Firehose to Fast Insights: Millisecond Queries at Scale
Adopting TigerData’s Postgres-native solution has paid off tremendously for Julep. They transformed a tangle of data concerns into a single, elegant stack – and their users and engineers are feeling the benefits:
- Infrastructure Simplification: There are fewer moving pieces to monitor, scale, and debug. Importantly, it keeps Julep’s architecture simple and cohesive: new team members need to understand Postgres (which they likely already know), not a grab-bag of niche datastores.
- Developer Velocity: The switch to in-database embeddings and time-series logic has freed up significant engineering time. Generating embeddings went from hundreds of lines of orchestrated code to a one-liner SQL procedure – meaning less custom code to maintain and fewer things that can break. Julep’s senior engineers no longer spend days fiddling with index management or writing glue code between systems. They can now devote that time to product improvements and new features.
- Performance at Scale: Despite surging workloads, Julep’s platform remains snappy and reliable in production. Real-time dashboards that aggregate recent agent activity now load in under a second, even when hundreds of agents are churning out events. The combination of partitioning and continuous aggregates means query latency stays low without manual tuning – no more worrying about index bloat or vacuum jobs during peak load.
- Cost Efficiency: TimescaleDB’s automatic data tiering and compression translate directly into savings. By offloading old chunks of data to object storage and compressing them, Julep dramatically reduced the storage cost per gigabyte of agent history. Meanwhile, the active working set (recent weeks of data) stays on high-performance storage. This hot/cold storage architecture ensures Julep isn’t paying top dollar to keep years of rarely-accessed data on SSD.
Speed Without Sacrifice
By embracing TigerData’s Postgres-native approach, Julep has turned its data layer from a potential bottleneck into a competitive advantage. The platform delivers real-time, memory-augmented AI agents without a maze of ancillary systems. Julep’s experience shows that for AI applications, unifying your state and vector data in one database can dramatically accelerate development while simplifying operations.
Looking ahead, TimescaleDB and pgAI are set to remain core to Julep’s roadmap. The team has several exciting explorations on the horizon:
First, the Open Responses API is slated to add real-time streaming so partial results, progress updates, and connection-keep-alive messages can reach front-end users the instant an agent starts thinking. Companion work includes a secure deletion endpoint (with cascading options and audit logs) and richer tool-call integrations that translate agent requests into external actions without extra glue code. On the performance side, the roadmap lists automatic smart truncation, context-length optimization, and other scaling tweaks to keep inference latency low as datasets grow.
In sum, Julep’s partnership with TigerData has empowered them to build the next generation of AI agents with speed, simplicity, and confidence. By trusting Postgres to do the heavy lifting, Julep can concentrate on innovating in the agent space. As more companies discover the benefits of this unified approach, Julep stands as a compelling case study: sometimes, the fastest way to build cutting-edge AI is to lean on the fastest PostgreSQL under the hood.
