Maximem Synap's Agent Memory Now Available for Pydantic AI

Pydantic AI is the fastest-growing type-safe agent framework. Built by the Pydantic team. Native integration with Pydantic models for validation and serialization. If you are building an agent where type safety matters, Pydantic AI is where you start.

Today, Maximem Synap extends Pydantic AI with persistent per-user memory. Native memory stores conversation state within a single process. Synap makes that state survive restarts, resolve entities across sessions, and retrieve relevant context without manual wiring.

Where Pydantic AI Excels

Pydantic AI taught developers how to build agents with type safety. Structured outputs validated against Pydantic models. Dependency injection that works. Tool calling with proper type hints. If your agent needs to validate inputs, enforce schemas, or guarantee output structure, Pydantic AI handles the type plumbing well.

The challenge is what happens when your user comes back tomorrow.

How Pydantic AI Memory Works Today

Pydantic AI ships basic memory options for conversation tracking. All store data within a single process lifetime. For a deeper look at how each works, see the Pydantic AI documentation. InMemoryHistory stores every message in a list attached to the agent run. A scratchpad that grows forever. After twenty turns, your context window fills with noise. The agent cannot see your actual instructions. On restart, the scratchpad clears. Every session starts fresh.

LastNMessages keeps only the last K messages and discards everything older. The window slides. Yesterday's conversation is already gone. You are not solving memory. You are accelerating forgetting.

All two options solve in-session state. What they do not solve, by design, is cross-session persistence, entity resolution, semantic retrieval, or automatic compaction. Those are memory-layer problems.

What Synap Adds

Synap is agentic context management. It does not replace Pydantic AI's memory. It extends it with a persistence layer.

We ship three components that plug into Pydantic AI's native interfaces:

SynapMiddleware implements Pydantic AI's AgentMiddleware. Attach it to any agent. It captures every turn in the background and ingests it into Synap asynchronously. No code changes to your agent logic. No latency added to your execution. The agent keeps working. The agent starts remembering.

SynapHistory implements AgentHistory. Use it as your memory backend. Per-user, per-conversation scoping. State survives restarts. Prior messages replay on the next session without manual setup.

SynapRetriever implements Retriever. Fetch user-scoped memories as standard memory objects. Two modes: fast (vector-only, 50 to 100ms) and accurate(graph traversal + reranking, 200 to 500ms).

The integration is a native package. Drop it in, replace the memory backend, and your agent picks up persistent memory without a rewrite.

We built this because type-safe agents kept stalling in production. Not from bad validation. From missing context that lived in a different session last Tuesday. Production testing hit 90.2% on LongMemEval. Fast mode retrieves in under 100ms.

For why context management is infrastructure and not a feature, read What Is Agentic Context Management?. For build-versus-buy numbers, see The Real Cost of DIY Agent Memory.

What Synap Adds to Pydantic AI

Persistence

Pydantic AI Native. In-process only. State clears on restart. With Synap. Per-user memory survives across sessions and restarts.

Entity Resolution

Pydantic AI Native. Raw identifiers. No linking across sessions. With Synap. "John" and "[email protected]" resolve to one canonical entity across every session.

Compaction

Pydantic AI Native. Manual summarization or no compaction. Lossy. With Synap. Automatic and configurable. Accuracy-preserving compaction that does not drop critical facts.

Retrieval Latency

Pydantic AI Native. Depends on setup. With Synap. 50 to 100ms fast mode. 200 to 500ms accurate mode.

Long-Term Recall

Pydantic AI Native. Not benchmarked for cross-session recall. With Synap. 90.2% on LongMemEval.

Failure Handling

Pydantic AI Native. Retrieval failures crash the run or return noise. With Synap. Empty result and a logged error. Your agent keeps running.

User Scoping

Pydantic AI Native. Run-scoped only. With Synap. Built-in user_id, conversation_id, customer_id scoping out of the box.

What Production Teams Gain

Cross-session continuity. Your user chats on Monday, returns on Wednesday. SynapHistory replays prior context. SynapRetriever surfaces relevant facts from last week. The agent treats every session as one continuous conversation. Native memory treats every session as a fresh start.

Accuracy that ships. 90.2% on LongMemEval measures whether agents recall facts across long, multi-turn conversations spanning multiple sessions.

Token efficiency. Synap's compaction trims conversation history without dropping critical context. Most teams see 60 to 70% fewer tokens shipped to the LLM per turn. At scale, that is the difference between profit and burn.

Latency that does not block. Fast retrieval: 50 to 100ms. Accurate mode with graph traversal and reranking: 200 to 500ms. Both degrade without crashing. A failure returns empty results and a log line, not a broken agent.

Entity resolution. "John from Acme," "[email protected]," and "user_4829" resolve to one person across every session. Synap handles this at the memory layer so your agent does not have to.

Production resilience. The middleware captures turns in the background without adding latency. The retriever returns empty results on failure instead of crashing. The history replays prior messages per session. All three components implement standard Pydantic AI interfaces. No wrappers. No adapters.

How to Get Started

Three steps. No rearchitecture.

Step 1: Install.

pip install maximem-synap-pydantic-ai
Step 2: Initialize and attach.
import os
from maximem_synap_pydantic_ai import (
MaximemSynapSDK,
SynapMiddleware,
SynapHistory,
SynapRetriever
)
sdk = MaximemSynapSDK(api_key=os.getenv("SYNAP_API_KEY"))
Attach automatic turn capture to any agent
middleware = SynapMiddleware(sdk=sdk, user_id="user_123")
Or use Synap as your history backend
history = SynapHistory(
sdk=sdk,
user_id="user_123",
conversation_id="session_456"
)
Or retrieve user-scoped memories
retriever = SynapRetriever(
sdk=sdk,
user_id="user_123",
mode="fast"  # or "accurate"
)
Step 3: Deploy. Synap handles persistence, compaction, and retrieval. Your agent handles logic.
Full config, scoping rules, and error handling: https://docs.maximem.ai/integrations/pydantic-ai

Memory Is Infrastructure

Pydantic AI gave developers type-safe agents. Real value. The memory layer it ships handles in-session state well. Making that state persist across sessions, resolve entities, and retrieve intelligently is a different problem.

The teams that ship production agents discover this around month three. They either build memory infrastructure themselves, or they plug in a system built for the problem.

This is why memory is infrastructure, not a feature.

Start building Pydantic AI agents that remember across sessions → (https://synap.maximem.ai)

Synap pricing is usage-based. You pay for memory operations: storage, retrieval, compaction. No per-seat or per-framework surcharge. Starter plan:
$49/month. Every new account gets $25 in free credits to test before committing. See full pricing at https://synap.maximem.ai/pricing.