Kizuna is built on Jujutsu (jj), a modern version control system that is Git-compatible while providing superior semantics for automation and collaboration.

Why Not Just Git?

Git was designed in 2005 for Linux kernel development by humans. Its model assumes:

• Manual staging of changes (git add)
• Named branches for parallel work
• Immediate conflict resolution
• Human-readable commit messages
• Local-only operation history

These assumptions create friction for AI agents:

Git Challenge	Impact on Agents
Staging area	Extra steps, easy to forget
Mutable commits	Lose tracking across amends
Detached HEAD	Confusing state machine
Rebase conflicts	Complex resolution required
No operation log	Mistakes hard to undo

Jujutsu: Designed for Automation

1. No Staging Area

In Jujutsu, your working copy is a commit.

# Git workflow
echo "code" > file.txt
git add file.txt          # Stage
git commit -m "message"   # Commit

# Jujutsu workflow
echo "code" > file.txt
# Done — automatically committed!
jj log                     # See the change

Benefit for agents: No missed adds, simpler mental model.

2. Stable Change IDs

Git commits are identified by content hash. Change one byte, get a new hash.

Jujutsu assigns stable IDs to changes that persist across:

• Rebasing
• Amending
• Splitting
• Squashing

jj log
# Change ID stays the same even after:
jj rebase -d main
jj describe -m "Better message"
jj squash

Benefit for agents: Track work across rewrites without losing context.

3. First-Class Conflicts

Git forces immediate conflict resolution. Jujutsu allows conflicts to exist as objects:

# Create a conflicted change
jj rebase -d conflicting-branch
# Change is now conflicted but exists!
jj log
# Shows: (conflict) description

# Resolve later
jj resolve
# Or undo
jj undo

Benefit for agents: Create conflicts, annotate with reasoning, hand off for resolution.

4. Operation Log with Undo

Every operation is logged and reversible:

jj op log
# Shows: rebase, describe, commit, etc.

# Undo anything
jj undo                    # Undo last operation
jj undo --op abcd1234     # Undo specific operation

# Restore any past state
jj op restore abcd1234

Benefit for agents: Mistakes are recoverable without reflog archaeology.

5. Anonymous Branches

Create parallel work without naming:

# From main, start two parallel changes
jj new main -m "Change A"
# work...
jj new main -m "Change B"
# work...

jj log
# Shows both changes diverging from main
# No branch names needed!

Benefit for agents: Multiple agents work concurrently without coordination overhead.

6. Revsets Query Language

Query the commit graph with expressions:

# Changes by me, not on main, touching src/
jj log -r 'author(me) ~ main ~ file(src.html)'

# Changes from last week
jj log -r 'committer_date(after:"last week")'

# Conflicts
jj log -r 'conflict()'

Benefit for agents: Express complex queries without parsing git log.

Git Compatibility

Jujutsu uses Git as its storage backend:

# Clone a Git repository
jj git clone https://github.com/user/repo.git

# Push to Git remotes
jj git push origin

# Fetch from Git remotes
jj git fetch

# Colocated repos work with both
jj --colocate

Existing Git tooling continues to work:

• GitHub/GitLab integrations
• CI/CD pipelines
• IDE plugins
• Command aliases

Kizuna + Jujutsu Integration

Server-Side Operations

Kizuna exposes Jujutsu operations via API:

# Create change via API
curl -X POST /api/v1/repos/org/repo/changes \
  -d '{"parent": "main", "description": "Fix bug"}'

# Rebase via API
curl -X POST /api/v1/repos/org/repo/changes/abc123/rebase \
  -d '{"destination": "main"}'

# List conflicts via API
curl /api/v1/repos/org/repo/conflicts

Conflict Inbox

Kizuna's UI renders Jujutsu conflicts as first-class objects:

• Visual diff of conflict regions
• Agent reasoning annotations
• Suggested resolutions
• Assignment workflows

Operation Log Viewer

Browse and undo any operation through the web UI:

Operations ─────────────────────
▼ 2026-03-10 09:00  rebase abcd1234
  2026-03-10 08:55  describe xyz7890
  2026-03-10 08:50  new pqr4567
  [Restore] [View Diff]

Learning Jujutsu

Quick Reference

Git Command	Jujutsu Equivalent
git add	Automatic
git commit	jj describe (change message)
git checkout -b	jj new
git rebase	jj rebase
git merge	jj rebase (same thing in jj)
git reset	jj undo
git reflog	jj op log
git stash	jj new (anonymous branch)

Installation

# macOS
brew install jj

# Linux
cargo install jj-cli

# Windows
winget install martinvonz.jj

Getting Help

jj help              # Overview
jj help command      # Specific command
jj help --keyword    # Search help

Summary

Jujutsu provides the semantic foundation that makes Kizuna's AI-native workflows possible:

• Simpler model — No staging, working copy is always committed
• Stable tracking — Change IDs persist across rewrites
• Conflict objects — Async resolution, annotation support
• Full history — Operation log with undo
• Git compatible — Existing tooling continues to work

Kizuna leverages these capabilities to enable autonomous agents that can create, modify, and resolve code changes with confidence and auditability.