Tiger Powers Julep’s AI Platform with Postgres-Native Infrastructure for Scalable Memory, Real-Time Reasoning, and Multi-Step Task Automation

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.