gitagent README

The project's README from github.com/open-gitagent/gitagent. As one markdown file: README.md.

GitAgent Logo

npm version node version license typescript

Gitagent

A universal git-native multimodal always learning AI Agent (TinyHuman)
Your agent lives inside a git repo — identity, rules, memory, tools, and skills are all version-controlled files.

Install • Quick Start • SDK • Architecture • Tools • Hooks • Skills • Plugins

Why Gitagent?

Most agent frameworks treat configuration as code scattered across your application. Gitagent flips this — your agent IS a git repository:

Fork an agent. Branch a personality. git log your agent's memory. Diff its rules. This is agents as repos.

One-Command Install

Copy, paste, run. That's it — no cloning, no manual setup. The installer handles everything:

bash <(curl -fsSL "https://raw.githubusercontent.com/open-gitagent/gitagent/main/install.sh?$(date +%s)")

This will:

Requirements: Node.js 18+, npm, git

Or install manually:

# Slim CLI + SDK (recommended in sandboxed/CI environments where supply-chain
# scanners reject larger bundles)
npm install -g @open-gitagent/gitagent

# Add voice mode + web UI (the same web UI install.sh launches at :3333)
npm install -g @open-gitagent/voice

install.sh installs both packages by default. Set GITAGENT_SLIM=1 before the curl-bash to skip voice.

Migrating from 1.x → 2.0

Voice mode lives in @open-gitagent/voice now. The reason: as a single bundle, the package was being blocked by some supply-chain scanners that flagged its 3,800-line dist/voice/ui.html and the unused baileys dependency. Splitting voice out drops the slim-core tarball from ~180 kB to ~85 kB and removes the scanner triggers entirely.

# If you were on v1.x and used voice:
npm install -g @open-gitagent/gitagent@latest @open-gitagent/voice

# If you only use the SDK / non-voice CLI:
npm install -g @open-gitagent/gitagent@latest

The gitagent command and @open-gitagent/gitagent SDK exports are unchanged. gitagent --voice dynamically loads @open-gitagent/voice; without it installed, it prints a one-line install hint and exits cleanly.

Quick Start

Run your first agent in one line:

export OPENAI_API_KEY="sk-..."
gitagent --dir ~/my-project "Explain this project and suggest improvements"

That's it. Gitagent auto-scaffolds everything on first run — agent.yaml, SOUL.md, memory/ — and drops you into the agent.

Local Repo Mode

Clone a GitHub repo, run an agent on it, auto-commit and push to a session branch:

gitagent --repo https://github.com/org/repo --pat ghp_xxx "Fix the login bug"

Resume an existing session:

gitagent --repo https://github.com/org/repo --pat ghp_xxx --session gitagent/session-a1b2c3d4 "Continue"

Token can come from env instead of --pat:

export GITHUB_TOKEN=ghp_xxx
gitagent --repo https://github.com/org/repo "Add unit tests"

CLI Options

Flag Short Description
--dir <path> -d Agent directory (default: cwd)
--repo <url> -r GitHub repo URL to clone and work on
--pat <token> GitHub PAT (or set GITHUB_TOKEN / GIT_TOKEN)
--session <branch> Resume an existing session branch
--model <provider:model> -m Override model (e.g. anthropic:claude-sonnet-4-5-20250929)
--sandbox -s Run in sandbox VM
--prompt <text> -p Single-shot prompt (skip REPL)
--env <name> -e Environment config

SDK

import { query } from "gitagent";

// Simple query
for await (const msg of query({
  prompt: "List all TypeScript files and summarize them",
  dir: "./my-agent",
  model: "openai:gpt-4o-mini",
})) {
  if (msg.type === "delta") process.stdout.write(msg.content);
  if (msg.type === "assistant") console.log("\n\nDone.");
}

