get-fable

Deterministic Coding Lifecycle and Autonomous Repository Steward for AI Agents

Inspectable process, mutation-aware verification, and disciplined engineering across 32 platforms.

46 connected Skills · Autonomous Repository Steward · routing · research · planning · architecture · TDD · verification · review · redteam · security healing · anti-slop · anti-churn · recovery · gRPC worker · TOON protocol · Rust Jev engine · Frontier test engine · DSH plugin · release

bun add -g get-fable

Start here · How it works · Steward Module · The Skills · Docs

Process over raw model size

Code quality depends on the harness surrounding the model. A capable model will still fail if it edits code before inspecting the repository, relies on stale documentation, patches bugs without a reproduction test, or accepts stale test runs as proof.

get-fable wraps your coding agent in a deterministic engineering lifecycle across 32 platforms. It enforces discovery before planning, test-driven changes before code edits, mutation-aware verification before task completion, and systematic diagnosis upon repeated failure.

YOUR CODING AGENT
       +
GET-FABLE HARNESS
       ↓
DISCOVER
RESEARCH
PLAN
TEST
DELEGATE
EXECUTE
VERIFY
REVIEW
SECURITY
RECOVER
RELEASE
       ↓
A MORE DISCIPLINED CODING LOOP

So what does get-fable actually do?

It equips the agent with 46 connected specialist Skills and a deterministic router that selects the right specialist for each task phase.

A normal bug request should not immediately mean “edit production code.”

"Fix the token refresh race condition"

        ↓

Where does the behavior actually live?
        ↓
Can we reproduce it reliably?
        ↓
What test level crosses the real failure boundary?
        ↓
Did RED fail for the right reason?
        ↓
Make the smallest production change
        ↓
Fresh GREEN
        ↓
Probe adjacent race/error paths
        ↓
Verify the current mutation
        ↓
Review the actual diff

A release request follows a different route.

An unfamiliar SDK should trigger current primary-source research before implementation.

A repeated failure should stop mutation and enter diagnosis.

A security-sensitive change should be traced through trust boundaries, not waved through because a scanner came back clean.

The workflow follows the work.

This is not a prompt pack

This distinction matters.

A prompt can say:

verify your work

get-fable can track that the repository changed after verification and treat the old evidence as stale.

A prompt can say:

use TDD

fable-tdd now distinguishes a valid RED from a syntax error, a broken fixture, a stale artifact, a false-green mock, or a concurrency test that only passes because it slept long enough.

A prompt can say:

use subagents

fable-delegate asks whether the work is independent at the semantic level, not just whether two workers touch different files.

A prompt can say:

debug carefully

fable-recover freezes blind mutation, builds a ranked hypothesis queue, chooses discriminating probes, falsifies bad theories, and only then issues one bounded repair.

A prompt can say:

make sure the release works

fable-release separates source correctness from the artifact users actually install, then distinguishes READY_NOT_PUBLISHED, PUBLISHED_UNVERIFIED, and genuinely RELEASED.

That is the direction of the project: not more instructions, but more operational judgment around the instructions.

Deep Skill Playbooks V2

Every canonical Skill carries complete operational knowledge and architecture discipline:

• Activation boundaries: Exact criteria for when to activate, refuse, or defer;
• Situational classification: Taxonomy and decision branches for ambiguous cases before acting;
• Staged execution: Verifiable, step-by-step evidence protocol with red/green gates;
• Architectural invariants: Non-negotiable constraints that must remain true;
• Failure handling: Actionable taxonomy that changes the next action upon error;
• Anti-pattern guards: Explicit enumeration of tempting anti-patterns to avoid;
• Structured artifacts: Machine-verifiable receipts, templates, and state handoffs;
• Progressive references: Substantial deep-dive guides (>1,000 to >3,000 bytes) for complex scenarios;
• Behavioral evals: Comprehensive 10-scenario evaluation benchmarks per skill.

Engineering reasoning is encoded directly in each Skill, providing deterministic execution across model tiers.

46 Skills across 8 Packs

Core Pack (7) - Lifecycle Navigation & Execution

