Maximem Synap's Agent Memory Now Available for OpenAI Agents SDK
The OpenAI Agents SDK has one of the lowest onboarding barriers of any agent framework. Built by OpenAI. Native integration with GPT-4o and o1 models. If you are building an agent that runs on OpenAI's stack, the official SDK is where you start.
Today, Maximem Synap extends the OpenAI Agents SDK with persistent per-user memory. Native memory stores conversation state within a single process, but Synap makes that state survive restarts, resolve entities across sessions, and retrieve relevant context without manual wiring.
Where OpenAI Agents SDK Excels
OpenAI gave developers a standard for building agents on their models. Tracing built in. Handoff patterns for multi-agent workflows. Function calling that works out of the box. Model switching without code changes. If your agent needs to call tools, reason across multiple steps, or hand off between specialized agents, the OpenAI Agents SDK handles the orchestration well.
The challenge is what happens when that user comes back tomorrow and the agent has no idea who they are.
How OpenAI Agents Memory Works Today
The OpenAI Agents SDK 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 OpenAI Agents SDK documentation.
InMemoryAgentMemory 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.
WindowedAgentMemory 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.
SummaryAgentMemory compresses history into summaries. Send a paragraph describing what happened instead of every message. But summarization is lossy. Research on long-context summarization has found that a single summary pass drops accuracy from 66.7% to 57.1% on recall tasks. Each additional pass loses more. You trade recall for tokens.
All three 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 the OpenAI Agents SDK's memory. It extends it with a persistence layer.
We ship three components that plug into the SDK's native interfaces:
SynapTracingHook implements the SDK's Hook interface. Attach it to any agent run. 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, and starts remembering.
SynapAgentMemory implements AgentMemory. 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 agents kept stalling in production — not from bad tool logic, but from missing context that lived in a different session last Tuesday. Production testing hit 90.2% on LongMemEval (a benchmark measuring cross-session fact recall across long, multi-turn conversations). 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 OpenAI Agents SDK
Persistence
OpenAI Agents SDK Native. In-process only. State clears on restart. With Synap. Per-user memory survives across sessions and restarts.
Entity Resolution
OpenAI Agents SDK Native. Raw identifiers. No linking across sessions. With Synap. "John" and "[email protected]" resolve to one canonical entity across every session, using embedding-based matching at the memory layer.
Compaction
OpenAI Agents SDK Native. Manual summarization. Lossy. With Synap. Automatic and configurable. Accuracy-preserving compaction that does not drop critical facts.
Retrieval Latency
OpenAI Agents SDK Native. Depends on setup. With Synap. 50 to 100ms fast mode (vector-only, best for chat). 200 to 500ms accurate mode (graph traversal + reranking, best for complex reasoning tasks).
Long-Term Recall
OpenAI Agents SDK Native. Not benchmarked for cross-session recall. With Synap. 90.2% on LongMemEval.
Failure Handling
OpenAI Agents SDK Native. Retrieval failures crash the run or return noise. With Synap. Empty result and a logged error. Your agent keeps running.
User Scoping
OpenAI Agents SDK 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. SynapAgentMemory 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 a profitable product and a runaway LLM bill.
Latency that does not block. Fast retrieval: 50 to 100ms. Accurate mode with graph traversal and reranking: 200 to 500ms. Both degrade without crrashing. 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 tracing hook captures turns in the background without adding latency. The retriever returns empty results on failure instead of crashing. The memory replays prior messages per session. All three components implement standard OpenAI Agents SDK interfaces. No wrappers. No adapters.
How to Get Started
Three steps, no rearchitecture required.
Step 1: Install.
pip install maximem-synap-openai-agents
Step 2: Initialize and attach.
import os
from maximem_synap_openai_agents import (
MaximemSynapSDK,
SynapTracingHook,
SynapAgentMemory,
SynapRetriever
)
sdk = MaximemSynapSDK(api_key=os.getenv("SYNAP_API_KEY"))
Attach automatic turn capture to any agent run
hook = SynapTracingHook(sdk=sdk, user_id="user_123")
Or use Synap as your memory backend
memory = SynapAgentMemory(
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/openai-agents
Memory Is Infrastructure
OpenAI gave developers a real standard for building agents on their models. 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.
Memory is infrastructure, not a feature — because it belongs below the agent, not inside it.
Start building OpenAI 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.
Related Posts
- What Is Agentic Context Management? (/blog/what-is-agentic-context-management)
- The Real Cost of DIY Agent Memory (/blog/real-cost-diy-agent-memory)
Skills Are the New Microservices (/blog/skills-new-microservices)