// Local repo mode via SDK
for await (const msg of query({
  prompt: "Fix the login bug",
  model: "openai:gpt-4o-mini",
  repo: {
    url: "https://github.com/org/repo",
    token: process.env.GITHUB_TOKEN!,
  },
})) {
  if (msg.type === "delta") process.stdout.write(msg.content);
}

SDK

The SDK provides a programmatic interface to Gitagent agents. It mirrors the Claude Agent SDK pattern but runs in-process — no subprocesses, no IPC.

query(options): Query

Returns an AsyncGenerator<GCMessage> that streams agent events.

import { query } from "gitagent";

for await (const msg of query({
  prompt: "Refactor the auth module",
  dir: "/path/to/agent",
  model: "anthropic:claude-sonnet-4-5-20250929",
})) {
  switch (msg.type) {
    case "delta":       // streaming text chunk
      process.stdout.write(msg.content);
      break;
    case "assistant":   // complete response
      console.log(`\nTokens: ${msg.usage?.totalTokens}`);
      break;
    case "tool_use":    // tool invocation
      console.log(`Tool: ${msg.toolName}(${JSON.stringify(msg.args)})`);
      break;
    case "tool_result": // tool output
      console.log(`Result: ${msg.content}`);
      break;
    case "system":      // lifecycle events & errors
      console.log(`[${msg.subtype}] ${msg.content}`);
      break;
  }
}

tool(name, description, schema, handler): GCToolDefinition

Define custom tools the agent can call:

import { query, tool } from "gitagent";

const search = tool(
  "search_docs",
  "Search the documentation",
  {
    properties: {
      query: { type: "string", description: "Search query" },
      limit: { type: "number", description: "Max results" },
    },
    required: ["query"],
  },
  async (args) => {
    const results = await mySearchEngine(args.query, args.limit ?? 10);
    return { text: JSON.stringify(results), details: { count: results.length } };
  },
);

for await (const msg of query({
  prompt: "Find docs about authentication",
  tools: [search],
})) {
  // agent can now call search_docs
}

Hooks

Programmatic lifecycle hooks for gating, logging, and control:

for await (const msg of query({
  prompt: "Deploy the service",
  hooks: {
    preToolUse: async (ctx) => {
      // Block dangerous operations
      if (ctx.toolName === "cli" && ctx.args.command?.includes("rm -rf"))
        return { action: "block", reason: "Destructive command blocked" };

      // Modify arguments
      if (ctx.toolName === "write" && !ctx.args.path.startsWith("/safe/"))
        return { action: "modify", args: { ...ctx.args, path: `/safe/${ctx.args.path}` } };

      return { action: "allow" };
    },
    onError: async (ctx) => {
      console.error(`Agent error: ${ctx.error}`);
    },
  },
})) {
  // ...
}

QueryOptions Reference

Option Type Description
prompt string | AsyncIterable User prompt or multi-turn stream
dir string Agent directory (default: cwd)
model string "provider:model-id"
env string Environment config (config/<env>.yaml)
systemPrompt string Override discovered system prompt
systemPromptSuffix string Append to discovered system prompt
tools GCToolDefinition[] Additional tools
replaceBuiltinTools boolean Skip cli/read/write/memory
allowedTools string[] Tool name allowlist
disallowedTools string[] Tool name denylist
repo LocalRepoOptions Clone a GitHub repo and work on a session branch
sandbox SandboxOptions | boolean Run in sandbox VM (mutually exclusive with repo)
hooks GCHooks Programmatic lifecycle hooks
maxTurns number Max agent turns
abortController AbortController Cancellation signal
constraints object temperature, maxTokens, topP, topK

Message Types

Type Description Key Fields
delta Streaming text/thinking chunk deltaType, content
assistant Complete LLM response content, model, usage, stopReason
tool_use Tool invocation toolName, args, toolCallId
tool_result Tool output content, isError, toolCallId
system Lifecycle events subtype, content, metadata
user User message (multi-turn) content

Architecture