• get-fable: Choose the next specialist from intent and durable state, prioritizing failure, security, stale proof, and unknowns.
• fable-discover: Trace real repository and runtime execution paths instead of guessing from filenames and imports.
• fable-plan: Turn evidence into dependency-aware, risk-aware, falsifiable work cards.
• fable-execute: Implement one bounded card while protecting scope, source-of-truth, and user work.
• fable-verify: Build a claim-to-evidence matrix and falsify the implementation with fresh proofs.
• fable-recover: Stop blind retries and rebuild causal confidence after repeated failure.
• fable-method: Run a step-by-step problem-solving loop: classify intent, define done, act surgically, verify by observation.

Intelligence Pack (1) - Primary Source Grounding

• fable-research: Resolve current external facts against version-appropriate primary sources.

Build Pack (4) - Disciplined Implementation

• fable-tdd: Prove the behavior gap through the correct test boundary before production mutation.
• fable-delegate: Parallelize only when write, semantic, and verification independence are satisfied.
• fable-native-code: Enforce codebase idiom matching and anti-bloat standards so diffs read like native code.
• fable-scope-discipline: Enforce anti-scope-creep and atomic diff discipline, keeping changes strictly bounded.

Proof Pack (10) - Adversarial Review & Security

• fable-review: Inspect diffs for concrete failure scenarios instead of style-comment theater.
• fable-security: Trace attacker-controlled input across trust boundaries and validate findings skeptically.
• fable-redteam: Run automated penetration testing with CVSS v3.1 scoring, circuit breaker protection, SARIF reports, and run attestations.
• fable-heal: Synthesize, apply, and verify security remediations for vulnerabilities identified by fable-redteam.
• fable-test: Orchestrate, author, and verify automated tests in application codebases, enforcing Test-Guard anti-bloat rules and test-value calculus.
• fable-core-test: Orchestrate, execute, and diagnose the complete internal 7-tier test pyramid for get-fable crates, Bun suites, Cypress, and system doctor audit.
• fable-prove-it: Enforce evidence precedence and verification rungs, preventing unverified claims.
• fable-judge: Conduct adversarial verification of finished work, detecting weakened tests and false completion claims.
• fable-anti-slop-engineering: High-performance native Rust engine detecting test tampering, weak assertions, swallowed errors, security bypasses, and type suppressions.
• fable-anti-churn: Native Rust engine preventing duplicate agent actions, infinite retry loops, and unverified churn.

Delivery Pack (5) - Production Readiness & Continuity

• fable-release: Audit and certify repository merge and release readiness against quality gates and verified artifacts.
• fable-handoff: Create a verified resumability contract for another agent or session.
• fable-finish-your-turn: Autonomous task completion policy preventing premature stops, upward delegation, and unexecuted TODOs.
• fable-outcome-first: Response styling policy enforcing direct first-sentence answers and zero sycophancy.
• fable-tend: Autonomous maintainer for repository CI repair, PR conflict resolution, and triage.

Evolution Pack (2) - Agent Evaluation & Durable Learnings

• fable-eval: Measure changes to agent behavior without benchmark overfitting or oracle leakage.
• fable-learning: Extract structured learnings, reusable patterns, failure lessons, and agent-kernel Playbooks from completed sessions.

System Pack (15) - Architecture, Scale & Cognitive Primitives

• fable-architecture: Evaluate scale, domain decoupling, and resource intensity vectors, locking out monolithic scaffolds when thresholds cross limits.
• fable-eco: Provision curated capabilities, manage reproducible capability locks, verify host integrations, and compile execution contracts.
• fable-context-thrift: Conserve token budget by eliminating redundant reads, batching queries, and targeting lookups.
• fable-council: Convene a multi-agent council across installed CLI agents to deliberate before finalizing plans.
• fable-wise: Low-level agentic design patterns and cognitive reflexes across Depth, Breadth, Coil, and Mesh.
• fable-spark: Predict the smallest atomic next move, or stay silent when another suggestion would be noise.
• fable-dataviz: Generate accessible, cohesive data visualizations, SVG charts, and dashboard tiles with theme-adaptive styling.
• fable-artifact: Produce source-grounded documents and diagrams that survive outside the conversation.
• fable-simplify: Reduce complexity without quietly changing behavior.
• fable-loop: Poll changing conditions with explicit state machines, budgets, backoff, and honest stop reasons.
• fable-run: Launch the exact runtime artifact and separate spawn, readiness, feature proof, and cleanup.
• fable-memory: Preserve durable facts with scope, provenance, supersession, and secret-safe rules.
• fable-config: Change harness settings with precedence, least privilege, and behavioral verification.
• fable-simulator: Compare against an independent oracle without confusing simulation with production proof.
• fable-cowork: Execute long scoped work autonomously without throwing away lifecycle gates or authorization boundaries.

