Docker worked because it found the right cut. The boundary between what an application needs and what infrastructure provides turned out to be clean enough that you could package one side and let the environment handle the other. That cut leaks sometimes — CPU architecture bleeds through, networking assumptions break — but it was fundamentally correct. Millions of deployments later, it still holds.

GitAgent, an open-source project that launched this month and quickly drew the "Docker for AI agents" comparison, is making a specific bet about where an equivalent seam sits for agents. Its own documentation is unusually honest about what crosses that boundary and what doesn't, which makes it more interesting to examine than most portability claims.

A GitAgent agent lives in a git repo as flat files: a YAML manifest, Markdown documents for personality and constraints, folders for skills and MCP-compatible tool schemas, and a memory/ directory of Markdown files. Run gitagent export and the CLI maps this definition onto LangChain, CrewAI, AutoGen, Claude Code, or OpenAI's Assistants API. The README states plainly what ports: system prompts, persona definitions, constraints, tool schemas, model preferences. And what stays behind: runtime orchestration, live tool execution, memory I/O, iterative loops. Identity travels. Execution stays where it is.

The memory/ directory is where things get concrete. Storing agent state as Markdown means it's searchable, diffable, and reversible with git revert. As an audit artifact, genuinely useful. But the creator acknowledged on Product Hunt:

And the target frameworks handle memory in structurally incompatible ways. LangGraph maintains a central state object with checkpointing and reducer logic. CrewAI persists state through task outputs. AutoGen is conversational and event-driven. OpenAI uses vector stores and durable threads. Claude Code accumulates learnings through its own memory system. A Markdown file can snapshot what an agent knew, but how an agent retrieves, updates, or reasons over that knowledge at runtime lives entirely outside the file's reach.

Orchestration runs into the same friction. LangGraph models workflows as directed graphs with conditional branching. CrewAI uses a two-layer architecture of Crews and Flows. AutoGen prefers conversational orchestration. Practitioners report that even the most common migration path, CrewAI to LangGraph, requires remapping agents to graph nodes and converting process flows to explicit edges. That structural transformation resists packaging into a manifest.

GitAgent can create a branch and pull request when an agent updates its memory or acquires a new skill. This is cleverer than it first appears. Organizations already have muscle memory for code review. Developers know how to read diffs, comment on changes, approve or reject. Repurposing that existing workflow for agent oversight means no new dashboard to learn, no unfamiliar approval interface. Identity review through diffs works well here. Execution behavior is harder to capture this way. Outcomes emerge from the interaction between orchestration logic, live memory, and tool-calling patterns, and a diff of Markdown files shows the shadow of what changed.

So what doesn't survive the trip across frameworks? These frameworks implement execution differently because they start from different theories about what agent cognition looks like: graph traversal in LangGraph, role delegation in CrewAI, conversational reasoning in AutoGen. The ecosystem may not converge on those questions. It might be a genuine plurality, five different answers to what thinking looks like when software does it.

GitAgent found a real seam. Whether it holds as agents grow more stateful, as the distance between what an agent knows and how it acts on that knowledge widens, is something the tool's own architecture makes visible, even if it can't resolve it yet.