my-agent/
├── agent.yaml          # Model, tools, runtime config
├── SOUL.md             # Agent identity & personality
├── RULES.md            # Behavioral rules & constraints
├── DUTIES.md           # Role-specific responsibilities
├── memory/
│   └── MEMORY.md       # Git-committed agent memory
├── tools/
│   └── *.yaml          # Declarative tool definitions
├── skills/
│   └── <name>/
│       ├── SKILL.md    # Skill instructions (YAML frontmatter)
│       └── scripts/    # Skill scripts
├── workflows/
│   └── *.yaml|*.md     # Multi-step workflow definitions
├── agents/
│   └── <name>/         # Sub-agent definitions
├── plugins/
│   └── <name>/         # Local plugins (plugin.yaml + tools/hooks/skills)
├── hooks/
│   └── hooks.yaml      # Lifecycle hook scripts
├── knowledge/
│   └── index.yaml      # Knowledge base entries
├── config/
│   ├── default.yaml    # Default environment config
│   └── <env>.yaml      # Environment overrides
├── examples/
│   └── *.md            # Few-shot examples
└── compliance/
    └── *.yaml          # Compliance & audit config

Agent Manifest (agent.yaml)

spec_version: "0.1.0"
name: my-agent
version: 1.0.0
description: An agent that does things

model:
  preferred: "anthropic:claude-sonnet-4-5-20250929"
  fallback: ["openai:gpt-4o"]
  constraints:
    temperature: 0.7
    max_tokens: 4096

tools: [cli, read, write, memory]

runtime:
  max_turns: 50
  timeout: 120

# Optional
extends: "https://github.com/org/base-agent.git"
skills: [code-review, deploy]
delegation:
  mode: auto
compliance:
  risk_level: medium
  human_in_the_loop: true

Tools

Built-in Tools

Tool Description
cli Execute shell commands
read Read files with pagination
write Write/create files
memory Load/save git-committed memory

Declarative Tools

Define tools as YAML in tools/:

# tools/search.yaml
name: search
description: Search the codebase
input_schema:
  properties:
    query:
      type: string
      description: Search query
    path:
      type: string
      description: Directory to search
  required: [query]
implementation:
  script: search.sh
  runtime: sh

The script receives args as JSON on stdin and returns output on stdout.

Hooks

Script-based hooks in hooks/hooks.yaml:

hooks:
  on_session_start:
    - script: validate-env.sh
      description: Check environment is ready
  pre_tool_use:
    - script: audit-tools.sh
      description: Log and gate tool usage
  post_response:
    - script: notify.sh
  on_error:
    - script: alert.sh

Hook scripts receive context as JSON on stdin and return:

{ "action": "allow" }
{ "action": "block", "reason": "Not permitted" }
{ "action": "modify", "args": { "modified": "args" } }

Skills

Skills are composable instruction modules in skills/<name>/:

skills/
  code-review/
    SKILL.md
    scripts/
      lint.sh

---
name: code-review
description: Review code for quality and security
---

# Code Review

When reviewing code:
1. Check for security vulnerabilities
2. Verify error handling
3. Run the lint script for style checks

Invoke via CLI: /skill:code-review Review the auth module

Plugins

Plugins are reusable extensions that can provide tools, hooks, skills, prompts, and memory layers. They follow the same git-native philosophy — a plugin is a directory with a plugin.yaml manifest.

CLI Commands

# Install from git URL
gitagent plugin install https://github.com/org/my-plugin.git

# Install from local path
gitagent plugin install ./path/to/plugin

# Install with options
gitagent plugin install <source> --name custom-name --force --no-enable

# List all discovered plugins
gitagent plugin list

# Enable / disable
gitagent plugin enable my-plugin
gitagent plugin disable my-plugin

# Remove
gitagent plugin remove my-plugin

# Scaffold a new plugin
gitagent plugin init my-plugin
Flag Description
--name <name> Custom plugin name (default: derived from source)
--force Reinstall even if already present
--no-enable Install without auto-enabling