Creator Pack (2) - Skill Authoring & Domain Specialization

• fable-skill-creator: Author new Skills to the Deep Playbook V2 standard instead of cloning shallow templates.
• fable-domain: Research-grounded domain adapter and workflow generator translating Fable methodology to sector nouns.

Explore the canonical Skill catalog →

Fable Spark: sometimes the best next move is tiny

During a long coding session, the agent usually does not need another page of advice.

It needs one useful move.

reproduce the bug
check the exact installed SDK version
write the failing contract test
compare source and built entrypoints
review the current diff
rerun evidence after the last mutation
stop retrying and diagnose

Or nothing.

Spark is explicitly allowed to stay silent when the current specialist already owns an obvious next step.

get-fable spark

Works with the coding agent you already use

get-fable is portable across 32 AI coding agents, platforms, and IDEs rather than being tied to one model or editor.

Proprietary & Commercial Markets

Agent / Tool	Integration Tier	Key Capabilities
Claude Code (Anthropic)	Full Lifecycle	5 Python hooks (settings.json), 43 canonical skills, rules in CLAUDE.md, Marketplace plugin
Gemini CLI / Google Antigravity (Google)	Full Lifecycle	hooks.json lifecycle triggers, plugin manifest, canonical skills, constitution rules
Grok Build (xAI)	Full Lifecycle	hooks.json lifecycle triggers, Grok plugin manifest, canonical skills, constitution rules
OpenAI Codex & ChatGPT (OpenAI)	Skill + Rule + Plugin	.codex-plugin/plugin.json, ChatGPT OpenAPI Custom Actions, skills in ~/.codex/skills/
Cursor (Anysphere)	Advisory Rule + Plugin	.cursor/rules/fable-lifecycle.mdc, .cursor-plugin/marketplace.json
GitHub Copilot Agent Mode (GitHub / Microsoft)	Advisory Rule	Global rules in ~/.copilot/rules/fable.md & project .github/copilot-instructions.md
Devin (Cognition)	Skill + Rule	Global ~/.devin/instructions.md, rules, and canonical skills in ~/.devin/skills/
Windsurf (Codeium)	Advisory Rule	Global rules in ~/.codeium/windsurf/rules.md & project .windsurfrules
Replit Agent (Replit)	Advisory Rule	Global rules in ~/.replit/rules/fable.md & project .replit.md
Amazon Q Dev (Amazon Web Services)	Advisory Rule	Global rules in ~/.aws/amazon-q/rules/fable.md & project .amazonq/rules.md
Trae (ByteDance)	Advisory Rule	Global rules in ~/.trae/rules/fable.md & project .trae/rules/fable.md
Warp AI (Warp Terminal)	Advisory Rule	Global rules in ~/.warp/rules/fable.md
Kimi K3 (Moonshot AI)	Advisory Rule	Rules in ~/.kimi/rules/fable.md
Atlarix (Atlarix Desktop Copilot)	Advisory Rule	Rules in ~/.atlarix/rules/fable.md
Vellum (Vellum Workflow Platform)	Advisory Rule	Rules in ~/.vellum/rules/fable.md
Codegen (Codegen Platforms)	Advisory Rule	Rules in ~/.codegen/rules/fable.md
Muse Code (Muse)	Advisory Rule	Rules in ~/.muse/rules/fable.md
Junie (JetBrains)	Advisory Rule	Global rules in ~/.junie/rules/fable.md & project .junie/rules/fable.md
Qodo (Formerly CodiumAI)	Advisory Rule	Global rules in ~/.qodo/rules/fable.md & project .qodo/rules/fable.md
Roo Code	Skill + Rule	Global rules ~/.roo/rules/fable.md, skills in ~/.roo/skills/, and project .roomodes

