mrkeyoor.comAsk

feder-cr/git-aitested 15 Nov 2026commit a17ad0f

git-ai review

Our feder-cr/git-ai run installed in 71 seconds and built in 16 seconds, then failed the SDK test package.

  • Install failed
  • Build 16 s
3/4passed, run exited non-zero
  • 632 packages
Dev Toolsevaluationupdated 15 Nov 2026
+4stars / 7d

Feder-cr's git-ai, called gitai with Graft extensions, is a Git-compatible server and command-line client for coding-agent workspaces. Its README describes sparse file access, server-side history queries and landing changes onto shared branches. It is separate from the git-ai-project/git-ai attribution extension.

Verdict

Our feder-cr/git-ai run installed in 71 seconds and built in 16 seconds, then failed the SDK test package. Platform engineers operating coding-agent infrastructure should consider an isolated evaluation of its server-side landing workflow. Developers seeking line attribution should use the separate attribution project, and teams choosing a complete hosting product should look elsewhere.

git-ai infographic: land agent changes onto shared branches, plus its uses, our test result, pitfalls and who it suits
Tested 15 November 2026: go install failed after 19 s. Before that: source install 71 s, build 16 s; 3 of 4 source tests passed.

We ran it

Lab card: what happened when we ran git-ai
Lab card from our sandbox run
Screenshot of git-ai (www.anthropic.com/engineering/redesigning-source-control)
www.anthropic.com/engineering/redesigning-source-control
Install✓ · 71s632 packages
Build✓ · 16s
Tests✗ · 568s3 passed · 1 failed of 4 (go test)
Repo3177 files~671,836 lines of source · 32.7 MB · 1 CI workflows

Answers from our run

Does git-ai build from source?

Dependencies installed in 71 seconds (632 packages), and the build succeeded in 16 seconds. We cloned commit a17ad0f into a clean Debian container with 3 CPUs and no project-specific setup.

Do git-ai's tests pass?

No. The project's own test command finished in 568 seconds and reported 3 passed, 1 failed (go test).

Who should not use git-ai?

Developers seeking line attribution in existing repositories; the separate attribution extension serves that purpose.

What are the alternatives to git-ai?

Git AI attribution extension, Normal Git clone and server Git protocol. Our feder-cr/git-ai run installed in 71 seconds and built in 16 seconds, then failed the SDK test package.