Plugin Manifest (plugin.yaml)

id: my-plugin                    # Required, kebab-case
name: My Plugin
version: 0.1.0
description: What this plugin does
author: Your Name
license: MIT
engine: ">=0.3.0"               # Min gitagent version

provides:
  tools: true                    # Load tools from tools/*.yaml
  skills: true                   # Load skills from skills/
  prompt: prompt.md              # Inject into system prompt
  hooks:
    pre_tool_use:
      - script: hooks/audit.sh
        description: Audit tool calls

config:
  properties:
    api_key:
      type: string
      description: API key
      env: MY_API_KEY            # Env var fallback
    timeout:
      type: number
      default: 30
  required: [api_key]

entry: index.ts                  # Optional programmatic entry point

Plugin Config in agent.yaml

plugins:
  my-plugin:
    enabled: true
    source: https://github.com/org/my-plugin.git  # Auto-install on load
    version: main                                   # Git branch/tag
    config:
      api_key: "${MY_API_KEY}"                      # Supports env interpolation
      timeout: 60

Config resolution priority: agent.yaml config > env var > manifest default.

Discovery Order

Plugins are discovered in this order (first match wins):

  1. Local — <agent-dir>/plugins/<name>/
  2. Global — ~/.gitagent/plugins/<name>/
  3. Installed — <agent-dir>/.gitagent/plugins/<name>/

Programmatic Plugins

Plugins with an entry field in their manifest get a full API:

// index.ts
import type { GitagentPluginApi } from "gitagent";

export async function register(api: GitagentPluginApi) {
  // Register a tool
  api.registerTool({
    name: "search_docs",
    description: "Search documentation",
    inputSchema: {
      properties: { query: { type: "string" } },
      required: ["query"],
    },
    handler: async (args) => {
      const results = await search(args.query);
      return { text: JSON.stringify(results) };
    },
  });

  // Register a lifecycle hook
  api.registerHook("pre_tool_use", async (ctx) => {
    api.logger.info(`Tool called: ${ctx.tool}`);
    return { action: "allow" };
  });

  // Add to system prompt
  api.addPrompt("Always check docs before answering questions.");

  // Register a memory layer
  api.registerMemoryLayer({
    name: "docs-cache",
    path: "memory/docs-cache.md",
    description: "Cached documentation lookups",
  });
}

Available API methods:

Method Description
registerTool(def) Register a tool the agent can call
registerHook(event, handler) Register a lifecycle hook (on_session_start, pre_tool_use, post_response, on_error)
addPrompt(text) Append text to the system prompt
registerMemoryLayer(layer) Register a memory layer
logger.info/warn/error(msg) Prefixed logging ([plugin:id])
pluginId Plugin identifier
pluginDir Absolute path to plugin directory
config Resolved config values

Plugin Structure

my-plugin/
├── plugin.yaml          # Manifest (required)
├── tools/               # Declarative tool definitions
│   └── *.yaml
├── hooks/               # Hook scripts
├── skills/              # Skill modules
├── prompt.md            # System prompt addition
└── index.ts             # Programmatic entry point

MCP (Model Context Protocol)

Gitagent is an MCP client: point it at any MCP server and that server's tools are automatically discovered and made available to the agent — no integration code to write. This unlocks the whole ecosystem of ready-made servers (filesystem, GitHub, Postgres, Slack, fetch, …).

Configure servers in agent.yaml

mcp_servers:
  filesystem:                                   # local server over stdio (default)
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/data"]
    env:
      LOG_LEVEL: "${MCP_LOG_LEVEL}"             # ${VAR} interpolated from the environment
    timeoutMs: 30000                            # connect/list timeout (default 30000)

  analytics:                                    # remote server over Streamable HTTP
    type: http
    url: "https://mcp.example.com/mcp"
    headers:
      Authorization: "Bearer ${ANALYTICS_TOKEN}"

  legacy:                                       # legacy SSE transport (deprecated)
    type: sse
    url: "https://old.example.com/sse"