Open-Source & Community Markets

Agent / Tool	Integration Tier	Key Capabilities
Aider (Git-first CLI agent)	Advisory Rule	Global rules in ~/.aider/rules/fable.md & project .aider.prompt.md
Cline (Autonomous BYOK Agent)	Skill + Rule	Global rules in ~/.cline/rules/fable.md, skills in ~/.cline/skills/, and .clinerules
OpenHands (Formerly OpenDevin)	Skill + Rule	Global microagents in ~/.openhands/microagents/, skills in ~/.openhands/skills/
OpenCode (SST)	Skill + Rule	Rules in ~/.opencode/rules/fable.md, skills in ~/.opencode/skills/
Continue (IDE extension layer)	Advisory Rule	Global rules in ~/.continue/rules/fable.md & project .continue/rules/fable.md
Kilo Code (Kilo Platform)	Skill + Rule	Global rules in ~/.kilo/rules/fable.md, skills in ~/.kilo/skills/
Plandex (Terminal multi-file engine)	Advisory Rule	Global rules in ~/.plandex/rules/fable.md & project .plandex/context.md
AutoGPT (Significant-Gravitas)	Advisory Rule	Global rules in ~/.autogpt/rules/fable.md
Kiro	Rule + Hooks	Rules in ~/.kiro/rules/fable.md and lifecycle triggers
DeepSeek Harness (DSH)	Plugin + UI	Cordis plugin bundle (cordis.patch.yml), REST backend, and consumed React Web UI
Pi Code	Advisory Rule	Rules in ~/.pi/rules/fable.md

Integration depth depends on what each host actually exposes:

• Cordis Plugin & Consumed Web UI: DeepSeek Harness (DSH)
• Full lifecycle integration: Claude Code, Antigravity, Grok Build
• Skill + rule integration: Codex, Devin, OpenCode, Roo Code, Cline, OpenHands, Kilo Code, Hermes Agent
• Advisory rule integration: Cursor, Copilot, Windsurf, Replit, Amazon Q, Trae, Warp, Kimi, Atlarix, Vellum, Codegen, Muse, Junie, Qodo, Aider, Continue, Plandex, AutoGPT, Kiro, Pi Code

That distinction is intentional. A host that can load rules but cannot register lifecycle hooks should not be described as if it has enforcement it does not actually provide.

See the host capability matrix →

get-fable install all
get-fable install claude
get-fable install antigravity
get-fable install grok
get-fable install codex
get-fable install cursor
get-fable install copilot
get-fable install devin
get-fable install windsurf
get-fable install replit
get-fable install amazonq
get-fable install trae
get-fable install warp
get-fable install kimi
get-fable install atlarix
get-fable install vellum
get-fable install codegen
get-fable install muse
get-fable install junie
get-fable install qodo
get-fable install roocode
get-fable install aider
get-fable install cline
get-fable install openhands
get-fable install opencode
get-fable install continue
get-fable install kilo
get-fable install plandex
get-fable install autogpt
get-fable install hermes
get-fable install deepseek
get-fable install dsh
get-fable install kiro
get-fable install pi
get-fable install no-mistakes

dsh plugin add imMamdouhaboammar/get-fable

/plugin marketplace add imMamdouhaboammar/get-fable
/plugin install get-fable@get-fable

Quick install

# Bun (recommended)
bun add -g get-fable

# npm (automatically installs skills via npx skills add imMamdouhaboammar/get-fable)
npm install -g get-fable
# or locally in your project:
npm install get-fable

# Homebrew (macOS & Linux)
brew tap imMamdouhaboammar/get-fable && brew install get-fable

# One-line shell installer (CI, Docker, bare metal)
curl -fsSL https://raw.githubusercontent.com/imMamdouhaboammar/get-fable/master/install.sh | bash

# Skill pack only (Vercel / skills.sh)
bunx skills add imMamdouhaboammar/get-fable

