Contents
How gitta works
gitta sits between your agents and Git. It reads what each agent changes, tells the agents that are affected, and checks combined work before it reaches main.
Workspaces
Each agent works in its own Git worktree. An agent does not see the half-done work of the others, so it cannot break their tests while it works. gitta finds new worktrees automatically. It does not matter which tool made them, for example Claude Code, Cursor, Conductor or git worktree add.
On Linux, gitta can make Claude Code worktrees share one checkout on disk. See Linux workspaces.
Warnings
gitta parses each changed file with Tree-sitter. gitta Enterprise reads COBOL and JCL with its own reader. It finds the functions, methods, classes, constants and fields that an agent changed. It also finds the symbols that the agent's new code uses. It follows imports and calls up to three steps away.
When one agent changes a symbol that another agent's new code uses, gitta warns the second agent. The warning reaches the agent inside its own session, at its next step. No person has to run a command. See Warnings and sync.
Security checks
gitta has three layers of security checks. None of them uses AI, and each one runs at the agent's next step.
| Layer | What it looks at | What happens |
|---|---|---|
| Risky code in an agent's own change | Only the lines the agent added, for well-known risks such as SQL or shell commands built from variables, or certificate checks turned off | A security note in the agent's session. High notes count as weakened checks at merge time. See Security notes. |
| Weakened security controls between agents | Login, permission, CSRF, rate limit, validation, escaping and certificate checks that one agent removes or switches off, while another agent's new code calls the code they protected | A security warning to both agents. The merge output and the audit trail report it. See Security controls. |
| Mainframe code, with gitta Enterprise | JCL, REXX, CLIST, COBOL and assembler changes that give code more authority | Reported at merge time and in the audit trail. See Security checks on mainframe code. |
Besides these, every merge to main reports what looks like credentials in code and tests or CI checks that were weakened. You can mark your own security checks, allow reviewed lines and choose which notes count. All of it goes into the audit trail.
Sync
Sync brings other work into an agent's worktree. It merges file by file. When lines clash, it merges by structure, for example by function, statement, import, JSON key or config entry. You run it with gitta sync. gitta syncs the workspaces it made itself, with gitta run or gitta up, on its own when the work merges cleanly and nothing their new code uses changed meaning. A worktree made by your agent tool keeps exactly what its agent wrote, and git brings main in when the agent merges. That merge uses the same structural merge: gitta init sets gitta as the git merge driver for code files, so two agents who add or change different functions in one file get both changes, not conflict markers. When the same lines really clash, the agent sees git's normal conflict.
Merging
You merge with git merge, git pull or git push, as always. gitta hooks into those commands. It checks for weakened tests, weakened security controls, risky new code and credentials, and runs your gate on the combined code. When the tests fail, the merge stops before main moves. See Merging.
A merged pull request works too, through the pull request check. To make the checks mandatory, see What gitta watches and what it blocks.
Many worktrees
Each hook scans only its own agent's worktree and reuses the last scan of the others, so adding agents adds little work for gitta. A worktree that gitta cannot read, for example because its folder is gone, is skipped with one line that names the fix. The other agents keep working. See Troubleshooting.