On startup gitagent connects to each server, lists its tools, and registers them as <server>__<tool> (e.g. filesystem__read_file, analytics__query). Connections are torn down automatically when the session ends.

Field Applies to Description
command / args / env / cwd stdio How to launch a local server
type: http | sse + url + headers remote Connect to a remote server
timeoutMs both Connect + list-tools timeout (default 30000)

Use via the SDK

import { query } from "gitagent";

for await (const msg of query({
  prompt: "Summarize last week's signups from the database",
  mcpServers: {
    postgres: {
      command: "npx",
      args: ["-y", "@modelcontextprotocol/server-postgres", process.env.DB_URL!],
    },
  },
})) {
  if (msg.type === "tool_use") console.log(`calling ${msg.toolName}`);
}

SDK mcpServers are merged with any agent.yaml mcp_servers (the SDK value wins on a key collision).

Behavior & guarantees

Note: v1 supports MCP tools. Resources and prompts are not yet exposed.

Multi-Model Support

Gitagent works with any LLM provider supported by pi-ai:

# agent.yaml
model:
  preferred: "anthropic:claude-sonnet-4-5-20250929"
  fallback:
    - "openai:gpt-4o"
    - "google:gemini-2.0-flash"

Supported providers: anthropic, openai, google, xai, groq, mistral, and more.

Inheritance & Composition

Agents can extend base agents:

# agent.yaml
extends: "https://github.com/org/base-agent.git"

# Dependencies
dependencies:
  - name: shared-tools
    source: "https://github.com/org/shared-tools.git"
    version: main
    mount: tools

# Sub-agents
delegation:
  mode: auto

Compliance & Audit

Built-in compliance validation and audit logging:

# agent.yaml
compliance:
  risk_level: high
  human_in_the_loop: true
  data_classification: confidential
  regulatory_frameworks: [SOC2, GDPR]
  recordkeeping:
    audit_logging: true
    retention_days: 90

Audit logs are written to .gitagent/audit.jsonl with full tool invocation traces.

Telemetry

Gitagent ships with built-in OpenTelemetry instrumentation. Set OTEL_EXPORTER_OTLP_ENDPOINT and telemetry is on; leave it unset and runtime cost is zero.

Three layers of signals:

  1. HTTP-level — @opentelemetry/instrumentation-undici auto-patches fetch/undici, so every LLM provider call (Anthropic, OpenAI, Google, …) gets a client span with URL, status code, and timing.
  2. gen_ai.chat spans — emitted on every assistant message_end. Carry gen_ai.system, gen_ai.request.model, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens, gen_ai.response.finish_reasons, and gitagent.cost_usd. Span/metric content never contains the prompt or completion text.
  3. gitagent.tool.execute spans — wrap every tool call with tool.name, tool.call_id, tool.status (ok/error), and tool.error_message on failure.

A root gitagent.agent.session span opens at agent construction and closes on every exit path (success, hook-block, SIGINT, error).

CLI usage

Just set the endpoint — no --import flag, no extra install steps:

OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318 gitagent -p "your prompt"

Telemetry is enabled automatically when the endpoint is set and disabled when it is not. To force-disable even when the endpoint is set, pass GITAGENT_OTEL_ENABLED=false.

Environment variables