# DeepSeek Harness (DSH) Cordis plugin
dsh plugin add imMamdouhaboammar/get-fable

# Claude Code Marketplace
# /plugin marketplace add imMamdouhaboammar/get-fable
# /plugin install get-fable@get-fable

Full install path

Follow these steps once after installing the CLI to get the complete lifecycle active across your agents and project.

Step 1: Install the CLI

bun add -g get-fable
get-fable --version   # confirm binary is on PATH

Step 2: Configure your coding agents

# All agents at once (recommended)
get-fable install all

# Or pick individually
get-fable install claude        # Claude Code: full lifecycle hooks + skills
get-fable install antigravity   # Google Antigravity / Gemini CLI: hooks + plugin
get-fable install grok          # Grok Build (xAI): hooks + plugin
get-fable install codex         # OpenAI Codex + ChatGPT: plugin + skills
get-fable install cursor        # Cursor: advisory rule + plugin
get-fable install copilot       # GitHub Copilot: advisory rule
get-fable install devin         # Devin: skill + rule
get-fable install windsurf      # Windsurf: advisory rule
get-fable install replit        # Replit Agent: advisory rule
get-fable install amazonq       # Amazon Q Dev: advisory rule
get-fable install trae          # Trae: advisory rule
get-fable install warp          # Warp AI: advisory rule
get-fable install kimi          # Moonshot Kimi: advisory rule
get-fable install roocode       # Roo Code: skill + rule
get-fable install cline         # Cline: skill + rule
get-fable install openhands     # OpenHands: skill + rule
get-fable install opencode      # OpenCode: skill + rule
get-fable install kilo          # Kilo Code: skill + rule
get-fable install aider         # Aider: advisory rule
get-fable install continue      # Continue: advisory rule
get-fable install plandex       # Plandex: advisory rule
get-fable install autogpt       # AutoGPT: advisory rule
get-fable install hermes        # Hermes Agent: skill + rule
get-fable install kiro          # Kiro: rule + hooks
get-fable install dsh           # DeepSeek Harness: Cordis plugin + Web UI
get-fable install pi            # Pi Code: advisory rule
get-fable install no-mistakes   # no-mistakes quality gate + pre-push hook

Step 3: Initialize a project

cd your-project
get-fable init

Creates .fable/state.json, .fable/LEDGER.md, .fable/PROGRESS.md, and docs/SPEC.md.

Step 4: Verify health

get-fable doctor          # 46+ system checks: skills, hooks, state, supply chain
get-fable doctor --json-v1  # machine-readable diagnostic envelope
get-fable lint            # ledger + state completion semantics

Step 5: Route your first task

get-fable route "Fix the checkout race condition and verify it with a regression test"

Get the smallest useful next move at any point:

get-fable spark

Step 6: Architecture evaluation (new projects)

get-fable arch-eval "High-throughput fintech ledger with 100k TPS and polyglot datastores"
# -> outputs composite score, monolith lockout decision, dual-transport contract, language matrix

Step 7: Security & quality gates

# Red team scan against a local target
get-fable redteam scan --target http://127.0.0.1:3000 --profile api-logic

# CI/CD baseline diff + CVSS threshold gate
get-fable redteam scan --target http://127.0.0.1:3000 \
  --baseline .fable/baseline.json --fail-on-cvss 7.0

# Auto-heal findings from the last red team run
get-fable route "remediate redteam findings"

# no-mistakes pre-push quality gate
get-fable install-no-mistakes

Step 8: gRPC worker (distributed execution)

The built-in worker-serve command starts the gRPC transport without an actual task executor. An unconfigured worker returns NOT_SERVING and cannot claim tasks or skills were completed. Integrators must supply real taskHandler and skillHandler callbacks on FableWorkerServer. jev-orchestrate --execute requires --worker-addr <host:port> pointing to a configured worker. A completed event counts as successful orchestration only when it includes a matching, verified TOON return packet. Worker-reported verification is not independent proof that the prescribed command was executed.

# Start the transport-only Fable Worker gRPC server (no executor configured)
get-fable worker-serve

# Behavioral evaluation pipeline
get-fable behavior-eval export --out /tmp/fable-behavior-requests.json
get-fable behavior-eval score /tmp/provider-responses.json \
  --out evals/results/agent-behavior-v1.json