Setup2/5In our 2026-11-15 run “go install github.com/feder-cr/git-ai/...@latest” failed with “go: github.com/feder-cr/git-ai/...@latest (in github.com/feder-cr/git…”, though our source checkout installed in 71 s and built in 16 s.Editor’s note: Install and build succeeded, but the SDK package failed and the run did not exercise a deployed agent workspace.
Docs4/5The README has an install section (“Quick start”) and usage in the same section; we did not run its quickstart ourselves.Editor’s note: The supplied README, security model and limitations support specific workflow descriptions, not a complete documentation-quality assessment.
Community4/5Last push on 2026-11-05 and 1,000 stars.Editor’s note: The supplied server licensing issue has no comments; reports about the separate attribution extension cannot assess this server's community.
Maturity1/5Latest release v0.4.2 on 2026-11-05 (pre-1.0), repository created 2026-10-15 and its test suite did not pass in our sandbox (3 of 4 passed).Editor’s note: The SDK package failed in the recorded run, while deployed reliability, recovery and concurrent landing were not assessed.

How we score

Who it’s for

Platform engineers evaluating server-side landing for coding agents.
Operators prepared to manage repository storage, agent credentials and branch policies.
Contributors investigating the recorded SDK integration failure.

Who it’s NOT for

Developers seeking line attribution in existing repositories; the separate attribution extension serves that purpose.
Teams choosing a complete hosting product rather than operating a Git server and client.
Organizations requiring a completed provenance assessment before redistribution.

Setup reality

Our November 15, 2026 sandbox run at commit a17ad0f installed successfully in 71 seconds with 632 dependencies recorded, then built in 16 seconds. Tests exited 1 after 568 seconds: the summary reports 3 passed and 1 failed of 4 package results. The failed package was github.com/feder-cr/git-ai/sdk; the supplied tail contains landing integration subtest names but no assertion messages.

The README's source-workspace route is to clone the repository, run make build and use examples/graft/quickstart.sh. Its requirements are Linux or macOS, Go 1.26, a C toolchain, Meson and Ninja. A separate hands-on package-install attempt failed because Go rejected module replace directives; its timings and environment are separate from the successful harness setup.

Feder-cr/git-ai is an agent-oriented Git server, and our run built successfully before its SDK test package failed. Evaluate it if your job is operating source-control infrastructure for coding agents. If you want to trace agent-written lines in an existing repository, use the separate Git AI attribution review. The shared name hides different products, installation routes and operating responsibilities. This review follows the server's documented workflows and the recorded build result rather than repeating the attribution guide.

What you can do with git-ai

Feder-cr's README describes sparse workspaces, server-side history queries and landing changes through a branch compare-and-swap. The product is called gitai, while its extensions use the Graft name in configuration, commands and source paths. Agents can request selected objects and paths rather than materializing a complete workspace for every task. History operations, including blame and ancestry, run on the server. These documented capabilities make the project relevant to engineers designing how automated writers share repositories. gitai README

The landing path is the central design choice. The README says UserLand rebases a change onto the current branch tip, then updates the reference with compare-and-swap. Concurrent lands on one branch are batched into a single reference update. That gives an evaluator a concrete workflow to examine: several agents prepare changes, submit them to the server and receive landing outcomes. It also explains why this project belongs in an infrastructure evaluation rather than an editor-extension comparison.

What people use git-ai for

The README documents three server use cases: sparse agent workspaces, shared-branch landing and monitoring accepted changes. These are documented uses, rather than customer deployment stories. Each puts the server between automated writers and repository state, so the relevant reader is someone responsible for that service. A useful evaluation starts by selecting which of these jobs your current workflow needs and then following its corresponding command or service through the documentation. documented server capabilities

  • Sparse workspaces: ObjectService serves individual objects and sparse trees, while graft clone and graft sparse materialize selected paths. This is the documented route for tasks that need only part of a repository. sparse workspace description
  • Shared-branch landing: UserLand rebases proposed changes and batches concurrent lands into a reference update. This is the documented coordination path for agents submitting work to the same branch. landing description
  • Change monitoring: the changeset stream records accepted reference updates with operation and actor, and monitoring agents can follow it. This supplies a documented input for component-specific reporting. changeset and monitoring description

The README also describes semantic review rules and graft-verify, which tests the tip, bisects a failure and reverts the offending change. These are separate parts of the proposed operating workflow: accepting a reference update, reviewing a change and responding to a broken tip have different responsibilities. Keeping those responsibilities visible helps an evaluator decide which components to configure first, rather than treating the quickstart as the whole service.

What happened when we ran it

Our run at commit a17ad0f on November 15, 2026 installed in 71 seconds, built in 16 seconds and failed tests after 568 seconds. The recorded sandbox configuration was 3 CPUs, 8 GB RAM and image golang:1.24-bookworm. Installation recorded 632 dependencies. These are measurements from our source checkout, distinct from the research pack's separate package-install attempt. The release page identifies v0.4.2 with commit a17ad0f. v0.4.2 release

Recorded step Outcome Recorded duration
Install Succeeded; 632 dependencies recorded 71 seconds
Build Succeeded 16 seconds
Tests Failed, exit 1; 3 passed and 1 failed of 4 package results 568 seconds

The failed package was github.com/feder-cr/git-ai/sdk. The tail lists TestIntegration_Land/create_branch, merge_strategy_creates_a_merge_commit, conflicting_change_is_reported, fast-forward_only_fails_when_not_a_fast-forward, already_landed_leaves_the_branch_alone and rebases_onto_a_diverged_tip. Those names place landing integration in the failed output. Successful package results appear for streamio, tools/govulncheck-filter and tools/protoc-gen-gitaly-lint. The four summary results are packages, so they should be read at that level rather than as a count of individual test cases.

The checkout contained 3,177 files, approximately 671,836 source lines and 32.7 MB. The scan found one CI workflow file, no Dockerfile and no tests directory. Go test files can sit beside implementation files; the package output demonstrates why a directory-name scan and an executed test command answer different questions. For a contributor, the concrete next step is to obtain the full SDK failure output and reproduce the named landing cases before assigning a cause.

The separate hands-on record used commit a17ad0f7f489 in an unprivileged golang:1.24-bookworm container with 2 CPUs, 4 GB RAM, no published ports and no secrets. Its quickstart-cli clone step took 3 seconds. The package-install step failed in 19.2 seconds with exit 1, and teardown reported success. These numbers belong to that record alone.

Where people get stuck

The separate go install attempt failed because the module contained replace directives. Its command was go install github.com/feder-cr/git-ai/...@latest, and the error identified v0.4.2. The log also recorded a requirement for Go 1.26.0 or later and automatic switching to go1.26.11. This explains the failed package-install route without changing the successful source-workspace result above.

The README instead gives a source-build sequence: clone feder-cr/git-ai, enter the checkout, run make build and invoke examples/graft/quickstart.sh. It lists Linux or macOS, Go 1.26, a C toolchain, Meson and Ninja because the build compiles bundled Git. The quickstart describes a temporary server, cache daemon, two agents and a land. Those instructions provide the documented entry point; the harness's successful install step does not identify that quickstart as an executed workflow. source-build instructions

Repository creation and sparse cloning also have a specific order. The limitations document says an operator creates repositories with the shared token, and graft clone needs an existing branch. For a new repository, graft repo create --initial-commit supplies the first commit. This is a useful setup distinction: provisioning a repository is an operator action, while giving an agent access to its workspace is a subsequent action with different credentials. repository setup rules

More agents mean more infrastructure to operate

The documented storage core uses SQLite for one node or PostgreSQL, plus object storage for packs. Server nodes act as reconstructible caches. To enable that storage design, the README directs operators to configure graft.storage, start in shadow mode, import repositories and then switch to authoritative mode. That sequence makes repository migration part of setup. Assign ownership for imports, database operation, object storage and recovery before treating the service as an ordinary command-line utility. storage setup

The v0.4.2 release notes describe fixes for rejected pushes recorded in the database, PostgreSQL connection churn and access through symbolic branches. These are maintainer-reported corrections. They give operators specific behaviors to inspect when choosing configuration and building an evaluation checklist. The release also introduces PostgreSQL pool settings and asks operators to keep the total connection allowance across nodes below the database server's connection limit, leaving room for upgrades. v0.4.2 operating changes

Security depends on deployment mode and credentials

Graft documents per-agent tokens and an RPC allowlist; standalone mode is an explicit identity-enforcement choice for evaluation. Its security model says agent identity comes from the token and distinguishes agent credentials from the shared operator token. Configure separate credentials for automated writers and operators, then examine the selected deployment mode alongside branch policy. The corresponding documented mode restriction appears in the consolidated testing and limitations section below. agent security model, deployment-mode behavior

Automatic conflict resolution is off by default. The security document says a model's proposed resolution can land automatically only when the configured verification command passes on the merged tree. That command executes code derived from repository content and model output. The document therefore recommends a separate unprivileged user, a container without network access, a read-only checkout, no credentials and resource limits. Treat this as an execution environment to configure, rather than as a consequence of possessing an agent token. resolution security guidance

git-ai vs alternatives

Feder-cr/git-ai coordinates agent work through a server; the attribution extension records agent-reported authorship in Git Notes. The existing Git AI attribution review answers the latter question. For this server evaluation, the useful comparison is the job each workflow performs and who operates it. The supplied sources support those functional distinctions, while the measured source build supplies the concrete result for feder-cr's project. server README, attribution repository

Tool or workflow Documented job Choose it when
feder-cr/git-ai Sparse workspaces, server-side queries and landing You are evaluating infrastructure for automated repository writers
git-ai-project/git-ai AI line attribution in existing repositories You need authorship records rather than a landing service
Normal Git clone and server Git protocol Full local object graph and Git push or pull Your workflow needs ordinary local Git commands and transport

The Graft limitations document explicitly directs commands needing the full local object graph, such as git log inside a workspace, to a normal Git clone. It also directs Git push and pull to the server's normal Git protocol. That makes coexistence a practical option: decide which operations need a sparse server-centric workspace and which need the ordinary Git interface. The comparison is about operation placement, rather than declaring one workflow a universal replacement. client workflow distinctions

What the other reviews get wrong

The supplied attribution reviews concern git-ai-project/git-ai, while this page measures feder-cr/git-ai at a17ad0f. Their product recommendations therefore belong to the attribution page. The research also identifies dated attribution coverage: Ry Walker lists Thoughtworks Assess, while the supplied November 2026 Radar entry lists Trial. The releases snapshot labels v1.7.5 Latest, while Tom Rochette's later update records v1.7.6. Those version labels belong to the separate extension. older review, Radar entry, release snapshot, later update

The attribution storage account also needs its own source: its README describes sessions saved outside Git, whereas the research flags an older review's statement that prompts travel in Git Notes. Keep that correction attached to the extension. For this server, use the feder-cr README, security documentation, limitations and release notes. An attribution endorsement or extension release number supplies no corresponding endorsement or version for the server. attribution storage description

FAQ

Feder-cr/git-ai is the gitai server with Graft extensions; git-ai-project/git-ai is the attribution extension. The owner and repository name determine which setup instructions apply. The following questions come from the supplied search intents and licensing issue, and keep the answers focused on identifying and evaluating this server. Readers seeking the extension's agent integrations can follow the existing attribution review instead of applying those instructions to this checkout. server identity, attribution review

What is git-ai, and which project does the name refer to?

Feder-cr/git-ai calls its product gitai and its extensions Graft. Its README describes a server, sparse client workflows and a landing API. The separate git-ai-project/git-ai repository describes an extension that links AI-written lines to agents, models and prompts. Include the GitHub owner in an installation search so that the chosen command belongs to the intended product. Our measured checkout is feder-cr's server. gitai identity, extension identity

How do I install git-ai?

For feder-cr/git-ai, the README says to clone the repository, run make build and use examples/graft/quickstart.sh. Its requirements are Linux or macOS, Go 1.26, a C toolchain, Meson and Ninja. Start with that source-workspace route when evaluating the server. The separate package-install failure in this review concerns go install with an @latest suffix, whereas the successful harness setup used the checked-out source workspace. documented installation route

Does feder-cr/git-ai's license match the provenance of its code?

The README declares MIT licensing and says the project began as a fork of Gitaly, while issue #5 challenges licensing of alleged Git-derived code. The supplied issue is open with zero comments. Read the allegation alongside the README's account of Gitaly ancestry and third-party notices; the provenance-assessment boundary is recorded below. This question concerns feder-cr's repository, so another project's license is not an answer. license complaint, README credits

What we have not tested yet

Our measurements cover source setup, a successful build and a failed test command; no server user deployment was verified. The SDK tail omits assertion messages and the underlying cause. The sandbox image label does not establish actual runtime or operating-system versions. We have not tested a deployed agent workspace, sustained concurrent landing, recovery, remote-node operation, conflict-resolution quality or security behavior. No corrected command or documented workflow in this draft is presented as a newly executed test.

With standalone mode off, agent-supplied gl_id and gl_username pass unchanged to GitLab's access check, allowing an agent to act as any GitLab user. This documented limitation qualifies the token-identity explanation above: evaluate standalone-mode identity enforcement explicitly before giving agents access. The limitations document also says Graft is not a security boundary by itself; anyone who can edit configuration can change write policy. Our run supplies no independent assessment of those controls. standalone identity limitation

The README says separate-machine nodes and S3, GCS and Azure buckets are untested, and interfaces may change before 1.0. Graft has no web UI, issues, merge-request review workflow or CI of its own. These documented boundaries matter when choosing a hosting service or planning distributed operation. Issue #5 remains an allegation: we have not audited source provenance or reached a legal conclusion. Redistribution decisions requiring that conclusion need a separate provenance assessment. README status, product boundaries, open licensing complaint

Alternatives

ProjectWhat it isPick it when
Git AI attribution extension gh↗Links AI-written lines to agents, models and prompts in existing repositories.Choose it when authorship tracking is the task; use the existing attribution review for that evaluation.
Normal Git clone and server Git protocolGraft's documentation directs full-local-history operations and Git push or pull to ordinary Git workflows.Choose a normal clone for commands needing the full local object graph, and the server's normal Git protocol for push and pull.

Sources

  1. Feder-cr gitai README
  2. Graft agent security model
  3. Graft limitations
  4. Feder-cr v0.4.2 release
  5. Feder-cr licensing complaint

More dev tools reviews