agentic-jujutsu
Quantum-resistant, self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination
Profile →npx skills add ruvnet/ruflo --skill agentic-jujutsu --agent claude-code
Same command for any agent — swap --agent for codex, cursor, copilot.
Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.
What it does
Agentic Jujutsu describes a version-control system designed for multiple AI agents to work concurrently without locking. It emphasizes self-learning via ReasoningBank, pattern discovery, learning statistics, and multi-agent coordination, with quantum-resistant security features and automatic conflict resolution.
How it works
The skill exposes a wrapper API (JjWrapper) with core methods for status, newCommit, log, diff, branchCreate, and rebase to manage code and history. It provides ReasoningBank-based learning utilities:
- startTrajectory(task): begin a learning trajectory and return a trajectory ID
- addToTrajectory(): record recent operations into the trajectory
- finalizeTrajectory(score, critique?): complete the trajectory with a score (0.0-1.0) and optional critique
- getSuggestion(task): obtain AI recommendations as JSON
- getLearningStats(): obtain learning metrics, JSON
- getPatterns(): obtain discovered patterns, JSON
- queryTrajectories(task, limit): find similar trajectories, JSON
- resetLearning(): clear learned data
It also includes AgentDB methods for operation statistics and recent/user-specific operations, and Quantum Security methods for fingerprints and optional HQC-128 encryption. Performance and best-practice sections describe how to apply and optimize usage, including multi-agent coordination and trajectory handling.
When to use it
Use agentic-jujutsu when multiple AI agents modify code concurrently, need lock-free version control, want self-learning capabilities, require quantum-resistant security, desire automatic conflict resolution, and plan to coordinate agents without blocking.
What it can touch
The skill lists the following tools and interfaces: "claude-code, codex". It also references internal APIs and modules such as JjWrapper, ReasoningBank methods (startTrajectory, addToTrajectory, finalizeTrajectory, getSuggestion, getLearningStats, getPatterns, queryTrajectories, resetLearning), and Quantum Security methods (generateQuantumFingerprint, verifyQuantumFingerprint, enableEncryption, disableEncryption, isEncryptionEnabled). It specifies operations like status, newCommit, log, diff, branchCreate, rebase, and various trajectory-related calls. It also shows example code using require('agentic-jujutsu') and usage patterns for multi-agent coordination.
Caveats
Declared limitations include validation rules for trajectories and learning data (non-empty context, finite scores between 0.0 and 1.0, at least one operation before finalizing, and non-empty context keys). The docs also present a 87% auto-conflict-resolution rate and a 23x speedup claim over Git, but these are stated as capabilities within the material and not outcomes guaranteed by the skill implementation.
# Agentic Jujutsu - AI Agent Version Control > Quantum-ready, self-learning version control designed for multiple AI agents working simultaneously without conflicts. ## When to Use This Skill Use **agentic-jujutsu** when you need: - ✅ Multiple AI agents modifying code simultaneously - ✅ Lock-free version control (23x faster than Git) - ✅ Self-learning AI that improves from experience - ✅ Quantum-resistant security for future-proof protection - ✅ Automatic conflict resolution (87% success rate) - ✅ Pattern recognition and intelligent suggestions - ✅ Multi-agent coordination without blocking ## Quick Start ### Installation ```bash npx agentic-jujutsu ``` ### Basic Usage ```javascript const { JjWrapper } = require('agentic-jujutsu'); const jj = new JjWrapper(); // Basic operations await jj.status(); await jj.newCommit('Add feature'); await jj.log(10); // Self-learning trajectory const id = jj.startTrajectory('Implement authentication'); await jj.branchCreate('feature$auth'); await jj.newCommit('Add auth'); jj.addToTrajectory(); jj.finalizeTrajectory(0.9, 'Clean implementation'); // Get AI suggestions const suggestion = JSON.parse(jj.getSuggestion('Add logout feature')); console.log(`C
- When to Use This Skill
- Quick Start
- Installation
- Basic Usage
- Core Capabilities
- 1. Self-Learning with ReasoningBank
- 2. Pattern Discovery
- 3. Learning Statistics
- 4. Multi-Agent Coordination
- 5. Quantum-Resistant Security (v2.3.0+)
- 6. Operation Tracking with AgentDB
- Advanced Use Cases
- Use Case 1: Adaptive Workflow Optimization
- Use Case 2: Multi-Agent Code Review
npx agentic-jujutsu
What does the agentic-jujutsu skill do?
Quantum-resistant, self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination
How do I install it?
Run `npx skills add ruvnet/ruflo --skill agentic-jujutsu --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.
Where does this skill come from?
From ruvnet/ruflo, a repository with 67,015 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.
Is a popular skill a good skill?
Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.