get-fable behavior-eval status

Step 9: Autonomous Perpetual Repository Steward (get-fable steward)

Run an unattended maintenance and continuous feature innovation loop over any repository. The steward evaluates live GitHub CI health, pending pull requests, open issues, diff slop, and roadmap backlog through a deterministic 5-tier triage priority matrix.

# Dry-run: Probe repository health and print triage decision without mutating workspace
get-fable steward --dry-run

# Run a single autonomous triage and execution cycle
get-fable steward

# Run perpetual continuous loop (60s interval, watchdog monitoring)
get-fable steward --loop --interval 60 --max-cycles 100

# Output machine-readable JSON v1 envelope
get-fable steward --json-v1

Shell integration (optional)

Add real-time prompt hints and lifecycle aliases to your shell profile:

# Zsh (~/.zshrc)
eval "$(get-fable shell zsh)"

# Bash (~/.bashrc or ~/.bash_profile)
eval "$(get-fable shell bash)"

# Fish (~/.config/fish/config.fish)
get-fable shell fish | source

Aliases enabled: gfr (route), gfs (spark), gfe (evidence), gfc (card), gfl (lint), gfd (doctor), gfm (mutation), gfst (status).

📖 Full Multi-Host & Platform Guide: See docs/INSTALLATION.md for detailed configuration of hooks, shell completions, and individual agent environments.

Behavioral proof: the uncomfortable part is intentional

get-fable treats “the Skill exists” and “the Skill has been proven to behave correctly” as different claims.

A previous version of the catalog had an external-provider evidence run across 115 blinded cases with 115 passes and zero forbidden-action violations.

That run is useful history.

It is not fresh proof for Deep Skill Playbooks V2.

V2 materially changes the instructions and expands the semantic scenario corpus. The evidence hashes should therefore make the old behavioral result stale.

That is a feature, not a regression.

Until the current V2 request bundle is executed against an independent provider and rescored, affected behavioral maturity should remain NOT_CHECKED, not magically inherit the old M4 badge.

The current workflow is:

get-fable behavior-eval export --out /tmp/get-fable-behavior-requests.json
# execute the blinded requests with an independent provider
get-fable behavior-eval score /tmp/provider-responses.json \
  --out evals/results/agent-behavior-v1.json
get-fable behavior-eval status
get-fable doctor --json-v1

The exported bundle is generated from the current Skill corpus, so the README deliberately does not hard-code a V2 request count.

Read the behavioral evidence protocol →

Local-first by default

get-fable is designed to add process without turning your repository into a telemetry product.

• telemetry is disabled by default;
• state and evidence live locally with the project;
• minimal zero-telemetry dependencies (@grpc/grpc-js, @grpc/proto-loader, @toon-format/toon) for high-performance gRPC and TOON serialization;
• Skill installation rejects traversal and symlink escapes;
• the local proxy binds to loopback by default;
• GitHub Actions are pinned to immutable commit SHAs;
• CodeQL, Dependency Review, TruffleHog, and E2E workflows are part of the repository quality surface.

For the full trust boundary, see SECURITY.md.

A few commands you will actually use

get-fable init
get-fable route "your task"
get-fable spark
get-fable arch-eval "your specification"
get-fable doctor
get-fable install-no-mistakes
get-fable worker-serve
get-fable feed list
get-fable graph
get-fable recipes
get-fable packs
get-fable behavior-eval status

Legacy --json output remains available, while supported commands can use the additive versioned --json-v1 envelope.

Read the usage guide →

Distribution

• npm: get-fable
• GitHub Releases: release history
• Homebrew formula: Formula/get-fable.rb
• Agent packaging: Claude, Codex, Gemini, Cursor, OpenCode, Kimi, DeepSeek, Kiro, and Pi manifests ship with the project/package

Documentation

The README tells the product story. The implementation details live here:

• Getting started and CLI usage
• Canonical Skills
• Host compatibility
• Behavioral evidence
• Architecture
• Plugin distribution
• Release process
• Security
• Support
• Contributing

bun add -g get-fable
get-fable init