TinyFish | Foundations

The Portability Gap

The Export File Is Not the Agent

By Rina Takahashi— March 25, 2026

Feature image for article: The Export File Is Not the Agent

A growing wave of tools now lets you export an agent definition and import it into a different framework. System prompts, tool schemas, model preferences, constraints. All neatly packaged. The tools work. What's worth paying attention to is what the export file leaves behind.

Teams who've tried moving a working agent between environments keep reporting the same thing: the agent that arrives behaves like it's never seen the domain before. Months of reliable operation, gone. Same instructions, same configuration, same logic. But something stayed behind. The portability tools are drawing a very precise line around what that something is, and it suggests the ecosystem may be building on a wrong assumption about what agents actually are.

The Portability Gap

The Export File Is Not the Agent

By Rina Takahashi— March 25, 2026

A growing wave of tools now lets you export an agent definition and import it into a different framework. System prompts, tool schemas, model preferences, constraints. All neatly packaged. The tools work. What's worth paying attention to is what the export file leaves behind.

Teams who've tried moving a working agent between environments keep reporting the same thing: the agent that arrives behaves like it's never seen the domain before. Months of reliable operation, gone. Same instructions, same configuration, same logic. But something stayed behind. The portability tools are drawing a very precise line around what that something is, and it suggests the ecosystem may be building on a wrong assumption about what agents actually are.

Portability, Tested

What Doesn't Survive the Trip Tells You Something About Agents

By Rina Takahashi— March 26, 2026

Feature image for article: What Doesn't Survive the Trip Tells You Something About Agents

Docker found its seam between application and infrastructure, and that boundary turned out to be clean enough to hold across millions of deployments. Now an open-source project called GitAgent is storing AI agents as flat files in a git repo. Personality in YAML. Memory as Markdown. One export command targeting five different frameworks. The pitch is portability. The bet is that there's an equivalent cut to be made for agents.

Look at what happens at the border. LangChain, CrewAI, AutoGen, Claude Code, and OpenAI don't just wire things differently. Some of what defines an agent travels cleanly across that boundary. Some of it doesn't. And the gap between those two categories says a lot about where the ecosystem actually stands.

Portability, Tested

What Doesn't Survive the Trip Tells You Something About Agents

By Rina Takahashi— March 26, 2026

Docker found its seam between application and infrastructure, and that boundary turned out to be clean enough to hold across millions of deployments. Now an open-source project called GitAgent is storing AI agents as flat files in a git repo. Personality in YAML. Memory as Markdown. One export command targeting five different frameworks. The pitch is portability. The bet is that there's an equivalent cut to be made for agents.

Look at what happens at the border. LangChain, CrewAI, AutoGen, Claude Code, and OpenAI don't just wire things differently. Some of what defines an agent travels cleanly across that boundary. Some of it doesn't. And the gap between those two categories says a lot about where the ecosystem actually stands.

Further Reading

The 2026 MCP RoadmapThe protocol's own gap map. Config portability, auth continuity, and gateway behavior are all still pre-RFC, which tells you where the real boundaries are.

Salesforce/MuleSoft 2026 Connectivity Benchmark ReportPrimary data on agent silos at scale: half of enterprise agents operate in isolation, the average org runs twelve. Vendor-commissioned, so read accordingly, but the numbers ground ...

Quick links

MCP's Biggest Growing Pains for Production Use Will Soon Be Solved

Meet GitAgent: A Universal Open-Source Format for Framework-Agnostic AI Agents

AI Agent Frameworks 2026: LangGraph vs CrewAI & More

What Travels, What Doesn't

"Can we move this agent somewhere else?" sounds like one question. It's actually six, and they have wildly different answers.

An agent is a stack of layers. System prompts, tool connections, memory, authorization, learned behavior, accumulated trust. Some of these travel well. Tool definitions, thanks to MCP, have a real interoperability story. System prompts are literally just text you can copy-paste. But memory architecture, auth tokens, behavioral patterns, trust? That's where the conversation gets honest.

These cards map the gradient. It's steeper than most portability discussions acknowledge.

What Travels, What Doesn't

"Can we move this agent somewhere else?" sounds like one question. It's actually six, and they have wildly different answers.

An agent is a stack of layers. System prompts, tool connections, memory, authorization, learned behavior, accumulated trust. Some of these travel well. Tool definitions, thanks to MCP, have a real interoperability story. System prompts are literally just text you can copy-paste. But memory architecture, auth tokens, behavioral patterns, trust? That's where the conversation gets honest.

