> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lyzr.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# GitAgent

> The open-source git-native AI agent framework. Define agents in your repo, run them anywhere.

GitAgent is an open-source framework for building AI agents that live in your git repository. Agents are defined as code, versioned with your project, and executed via a local runtime or CI pipeline — no separate deployment infrastructure required.

GitAgent was originally called GitClaw. It has been renamed to reflect its core design: agents that are native to git workflows, not bolted on top of them.

## What makes GitAgent different

Most agent frameworks treat git as a deployment mechanism — you write code, push it, and the framework picks it up. GitAgent inverts this: **the agent's definition is the repository**. Skills, hooks, memory, and tools are all discovered by walking the repo tree according to the OpenGAP directory convention.

This means:

* **No agent configuration UI** — the repo is the source of truth
* **Agent diffs are code diffs** — reviewing an agent change is reviewing a PR
* **Any CI system can run it** — `gitagent run` works in GitHub Actions, GitLab CI, Jenkins, or locally

## Core concepts

| Concept            | Description                                                                       |
| ------------------ | --------------------------------------------------------------------------------- |
| **Agent manifest** | `agent.yaml` in the repo root — defines identity, model, and entrypoint           |
| **Skills**         | Individual capabilities the agent can invoke (tools, knowledge, sub-agents)       |
| **Hooks**          | Lifecycle callbacks — before/after each skill call, on error, on completion       |
| **Plugins**        | Extend the runtime — add new skill types, output processors, auth providers       |
| **SkillsFlow**     | Compose skills into multi-step workflows with branching and loops                 |
| **Memory**         | Persistent memory that survives across runs (conversation history, learned facts) |

## How it works

```
repo/
├── agent.yaml              ← agent manifest
├── skills/
│   ├── search_web.py       ← a skill
│   ├── read_file.py        ← a skill
│   └── summarize.py        ← a skill
├── hooks/
│   └── on_complete.py      ← lifecycle hook
└── flows/
    └── research_flow.yaml  ← a SkillsFlow
```

When you run `gitagent run`, the runtime:

1. Reads `agent.yaml` to get the agent's identity and model
2. Discovers all skills in `skills/`
3. Loads hooks from `hooks/`
4. Starts a conversation loop — the LLM decides which skills to call

## When to use GitAgent

**Good fit:**

* Agents that need to be version-controlled and code-reviewed
* Teams that want agents as part of their existing git workflows
* Agents that run on a schedule in CI (nightly analysis, weekly reports)
* Self-hosted environments where cloud agent platforms aren't an option

**Consider alternatives:**

* If you need a visual no-code agent builder → [Lyzr Studio](https://studio.lyzr.ai)
* If you need multi-agent orchestration at scale → [SuperFlow](../../enterprise/agent-studio/superflow/overview)

## Relationship to OpenGAP

GitAgent implements the [OpenGAP](../opengap/overview) specification. OpenGAP defines the directory structure, manifest format, and skill protocol that any compliant runtime must support. GitAgent is the reference implementation.

This means agents you build with GitAgent are portable: any OpenGAP-compatible runtime can execute them.

## Where to go next

* [Quickstart](./quickstart) — build and run your first GitAgent in 5 minutes
* [Installation](./installation) — install options and system requirements
* [Agent Structure](./agent-structure) — directory layout and manifest format
* [Skills](./skills) — how to write skills
* [SkillsFlow](./skillsflow) — composing multi-step skill workflows