The Session Identity Crisis

Every agent framework invents a different session model. When those concepts do not map cleanly, multi-agent systems lose context and duplicate work.

God looked down at AI engineers building multi-agent systems and said "let me confuse their session IDs so they may not understand one another's state."

And it was so. LangGraph got thread_id. OpenAI also got thread_id but different. Claude got session_id. CrewAI got a UUID. PydanticAI got a list and a prayer. And A2A got two IDs, one optional.

And they've been writing custom mapping code ever since.

Imagine three people working on the same project - one uses Google Docs, one uses Notion, one uses Word. Each person's work makes sense in their own tool. Now ask "show me the full project history." You can't. Each tool tracks changes differently, stores history differently, and has no idea the other two exist. You end up copying and pasting between them, losing context at every handoff.

That's exactly what happens when AI agents built on different frameworks try to work together. Except instead of documents, it's conversations. And instead of copy-paste, it's custom integration code that someone has to build and maintain for every pair of frameworks.

The root problem is deceptively simple: every framework has a different answer to "where was I in this conversation?" Not just a different implementation - a different concept.

In LangGraph, a session is a thread of graph state snapshots. You pass a thread_id to a checkpointer, and the framework saves the full graph state at every super-step. You can time-travel through the history. You can fork a thread into two divergent paths.

In the OpenAI Agents SDK, a session is one of three mutually exclusive things. You can manage conversation history yourself with to_input_list(). You can use a built-in Session object backed by SQLite. Or you can let OpenAI manage state server-side with conversation_id and previous_response_id. Pick one - you cannot combine them in the same run.

In the Claude Agent SDK, a session is the full conversation record - your prompt, every tool call, every tool result, every response. The SDK writes it to disk as JSONL and hands you a session_id. You can resume or fork it.

In CrewAI, a session is a Flow state object - a Pydantic model with an auto-generated UUID. State persists across steps within a single Flow execution. Cross-execution continuity is your problem.

In PydanticAI, there is no session. You get a message_history - a list you carry between runs. No built-in session ID. No built-in persistence.

In A2A, a session is a contextId that groups messages into a thread, plus a taskId for each unit of work. The agent may use the contextId to maintain state - the protocol doesn't require it.

Six frameworks. Six answers. A checkpoint sequence. Three mutually exclusive modes. A JSONL file. A Pydantic model with a UUID. A list you carry around yourself. A pair of IDs where one is optional.

The naming makes this worse. LangGraph has a thread_id. OpenAI also has a thread_id. They mean different things. LangGraph's thread is a checkpoint sequence. OpenAI's thread is a message container in the Assistants API - or doesn't exist at all in the Agents SDK, where it's replaced by sessions and conversation IDs. Same word, different semantics.

Now try to build a system where agents on three of these frameworks collaborate on the same task. Which session ID is the source of truth? When a LangGraph agent hands work to a Claude agent, does the session_id reference back to the thread_id? Where does the shared context live? If the CrewAI Flow state has a UUID and the A2A task has a contextId, who maps between them?

Nobody. You do. For every combination.

Back to the Google Docs analogy: what you actually need is a shared project workspace that all three tools connect to - a single source of truth for the project's history, regardless of which tool each person prefers. Not a converter between Google Docs and Notion and Word. A layer underneath that makes the choice of tool irrelevant.

Agent systems need the same thing. A layer that owns the conversation identity across all participating agents, regardless of framework - so that a LangGraph agent, a CrewAI agent, and a Claude SDK agent can all participate in the same work without anyone writing a custom mapping between three incompatible session models.

That's one of the concrete problems I've been thinking about. More in the coming posts.