These cards map the gradient. It's steeper than most portability discussions acknowledge.

Core Logic

System Prompts Copy Easily but Behave Unpredictably

A system prompt is just text. You can paste it anywhere. But identical instructions produce meaningfully different behavior across model families, and frameworks like LangChain, CrewAI, and OpenAI's Agents SDK each wire those instructions into different structural patterns. The words travel fine. The behavior stays behind.

Tool Layer

MCP Makes Tool Definitions the Bright Spot

Tools are the most portable layer right now, and MCP deserves the credit. Point a new client at the same MCP servers and things mostly just work. Mostly. JSON Schema dialect mismatches still cause real friction, and MCP handles discovery, not execution concerns like rate limits or compliance logging.

Agent Memory

Memory Is Where Portability Runs Into Concrete

Every major framework implements memory its own way. LangChain has buffer and summary modules. CrewAI has built-in memory types. AutoGen leans on conversational history. None of them talk to each other. Platforms like Mem0 and Zep offer framework-agnostic persistence, but there's no export standard. Switching frameworks means rebuilding from scratch.

Auth State

Authorization Tokens Are Locked Down by Design

OAuth tokens are scoped to a specific server, resource, and agent identity. That's intentional: a leaked token shouldn't work somewhere else. But it also means authorization state can't follow an agent between deployments without full reissue. NIST's February 2026 concept paper on agent identity signals just how unsettled this area remains.

Learned Behavior

Hard-Won Production Skills Go Nowhere at All

Over time, agents accumulate workflow shortcuts, heuristics, task-specific improvements. These live as elaborate prompt additions, vector-embedded examples, or fine-tuned weights. None of these formats are standardized. None are cross-framework compatible. An agent that spent months getting good at its job carries none of that skill into a new home.

Earned Trust

Trust Built Over Thousands of Tasks Resets Instantly

Separate from formal permissions, trust is the expanded autonomy an agent earns by performing reliably over time. Thousands of flawless tasks, zero incidents, growing confidence from the humans and systems around it. Move that agent to a new framework or deployment and all of it vanishes. No protocol exists for exporting a track record.

How Frameworks Carry State

Ask five agent frameworks where memory lives and you'll get five structurally different answers. One checkpoints graph state to Postgres. Another treats the raw conversation as the only record. A third stores everything on someone else's servers, behind an API key you don't fully control.

These differences feel like implementation details right up until you try to move an agent from one framework to another. That's when the real shape of the problem becomes visible: identity might travel, but accumulated knowledge almost never does. Each framework's state model reflects genuine architectural choices. And those choices lock in faster than most teams expect.

Here's where agent state actually lives in six major frameworks, what persists, and what gets quietly left behind.

How Frameworks Carry State

Ask five agent frameworks where memory lives and you'll get five structurally different answers. One checkpoints graph state to Postgres. Another treats the raw conversation as the only record. A third stores everything on someone else's servers, behind an API key you don't fully control.

These differences feel like implementation details right up until you try to move an agent from one framework to another. That's when the real shape of the problem becomes visible: identity might travel, but accumulated knowledge almost never does. Each framework's state model reflects genuine architectural choices. And those choices lock in faster than most teams expect.

Here's where agent state actually lives in six major frameworks, what persists, and what gets quietly left behind.

Graph State

LangGraph Scatters State Across Three Separate Layers

Memory fragments across graph state schemas, checkpointer backends, and store namespaces. Short-term memory is thread-scoped. Long-term memory spans sessions via PostgreSQL or InMemoryStore. No single export captures the full picture. Moving an agent means reconstructing three layers independently, with nothing bridging them.

Unified Memory

CrewAI Funnels Everything Through One Memory Object

A single Memory() class replaces separate short-term, long-term, and entity stores. An LLM infers scope and importance at save time. Facts get auto-extracted after each task. Agent identity ports easily as role/goal/backstory text. The fact store, though? No standard export format exists.

Conversation State

AutoGen Makes the Conversation the Whole State

State is a flat message list shared across group chat participants. No separate schema. Agents join and leave dynamically while a GroupChatManager picks speakers. Persistent memory requires bolting on ChromaDB or Mem0. The message JSON exports fine. The group topology and speaker logic don't.

Server-Side Threads

OpenAI Assistants API Keeps State on Their Servers