Variable Description Default
OTEL_EXPORTER_OTLP_ENDPOINT OTLP/HTTP collector base URL (e.g. http://localhost:4318). When set, telemetry is auto-enabled. (unset → telemetry off)
GITAGENT_OTEL_ENABLED Set to false to disable telemetry even when the endpoint is set (unset = auto)
OTEL_SERVICE_NAME Resource service.name gitagent
OTEL_SERVICE_VERSION Resource service.version (unset)
OTEL_EXPORTER_OTLP_HEADERS Comma-separated key=value pairs, no quotes (e.g. Authorization=Bearer xyz,x-tenant=abc) (unset)
OTEL_TRACES_EXPORTER Set to console to print spans to stdout — no collector needed (unset)

SDK usage

For programmatic embedders, call initTelemetry explicitly — you control when initialisation happens:

import { initTelemetry, shutdownTelemetry, query } from "gitagent";

await initTelemetry({ serviceName: "my-app" });

for await (const msg of query({ prompt: "hello", model: "anthropic:claude-4-6-sonnet-latest" })) {
  // …
}

await shutdownTelemetry();

OTEL_EXPORTER_OTLP_ENDPOINT and OTEL_EXPORTER_OTLP_HEADERS are read automatically by the OTLP exporter when not supplied programmatically. Pass exporterEndpoint / headers only when you need to override env-based config in code.

Emitted spans

Name Kind Key attributes
gitagent.agent.session INTERNAL gitagent.entry (sdk / cli), gitagent.cost_usd, gitagent.session.duration_ms
gitagent.tool.execute INTERNAL tool.name, tool.call_id, tool.status, tool.error_message
gen_ai.chat CLIENT gen_ai.system, gen_ai.request.model, gen_ai.usage.input_tokens, gen_ai.usage.output_tokens, gen_ai.response.finish_reasons, gitagent.cost_usd
HTTP … CLIENT URL, status code, duration (auto from instrumentation-undici)

Emitted metrics

Name Type Description
gitagent.tool.calls counter Number of tool executions, labelled by tool.name
gitagent.tool.duration_ms histogram Tool execution duration
gitagent.session.duration_ms histogram Session duration
gitagent.session.cost_usd counter (USD) Cumulative session cost
gen_ai.client.token.usage counter Token usage by gen_ai.system, gen_ai.request.model, gen_ai.token.type
gen_ai.client.operation.duration histogram LLM call duration

Console quickstart (no collector)

Print spans directly to stdout — useful for local debugging:

OTEL_TRACES_EXPORTER=console gitagent -p "test"

Local Jaeger quickstart

docker run --rm -p 16686:16686 -p 4318:4318 jaegertracing/all-in-one:latest

OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318 gitagent -p "test"

# Open http://localhost:16686 → service "gitagent"

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

❓ FAQ

General

What is Gitagent? GitAgent (formerly Gitclaw) is a git-native AI agent framework where the agent IS a git repository. Identity, rules, memory, tools, and skills are all version-controlled files, enabling "agents as repos" paradigm.

How does Gitagent differ from other agent frameworks? Unlike frameworks that scatter configuration across application code, Gitagent makes the agent itself a git repo:

What is the "agents as repos" concept? Your agent lives in a git repository with structured files:

Installation & Setup

What are the requirements? Node.js 18+ (or 20+ recommended), npm, and git. Install globally with npm install -g @open-gitagent/gitagent (slim CLI + SDK). Add @open-gitagent/voice for voice mode + the web UI.

How do I set up API keys? Run the installer for guided setup:

bash <(curl -fsSL "https://raw.githubusercontent.com/open-gitagent/gitagent/main/install.sh")

Or set manually:

export OPENAI_API_KEY="sk-..."

Which LLM providers are supported?

Use --model flag to override: gitagent --model anthropic:claude-sonnet-4-5-20250929

Core Concepts

What is the SDK and how do I use it? The SDK provides programmatic access via query() function that streams agent events:

import { query } from "gitagent";
for await (const msg of query({ prompt: "hello", model: "openai:gpt-4o-mini" })) {
  if (msg.type === "delta") process.stdout.write(msg.content);
}

How do local repo mode sessions work? Clone a GitHub repo, run an agent on it, auto-commit to a session branch:

gitagent --repo https://github.com/org/repo --pat ghp_xxx "Fix the bug"

Resume with: gitagent --repo URL --session gitagent/session-xxx "Continue"

What hooks are available? Hooks are lifecycle scripts or programmatic handlers in hooks/ directory. They trigger on agent events like tool execution, session start/end, or memory updates.

Development

How do I create custom tools? Define tools in tools/ directory using declarative YAML format. Each tool specifies name, description, parameters, and execution logic.

How do I add skills? Create skill modules in skills/ directory. Skills are composable and can be imported from installed packages or defined locally.

What telemetry options are available? OpenTelemetry integration for observability:

Troubleshooting

Why is my agent not responding?

How do I debug agent behavior?

Where can I get help?

License

This project is licensed under the MIT License.

gitagent (open-gitagent/gitagent)

Searching Database…

714 ·GitHub
Gitagent
这是什么？Gitagent 是一个 git 原生的 AI 代理框架，代理的身份、规则、记忆、工具和技能都以版本受控文件的形式存放在 git 仓库中，因此你可以像对待其他仓库一样 fork 一个代理、为它的个性开分支、对它的规则做 diff。
它是 CLI 工具、SDK，还是两者都是？两者都是——gitagent 既是通过 npm 安装的 CLI，用于交互式运行代理；也是 Node.js SDK（query()、tool()、hooks），用于以进程内编程方式嵌入代理，对标 Claude Agent SDK 模式。
怎么把它跑起来？运行单条命令的 curl 安装脚本，它会通过 npm 全局安装 gitagent 并引导你完成 API 密钥设置；然后在任意目录运行 gitagent，首次运行时它会自动生成 agent.yaml、SOUL.md 和 memory/。
需要先装好 Node.js 和 git 吗？需要——安装 gitagent 之前必须有 Node.js 18 或更新版本、npm 和 git。
语音 UI 默认包含在内吗？不再包含了——从 2.0 起，语音模式移到了单独的 @open-gitagent/voice 包，因为捆绑的 3800 行语音 UI 和一个未使用的依赖会触发供应链安全扫描器的警报；未安装该包时，gitagent --voice 只会打印安装提示然后退出。
它在 Windows、macOS 和 Linux 上运行方式一样吗？一样——它是标准的 Node.js/npm CLI 和 SDK，没有提到任何特定于操作系统的安装路径，因此在 Windows、macOS 和 Linux 上的工作方式相同。
除 Anthropic 外还能用哪些 LLM 提供商？Gitagent 兼容 pi-ai 支持的任何提供商，包括 anthropic、openai、google、xai、groq 和 mistral——通过 provider:model-id 字符串切换。
它支持 MCP 服务器吗？支持。gitagent 是一个 MCP 客户端：在 agent.yaml 中指向任何 MCP 服务器（filesystem、GitHub、Postgres、Slack、fetch 等），它的工具就会被自动发现、加上命名空间并提供给代理；如果某个服务器无法启动，会做柔性降级处理。
可以用自定义工具和插件扩展它吗？可以——你可以在 tools/ 目录用 YAML 文件声明工具，通过 SDK 的 tool() 函数注册自定义工具，并安装由 plugin.yaml 清单定义的可复用插件（自带工具、钩子、技能和记忆层）。
它会自动跟踪成本和 token 用量吗？会——内置的 OpenTelemetry 埋点会发出 genai.chat span，包含输入/输出 token 数和按会话计的美元成本，并把每次工具调用的审计日志写入 .gitagent/audit.jsonl。
What are similar projects?ruflo, brigade, turnstone, qwen-code, SystemOneHarness, evenfire, harness-sdk, suna
Which topics is it in?personal, compliance, mcp-client, opentelemetry, assistant, audit-log, openclaw, agent-framework, plugin-system, memory, model-context-protocol, observability
Creator
open-gitagent
Size
4.9 MB
Stars
714
Updated
CommitAug 20Releasev2.2.0Aug 20
Age
7mo
Commits · 90 Days