  Hey HN,

  We built GitAgent — a git-native, framework-agnostic open standard
  for
  defining AI agents. The idea is simple: your repo IS the agent.

      npx @open-gitagent/gitagent@latest run -r
  https://github.com/shreyas-lyzr/architect -a claude

  That one command clones the repo, reads agent.yaml + SOUL.md +
  skills/,
  and launches it with Claude Code. Switch `-a openai` or `-a lyzr`
  to run
  the same agent on a different framework. No code changes. 

  
 
  Goal: is keep the gitagent as a open standard ledger for an AI Agent in a VM, with versioned memories,   skills etc.

  An agent is just files:

      my-agent/
      ├── agent.yaml      # config: model, skills, tools
      ├── SOUL.md         # identity, personality, expertise
      ├── RULES.md        # boundaries, constraints
      ├── skills/         # capabilities
      ├── knowledge/      # reference docs
      └── memory/         # persistent context

  Why Git? Because agents need the same things code needs —
  versioning,
  branching, diffing, code review, and collaboration. We already have

  the best tool for that.

  What we've built:
  - CLI that validates, exports, imports, and runs agents
  - 8 adapters: Claude Code, OpenAI, CrewAI, OpenClaw, Nanobot, Lyzr,
   GitHub Models
  - Public registry at registry.gitagent.sh — browse and share agents
  - Compliance framework (FINRA, SEC, Fed) — audit logging,
  human-in-the-loop, kill switches

  Try it: https://gitagent.sh
  Registry: https://registry.gitagent.sh  
  GitHub: https://github.com/open-gitagent/gitagent
  Discord: https://discord.gg/hVZV8Xyjdc
  
  Patterns
  1. Human-in-the-Loop — Agents create a branch and PR for human review before updating memory or skills.

  2. Live Agent Memory — memory/runtime/ stores dailylog.md, key-decisions.md, and context.md to persist state across sessions.

  3. Agent Versioning — Every agent change is a git commit. Roll back broken prompts or revert bad skills      anytime.

  4. Shared Context via Monorepo — Root-level context.md, skills/, tools/, and knowledge/ are inherited by all agents automatically.

  5. Branch-based Deployment — Promote agent changes through dev → staging → main, just like shipping  software.

  6. Knowledge Tree — knowledge/ folder stores entity relationships as a directory tree with embeddings for structured reasoning.

  7. Agent Forking & Remixing — Fork a public agent repo, customize SOUL.md, add skills, and PR improvements back upstream.

CI/CD for Agents — Run gitagent validate on every push via GitHub Actions. Test, block bad merges, auto-deploy.

  8. Agent Diff & Audit Trail — git diff shows what changed; git blame traces every line to who wrote it and when.

Tagged Releases — Tag stable versions like v1.1.0. Pin production to a tag, canary on staging, roll back instantly.

  9. Secret Management — Agent config is version-controlled; API keys stay in .env excluded via .gitignore.

  10. Lifecycle Hooks — hooks/bootstrap.md and hooks/teardown.md define what an agent does on startup and shutdown.
 
  11. Git-Native — Version control, branching, diffing, and collaboration are built in.
  
  12. Framework-Agnostic — Works with Claude Code, OpenAI, CrewAI, LangChain, and more.
  
  13. Compliance-Ready — First-class FINRA, SEC, and Federal Reserve support with audit logging and supervision.

  14. Composable — Skills, tools, sub-agents, and workflows can extend, depend on, and delegate to each other.

MIT licensed. Would love feedback.