GitAgent proposes a single AI agent format for LangChain, AutoGen and Claude Code

GitAgent has been introduced as an open-source format for AI agents meant to remove dependence on a specific framework. The idea is to describe an agent in a Git repository once, then export it to LangChain, AutoGen, Claude Code, OpenAI Assistants and CrewAI without rewriting the core logic.

Why the market is fragmented

AI agent developers currently live in a world of incompatible stacks. LangChain, AutoGen, CrewAI, OpenAI Assistants and Claude Code each define an agent's role, store memory, connect tools and manage task execution differently. In practice this creates a simple but expensive problem: once a team picks a stack, migrating to another almost always means rewriting the system from scratch or building a complicated layer of workarounds on top of the old code.

GitAgent tries to move the agent's "personality" and structure out of a specific runtime into a separate layer. Instead of keeping instructions, rules, memory and skills inside a single framework, the project proposes collecting them in a standardized file structure inside a Git repository. The authors explicitly compare this approach to Docker: first you describe the entity in a common format, and only then decide where and how to run it.

How GitAgent works

GitAgent is built not on a new orchestration engine but on a file specification and a CLI. An agent is described as a directory of human-readable files, each responsible for a separate layer of behavior. This should simplify maintenance, teamwork, change auditing and portability between tools.

• agent.yaml — the main manifest with the model, versions, dependencies and environment configuration
• SOUL.md — the agent's identity: role, tone, style and basic instructions
• DUTIES.md — duties and constraints, including separation of roles
• skills/ and tools/ — the skills and tools the agent uses to take actions
• memory/ — memory in readable files such as context.md and dailylog.md

The key idea is that the agent's state is no longer hidden in a library's internal format or an opaque database. If an agent updates its memory, changes its rules or gains a new skill, those changes can be viewed as an ordinary diff in Git. The team gets familiar development mechanics: branches, pull requests, review, edit history and a quick rollback with git revert if behavior goes astray or the agent starts drifting from its original role.

Export and control

GitAgent's main practical feature is the export command, which converts the same specification into the format of the target ecosystem. The article covers five targets: OpenAI Assistants, Claude Code, LangChain or LangGraph, CrewAI and AutoGen. In theory, a developer can keep the agent's business logic and change only the execution layer for a given task, instead of rewriting memory, instructions and tools separately for each stack.

This addresses more than vendor lock-in; it also makes experimentation easier. The same agent can first be tested in a coding environment, then moved into multi-agent orchestration, then connected to a production scenario with a different set of tools. For teams that switch stacks often or work with several platforms at once, this may noticeably lower the cost of iteration and speed up hypothesis testing.

There is a separate emphasis on compliance for regulated industries. GitAgent supports a Segregation of Duties model that lets teams explicitly separate the maker, checker and executor roles. Before deployment, the validate command is supposed to check whether a single agent has been given too much authority. This matters especially in financial and legal scenarios, where the same actor must not both initiate and confirm a critical action without an additional check.

What this means

GitAgent targets a real pain point: AI agents are evolving fast, but every framework pulls developers toward its own closed description model. If the project manages to establish itself as a neutral format across different stacks, teams will get more portable, verifiable and manageable agents — much as containers once simplified moving applications between environments.