Every AI agent framework defines agents differently, and switching frameworks means rewriting everything. OpenGAP, short for Git Agent Protocol, answers with a simple idea: the agent is the repo. Define your agent as plain files in a git repository, and one definition can be exported to Claude Code, the OpenAI Agents SDK, CrewAI, and more. The standard and its reference CLI live in a single repository, open-gitagent/opengap on GitHub: MIT-licensed, written in TypeScript, with 2,981 stars and 354 forks.
Key Takeaways
OpenGAP is an open standard for portable AI agents: an agent is a set of files in a git repository, and cloning the repo gives you the complete agent.
Only two files are required, `agent.yaml` (the manifest) and `SOUL.md` (the identity). Everything else, rules, duties, skills, tools, memory, is optional.
The reference CLI, published on npm as `@open-gitagent/opengap` (latest release 0.5.0), validates, runs, imports, and exports agents across 16 adapters.
Compliance is built in, not bolted on: segregation of duties, FINRA and Federal Reserve mappings, and a dedicated audit command.
OpenGAP is not the same project as GitAgent, a separate framework repo from the same organization. The naming history is explained below.
The Standard: Your Repository Becomes Your Agent
OpenGAP defines an agent as a directory of human-readable files inside a git repository. The specification document lives in the repo at `spec/SPECIFICATION.md` (currently v0.1.0), with JSON Schemas for validation alongside it. Only two files are required:
File | Purpose |
|---|---|
`agent.yaml` | The manifest: name, version, model, skills, tools, compliance |
`SOUL.md` | Identity, personality, communication style, values |
Around them sits an optional structure that covers the full life of an agent:
`RULES.md` for hard constraints and safety boundaries, and `DUTIES.md` for segregation-of-duties policy.
`skills/` for reusable capability modules, `tools/` for MCP-compatible tool definitions in YAML, and `workflows/` for multi-step playbooks.
`knowledge/` for reference documents and `memory/` for persistent cross-session memory, including a `runtime/` folder where the agent writes live state such as daily logs and context notes.
`hooks/` for lifecycle handlers, `compliance/` for regulatory artifacts, and `agents/` for sub-agents that recursively follow the same structure.
Because everything is a file, every standard git operation applies. `git diff` shows exactly what changed in an agent's behavior, `git blame` traces who wrote each line, and `git revert` rolls back a bad prompt the way you would revert a bad commit.
Patterns That Fall Out of Git
Treating the repo as the agent produces a set of patterns the project documents in detail:
Human-in-the-loop review. When an agent learns a new skill or writes to memory, it opens a branch and a pull request for human review before merging.
Branch-based deployment. Promote agent changes through `dev`, `staging`, and `main`, tag stable releases like `v1.1.0`, and pin production to a tag.
CI/CD for agents. Run `opengap validate` in GitHub Actions on every push, block bad merges, and treat agent quality like code quality.
Forking and remixing. Fork any public agent repo, customize its `SOUL.md`, add skills, and send improvements back upstream.
Shared context in a monorepo. Root-level skills, tools, and context files are shared automatically across every agent in the repository.
Secrets stay local. Tools read API keys from a local `.env` file kept out of version control, so agent definitions stay shareable.
Workflows get their own deterministic format, SkillsFlow: YAML files in `workflows/` that chain skill, agent, and tool steps with explicit dependencies and template data flow, so a multi-step process follows the same path on every run.
Compliance Is a First-Class Citizen
Most agent standards ignore regulated industries. OpenGAP was clearly built with them in mind. Its segregation-of-duties model lets you define roles such as maker, checker, executor, and auditor in `agent.yaml` and `DUTIES.md`, declare a conflict matrix (a maker cannot approve its own work), and require multi-agent handoffs for critical actions. The validator catches violations before deployment, and enforcement can be strict or advisory.
The compliance layer maps to real financial regulation: FINRA Rules 3110 (supervision), 4511 (recordkeeping), and 2210 (communications), Federal Reserve guidance SR 11-7 on model risk management and SR 23-4 on third-party risk, SEC Regulation S-P on customer privacy, and CFPB Circular 2022-03 on explainable adverse action. Running `opengap audit` generates a compliance report against your agent configuration. The design credits inspiration from Salient AI's agent architecture and the FINOS AI Governance Framework.
Write Once, Run Anywhere: 16 Adapters
The payoff of the file-based model is portability. The reference CLI ships with 16 adapters used for both export and run: system-prompt (a concatenated prompt that works with any LLM), Claude Code, OpenAI Agents SDK, CrewAI, Lyzr, GitHub Models, OpenCode, Google Gemini CLI, OpenClaw, Nanobot, Cursor, and GitClaw, plus export-only targets for GitHub Copilot, OpenAI Codex, and Kiro, and a git-native execution adapter for running agents directly from a repo.
The CLI works in both directions. `opengap import` converts existing agents from Claude, Cursor, CrewAI, and OpenCode into the OpenGAP format. Agents can also extend a parent agent hosted in any git repository, or declare versioned dependencies on other agents that are mounted in as sub-agents, so teams can compose agents the way they compose libraries.
Try It in Five Minutes
You will need Node.js 18 or newer and git (GitHub, retrieved 2026-10-22).
Install the CLI globally with npm: `npm i -g @open-gitagent/opengap`. Then scaffold a new agent with `opengap init --template standard` (templates: minimal, standard, full, llm-wiki), check it with `opengap validate`, inspect it with `opengap info`, and export it anywhere with a command such as `opengap export --format system-prompt`. The repo's `examples/` folder includes a two-file minimal agent, a standard code-review agent, and a full production compliance agent to learn from, plus a worked example that ports NVIDIA's AIQ Deep Researcher, originally built across config files and Python code, into the portable format.
OpenGAP or GitAgent? A Necessary Clarification
The names around this project are genuinely confusing, so here is the map. The standard began under the name gitagent: the specification document in this repository is still titled "gitagent Specification v0.1.0". The CLI was originally published on npm as `@open-gitagent/gitagent`, then renamed to `@open-gitagent/gapman`, and is now `@open-gitagent/opengap`. The `gitagent` command is still installed as an alias, so both `opengap validate` and `gitagent validate` work.
Separately, the same organization (the open-gitagent org, led by contributors from Lyzr, including GitHub users shreyas-lyzr and patel-lyzr) also maintains open-gitagent/gitagent, a distinct and actively developed git-native agent framework with 720 stars that is built around the same agent-as-files idea. It is a sibling project, not the standard itself, and its README does not define OpenGAP. This article is about the standard and its reference CLI in the opengap repository, which is also the repository featured in the RepoManiac video linked below.
One honest caveat on activity: the opengap repository was created on 2026-02-24 and its most recent push was 2026-07-02, the same day CLI version 0.5.0 was published to npm (GitHub API, retrieved 2026-10-22). The standard is stable rather than fast-moving right now, while the sibling GitAgent framework repo sees more frequent commits.
Where It Fits (and Where It Does Not)
OpenGAP fits teams that maintain agents across more than one framework, organizations in regulated industries that need audit trails and segregation of duties, and open-source projects that want to ship reusable agent definitions others can fork. It fits less well if your agent is a single throwaway prompt inside one app, where the manifest, duties, and workflow files add more structure than the use case earns. And as with any young standard, the adapters are only as good as their coverage of each target framework, so test the export for your stack before committing.
Frequently Asked Questions
Is OpenGAP the same thing as GitAgent?
Not exactly. OpenGAP is the open standard (the Git Agent Protocol) plus its reference CLI, maintained in the open-gitagent/opengap repository. The project began under the gitagent name, and the `gitagent` command survives as a CLI alias. A separate repository, open-gitagent/gitagent, is a different agent framework from the same organization.
Which frameworks can an OpenGAP agent export to?
The CLI lists 16 adapters, including Claude Code, the OpenAI Agents SDK, CrewAI, Cursor, Google Gemini CLI, OpenCode, OpenClaw, and a universal system-prompt export that works with any LLM.
What license does OpenGAP use?
MIT. The standard, the CLI, and the specification are fully open source at github.com/open-gitagent/opengap (GitHub API, retrieved 2026-10-22).
What does OpenGAP cost?
The project itself is free and open source. You still pay your LLM provider for the model calls your agent makes, the same as any other agent framework.
Sources
GitHub repository: open-gitagent/opengap
Specification: spec/SPECIFICATION.md
GitHub API: repo data
Official site: gitagent.sh
Sibling project: open-gitagent/gitagent
---
Watch the 30-second repo signal that surfaced this project, or browse more repo signals for quick video overviews of trending open-source projects.
Read this article in Bahasa Indonesia: OpenGAP: Ubah Repo Git Kamu Menjadi AI Agent yang Portabel.