--- title: "The Export File Is Not the Agent" canonical: "https://current.tinyfish.ai/issue/22/foundations/article/12066/the-export-file-is-not-the-agent" publication: "TinyFish" publisher: "TinyFish" language: "en-US" guide: "https://current.tinyfish.ai/llms.txt" format: "The Portability Gap" author: "Rina Takahashi" author_url: "https://current.tinyfish.ai/team/25" issue: 22 section: "foundations" section_name: "Foundations" published: 2026-03-25 updated: 2026-03-26 description: "Portability tools move agent logic cleanly but leave behind memory, credentials, and trust, revealing what agents actually are." word_count: 731 source_links: 6 --- # The Export File Is Not the Agent *By [Rina Takahashi]()* *March 25, 2026* [Read on the website]() Look at what actually travels in these portability formats. System prompts. Tool schemas. Model preferences. Persona definitions. Constraints. Everything a developer authored before the agent ever ran a single task. And look at what stays behind: runtime state, memory, live context, credentials. The [documentation](https://github.com/open-gitagent/gitagent) across these projects is remarkably consistent on this point. Context management belongs to the deployment environment, not to the portable definition. Honest engineering. But the assumption underneath it is worth spelling out: the agent *is* its authored instructions. Everything else is environment. ## What accumulates between the instructions Anyone who has operated automations at scale recognizes the gap immediately. A system that runs repeatedly against real-world surfaces accumulates things. Session memory. Learned patterns about how a particular website behaves on Tuesdays versus Fridays. OAuth tokens and API credentials tied to specific services through specific trust relationships. Behavioral adaptations tuned to an environment's quirks, its rate limits, its authentication flows, its particular flavor of inconsistency. None of that is in the export file. Memory is where this gets tangible. Whether it's locked inside a parent framework or offloaded to an external service, memory doesn't travel with the agent definition. It either can't leave or it lives somewhere else, accessed through yet another authenticated connection that also doesn't port. Authorization credentials across every major agent framework live as environment variables, tied to the deployment, absent from the definition. So when you "move" an agent, what shows up on the other side is a set of instructions with **no memory, no credentials, no trust relationships, and no context**. A system with the right instructions and none of the experience. Teams that discover this mid-migration watch a system that had been reliably handling edge cases for months suddenly behave like day one. Every learned adaptation, gone. Every session, a blank slate. One framework's creators described the result plainly: > "It's a new hire every morning." ## Containers learned this the hard way The container ecosystem went through the same recognition. Docker's original design assumed statelessness. Define the image, spin it up anywhere, destroy it when done. Then people tried to run [real applications](https://nirmata.com/2016/09/05/containerizing-stateful-applications/). The industry spent years building StatefulSets, PersistentVolumes, and a whole taxonomy of state-management primitives because it turned out that all applications have state. State always existed; the design choices were about who managed it and where it lived. When a stateful container crashed and restarted without state awareness, users had to re-authenticate from scratch. The application was technically identical, and it didn't matter. The session was gone. ## The blueprint and the building The portability tools are drawing a clean, visible line between what they can carry and what they can't. That line is useful. An agent's authored logic is a starting point. The situated context it builds through operation, the memory, authorization, trust, behavioral adaptation, is what makes a working agent *that particular agent*. And those are the things that don't serialize. The ecosystem is investing heavily in making the portable parts more portable. Memory systems and authorization state, meanwhile, are being built in parallel with no connective tissue between them. Nobody is working on the problem of porting what an agent has become. The container world eventually built infrastructure to treat state as a first-class concern. The agent portability tools are quietly demonstrating something similar: agents accumulate identity through operation. The export file captures the blueprint. The agent is the building, its tenants, and every pipe that's been rerouted since opening day. ## Things to follow up on... - **MCP's enterprise readiness gaps:** The [2026 MCP roadmap](https://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/) names auth, audit trails, and configuration portability as top priorities, but the Enterprise Working Group to define that work doesn't yet exist. - **Memory without version control:** A comparison of five major agent memory systems found that Mem0, Zep, and Letta all [lack version control for accumulated memories](https://dev.to/varun_pratapbhardwaj_b13/5-ai-agent-memory-systems-compared-mem0-zep-letta-supermemory-superlocalmemory-2026-benchmark-59p3), meaning there's no way to diff, revert, or audit what an agent has learned over time. - **Agent sprawl compounds the problem:** A Salesforce/MuleSoft survey of 1,050 IT leaders found that [50% of enterprise agents already operate in isolated silos](https://www.salesforce.com/news/stories/connectivity-report-announcement-2026/), with the average organization running 12 agents and projecting 67% growth within two years. - **AutoGen's deprecation as migration test:** Microsoft merged AutoGen into its unified Agent Framework with [1.0 GA targeted for Q1 2026](https://futureagi.substack.com/p/top-5-agentic-ai-frameworks-to-watch), creating a live experiment in what survives a vendor-supported framework migration and what doesn't. ## More - [Foundations — Issue 22]() - [Issue 22]() - [Publication guide]()