GitAgentProtocol (OpenGAP) — Summary

OpenGAP (the Git Agent Protocol) is a framework-agnostic, git-native standard for defining AI agents. A repository becomes an agent: agent.yaml (manifest) + SOUL.md (identity) are the minimum required files, with optional RULES.md, DUTIES.md, skills/, tools/, memory/, workflows/, hooks/, compliance/, and agents/ (sub-agents). The reference CLI (opengap, npm package @open-gitagent/opengap) validates agent manifests, exports to 12+ framework formats (Claude Code, Cursor, Codex, CrewAI, LangChain, Kiro, etc.), and manages registry operations. Built-in compliance support for FINRA, Federal Reserve, and SEC with segregation-of-duties enforcement in agent.yaml.

Compared to seeds: OpenGAP is closest in philosophy to agent-os (git-native, markdown-first agent definitions) and BMAD-METHOD (persona files + skills structure) but is more comprehensive — it defines a portable interoperability standard rather than a single framework's file layout. Unlike all seeds which target a specific coding tool, OpenGAP explicitly exports to any framework via adapters. The compliance infrastructure (SOD conflict matrix, FINRA/SEC regulatory mapping) is unique in the corpus.

GitAgentProtocol (OpenGAP) — Overview

Origin

Published as @open-gitagent/opengap on npm (previously @open-gitagent/gapman, originally gitagent). TypeScript/Node.js. MIT license. 2,790 stars, 336 forks. Spec v0.1.0.

Philosophy

"Your repository becomes your agent. Clone a repo, get an agent."

OpenGAP's thesis: every AI framework has its own structure (CLAUDE.md, AGENTS.md, .cursor/rules, etc.). This creates fragmentation — an agent defined for Claude Code doesn't work in CrewAI. OpenGAP proposes a neutral, git-native format that exports to any framework via adapters.

Design Goals

1. Framework-agnostic: Works with Claude Code, OpenAI Codex, LangChain, CrewAI, AutoGen, and more
2. Git-native: Version control, branching, diffing, and collaboration are first-class
3. Compliance-ready: First-class support for FINRA, Federal Reserve, SEC, and segregation of duties
4. Composable: Agents can extend, depend on, and delegate to other agents

Architectural Metaphor

"Agent Versioning" — treating agent definitions exactly like software: commits, branches, releases, forks, PRs. The audit trail for every agent decision is the git log.

Key Patterns

From README (illustrated with architecture diagrams):

• Human-in-the-Loop for RL Agents: PR-based skill/memory changes requiring human review before merge
• Segregation of Duties: Conflict matrix enforcement across agent roles
• Branch-based Deployment: dev → staging → main for agent changes
• CI/CD for Agents: opengap validate on every push via GitHub Actions
• Agent Forking: Open-source collaboration for AI agent definitions

Compliance Focus

OpenGAP is the only framework in the corpus with explicit FINRA, Federal Reserve, and SEC compliance patterns. The compliance/ directory and agent.yaml segregation-of-duties schema are designed for financial services.

GitAgentProtocol (OpenGAP) — Architecture

Distribution

npm: npm install -g @open-gitagent/opengap Binary aliases: opengap and gitagent (backward compatibility)

Standard File Structure

my-agent/
├── agent.yaml              # [REQUIRED] Agent manifest (AJV-validated schema)
├── SOUL.md                 # [REQUIRED] Identity and personality
├── RULES.md                # Hard constraints and boundaries
├── DUTIES.md               # Segregation of duties policy and role declaration
├── AGENTS.md               # Framework-agnostic fallback instructions
├── skills/                 # Reusable capability modules
│   └── <skill>/
│       ├── SKILL.md        # Frontmatter + instructions
│       └── scripts/
├── tools/                  # MCP-compatible tool definitions (YAML schemas)
├── knowledge/              # Reference documents
│   └── index.yaml          # Retrieval hints
├── memory/
│   ├── MEMORY.md           # Current state (200 line max)
│   ├── memory.yaml         # Config
│   └── archive/            # Historical snapshots
├── workflows/              # YAML workflows (SkillsFlow)
├── hooks/
│   ├── hooks.yaml
│   └── scripts/
├── examples/               # Few-shot calibration
├── agents/                 # Sub-agent definitions (recursive)
└── compliance/
    ├── regulatory-map.yaml     # Rule-to-control mappings
    ├── audit-log.schema.json   # Audit log format
    └── risk-assessment.md

CLI Source Structure

src/
  commands/       # CLI command implementations
  adapters/       # Framework export adapters
  runners/        # Execution runners
  utils/          # Schema loading, formatting

Adapters (12 framework targets)

adapters/
  claude-code.ts, codex.ts, copilot.ts, crewai.ts, cursor.ts
  gemini.ts, github.ts, kiro.ts, langchain4j.ts, lyzr.ts
  nanobot.ts, openai.ts, openclaw.ts, opencode.ts, system-prompt.ts

Registry

registry/         # Public agent registry
registry-landing/ # Registry website

Required Runtime

• Node.js ≥ 18
• npm

Validation

AJV (JSON Schema validator) validates agent.yaml against the OpenGAP schema. Format validation via ajv-formats.

GitAgentProtocol (OpenGAP) — Components

CLI Commands

agent.yaml Schema (Key Fields)

name: loan-originator
version: "1.0.0"
description: "Processes loan applications"
spec_version: "0.1.0"
model:
  preferred: "claude-opus-4-6"
  fallback: ["gpt-4o", "gemini-pro"]
  constraints:
    temperature: 0.3
skills: [credit-check, document-review]
tools: [loan-db, kyc-verifier]

compliance:
  segregation_of_duties:
    roles:
      - id: maker
        description: Creates proposals
        permissions: [create, submit]
      - id: checker
        description: Reviews and approves
        permissions: [review, approve, reject]
    conflicts:
      - [maker, checker]    # maker cannot approve own work
    assignments:
      loan-originator: [maker]
      credit-reviewer: [checker]
    enforcement: strict

Framework Adapters (12 targets)

SkillsFlow Workflows

YAML-defined deterministic multi-step workflows:

name: code-review-flow
steps:
  lint:
    skill: static-analysis
  review:
    agent: code-reviewer
    depends_on: [lint]
  test:
    tool: bash
    depends_on: [lint]
  report:
    skill: review-summary
    depends_on: [review, test]

Supports: skill:, agent:, tool: step types; depends_on DAG ordering; ${{ }} template variables; per-step prompt: overrides.

Compliance Module

Memory System

• memory/MEMORY.md — rolling current state (hard limit: 200 lines)
• memory/archive/ — historical snapshots when MEMORY.md rolls over
• memory/runtime/ — live agent state: dailylog.md, key-decisions.md, context.md

GitAgentProtocol (OpenGAP) — Uniqueness

Differentiator

OpenGAP is the only framework in the corpus that treats a git repository as the complete, portable, version-controlled definition of an AI agent — not as a storage mechanism for an agent, but as the agent itself. The thesis "clone a repo, get an agent" has no equivalent in any seed or peer framework.

Differs from Seeds

Against the five seed archetypes and 11 seed frameworks:

vs. Skills-only behavioral (superpowers, spec-kit): Seeds define skills inside a single tool's directory (.claude/skills/). OpenGAP defines skills in a framework-neutral structure and exports them to any tool via adapters. The seed skills only work in Claude Code; OpenGAP skills work in 12 frameworks.

vs. Mirror commands+skills (claude-conductor, claude-flow, openspec): These frameworks coordinate Claude Code instances but remain Claude-Code-specific. OpenGAP's coordination (SkillsFlow) is framework-agnostic — it can route steps to Claude Code, CrewAI, OpenAI, or any adapter target.

vs. MCP-anchored toolserver (spec-driver, ccmemory): Seeds add tools to an existing agent. OpenGAP defines the agent, its tools, its memory, its roles, and its compliance rules — then exports the whole package to any runtime.

vs. Markdown scaffold (BMAD-METHOD, taskmaster-ai, agent-os, kiro): These use markdown for human-authored agent behavior. OpenGAP uses agent.yaml with AJV schema validation — the manifest is machine-validated, not just human-readable.

vs. Closed IDE with proprietary primitives (kiro): Kiro's .kiro/ structure is proprietary. OpenGAP explicitly exports TO kiro format (opengap export --adapter kiro), treating Kiro as one of many deployment targets rather than the defining format.

Git-as-Audit-Trail

Every other framework in this batch (contextforge, archestra, agentgateway, atmosphere, parlant, plano) implements audit logging via a database (PostgreSQL, SQLite) or external system (OTEL, Prometheus). OpenGAP's audit trail is the git commit history:

• Every agent state change = one git commit
• git log --oneline -- memory/MEMORY.md = complete memory change history
• git diff v1.0.0 v1.1.0 -- RULES.md = what rules changed between versions
• PR review = human approval gate before any skill/memory change takes effect

This is not a workaround — it is the design. For regulated industries, git provides a tamper-evident, cryptographically signed, human-readable audit log without any additional infrastructure.

SOD Compliance as First-Class Primitive

No other framework in the corpus (batch or seeds) implements Segregation of Duties at the schema level. OpenGAP's agent.yaml has a compliance.segregation_of_duties block with:

• Named roles with explicit permissions
• Conflict matrix ([[maker, checker]] = these roles cannot be held by the same agent)
• enforcement: strict → opengap validate fails if violations exist
• FINRA/Federal Reserve/SEC domain specificity in examples

The combination of machine-validated SOD in agent.yaml + human-readable DUTIES.md + CI/CD blocking creates a compliance loop found nowhere else in the corpus.

Branch-Based Deployment

OpenGAP applies git branching semantics to agent deployment:

feature/add-credit-check → dev → staging → main (production)

Each branch = one deployment environment. Agent behavior in production is exactly the tagged release. Rollback = git revert. Hotfix = standard git hotfix workflow. No other framework maps deployment environments to git branches.

Framework Adapter Network Effect

With 12 export adapters (claude-code, codex, copilot, cursor, crewai, gemini, github, kiro, lyzr, nanobot, openai, system-prompt), OpenGAP positions itself as the universal agent format. An organization can define one agent and deploy it across all platforms. This adapter network has no equivalent in any other framework in this corpus.

What It Does Not Do

• No web dashboard or runtime UI
• No built-in LLM gateway or request routing
• No model cost optimization
• No vector database or RAG pipeline
• No real-time observability (OTEL, Prometheus) — only git history
• No prompt injection defenses beyond human-authored RULES.md

OpenGAP is a definition and compliance standard, not a runtime execution engine. Frameworks like agentgateway, plano, and contextforge handle runtime concerns; OpenGAP handles agent identity, versioning, and governance.