get-fable

get-fable

What if the coding agent you already use could work more like Claude Fable?

Same model. Better working habits. A much stronger coding loop.

42 connected Skills · 32 AI Hosts · 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

Quick Install · Start here · How it works · The Skills · Docs

⚡ Quick Install

Get up and running with get-fable in under 60 seconds:

Option 1: Universal Skills Installation (Instant AI Agent Superpowers)

If you already use an AI coding tool (Claude Code, Cursor, Codex, Windsurf, Antigravity, Cline, RooCode, etc.), add all 42 connected canonical skills directly to your environment:

# Add canonical skills directly to your AI agent
npx skills add imMamdouhaboammar/get-fable

# Or using Bun
bunx skills add imMamdouhaboammar/get-fable

Option 2: Full CLI Harness & Multi-Host Platform Engine (Recommended)

Install the standalone get-fable CLI engine to enable mechanical lifecycle hooks, workspace state tracking, doctor audits, and automated host distribution:

# 1. Approved Installation via Bun (Fastest)
bun add -g get-fable

# Or via npm
npm install -g get-fable

# Or via the direct automated shell installer
curl -fsSL https://raw.githubusercontent.com/imMamdouhaboammar/get-fable/main/install.sh | sh

# 2. Initialize workspace state machine (.fable/ schema v3)
get-fable init

# 3. Broadcast lifecycle hooks and configs to all 32 supported agent platforms
get-fable install all

# 4. Deploy and link all 42 canonical skills across all agent environments
get-fable skills install all

🤖 Ask Your Agent to Configure & Install get-fable

Prefer to delegate setup to your coding assistant? Copy and paste this prompt directly into your agent (Claude Code, ChatGPT/Codex, Cursor, Windsurf, Gemini/Antigravity, Cline, etc.):

[!TIP] Copy & Paste this prompt to your AI Assistant:

Set up, configure, and verify get-fable for this workspace and my AI coding environment.
Follow the canonical onboarding guide at:
https://github.com/imMamdouhaboammar/get-fable/blob/main/docs/install-and-init-get-fable.md

Please execute the following sequence:
1. Verify runtime requirements (Bun >= 1.3.0, Git, Python 3.9+).
2. Install the latest get-fable CLI globally:
   bun add -g get-fable
   (or: npm install -g get-fable, or run: curl -fsSL https://raw.githubusercontent.com/imMamdouhaboammar/get-fable/main/install.sh | sh)
3. Initialize this workspace's lifecycle state:
   get-fable init
4. Broadcast mechanical lifecycle hooks and platform configurations across all detected agent hosts:
   get-fable install all
5. Deploy all 42 canonical skills across all hosts:
   get-fable skills install all
   (or link via universal skills CLI: npx skills add imMamdouhaboammar/get-fable)
6. Run doctor diagnostics and verify host integration:
   get-fable doctor
   get-fable status
7. Verify that the latest version is active with 0 errors, and summarize how to use get-fable in daily engineering work.

Context & Activation Contract (install-and-init-get-fable):
"End-to-end onboarding, host installation, workspace initialization, supporting toolchain setup, interactive fable-eco capability provisioning, and bilingual (Arabic/English) workflow coaching for get-fable across 32 AI coding platforms and 42 canonical skills. Use when setting up get-fable on a user machine, initializing .fable/ in a repository, installing the 42 canonical skills and 5 Python lifecycle hooks across agent hosts, configuring git quality gates or shell aliases, asking the user whether to provision fable-eco capability profiles, or answering user questions on how to use get-fable in daily engineering work. Do NOT use for executing individual bounded coding cards once setup is complete (use fable-execute or fable-tdd) or performing standalone security penetration scans (use fable-redteam)."

[!NOTE] 💡 Open-Source Skills Edition: The current version of get-fable is 100% Free & Open-Source (AGPLv3) as connected canonical skills and lifecycle harnesses.

🚀 Coming Soon: Premium Pro Get-Fable MCP: We are currently engineering the Premium Pro Get-Fable MCP — the most advanced autonomous engineering harness, dual-plane microkernel, East-West gRPC orchestration, and real-time cognitive loop server for enterprise and frontier agents. Stay tuned!

I kept coming back to one question

What if you could take the coding agent you already have — Codex, Claude Code, Gemini, OpenCode, Cursor, a local model, a cheaper model, whatever you happen to use — and make it work more like a serious coding partner?

Not by swapping the model.

Not by writing one giant system prompt and hoping it still matters forty minutes later.

But by changing what happens around the model.

That question is where get-fable started.

Because when people talk about a great coding agent, they usually talk about the model first. And obviously the model matters. A lot.

But the model is not the whole experience.

A strong coding partner also knows when to inspect before touching anything. When to stop guessing and check the current docs. When a bug needs a failing test before a fix. When a task is large enough to plan. When two workers can genuinely work in parallel — and when they absolutely should not. When a green test is stale because the code changed afterward. When three failed attempts mean rethink the diagnosis, not try a fourth variation of the same patch.

That behavior is not just raw intelligence.

A lot of it is the harness.

get-fable is an attempt to bring that harness to almost any coding agent.

The goal is deliberately ambitious: take the agent you already use and push its working behavior closer to the discipline you expect from a top-tier coding partner.

No, it does not magically turn a small local model into Claude Fable.

But it can give that model a better way to approach real software work.

And when the model underneath is already strong, the harness has more to work with.

The model is only part of the agent

Two agents can use completely different models and still make the same mistakes.

They can both start editing too early.

They can both lose the original plan halfway through a long task.

They can both rely on stale knowledge about an API.

They can both patch a bug without proving the bug first.

They can both run tests, change five more files, and still treat the old test run as proof.

They can both split work across subagents because the files look different while the workers are quietly changing the same contract.

They can both keep retrying an approach that clearly is not working.

And they can both end with the most dangerous sentence in agentic coding:

“Done.”

get-fable works on that part of the problem.

It does not replace the model.

It surrounds it with a way of working.

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 gives the agent 46 connected specialist Skills across 8 packs and a deterministic lifecycle that decides when each one should take over.

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.

The hard-earned engineering reasoning lives directly in the Skill — providing reliable, deterministic execution across all model tiers.

42 Skills across 8 Packs. One way of working.

Core Pack — Lifecycle Navigation & Execution

• get-fable — choose the next specialist from intent + durable state, with precedence for failure, security, stale proof, and unknowns.
• fable-discover — trace real repository/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 → failure mode → evidence matrix and try to falsify the implementation.
• fable-recover — stop blind retries and rebuild causal confidence after repeated failure.
• fable-method — step-by-step problem-solving loop classifying asks, defining done, acting surgically, and verifying by observation.

Intelligence Pack — Primary Source Grounding

• fable-research — resolve current external facts against version-appropriate primary sources.

Build Pack — Disciplined Implementation

• fable-tdd — prove the behavior gap through the right test boundary before production mutation.
• fable-delegate — parallelize only when write, semantic, and verification independence are real.
• fable-native-code — codebase idiom matching and anti-bloat policy ensuring diffs read like native code.
• fable-scope-discipline — anti-scope-creep and atomic diff policy keeping changes strictly bounded to requests.

Proof Pack — Adversarial Review & Security

• fable-review — inspect the actual diff 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 enterprise-grade automated penetration testing, CVSS v3.1 scoring, circuit breaker protection, SARIF reports, and cryptographic run attestations.
• fable-heal — automatically synthesize, apply, and verify security remediations for vulnerabilities identified by fable-redteam.
• fable-test — orchestrate, author, and verify automated tests enforcing Test-Guard rules and test-value calculus.
• fable-prove-it — evidence precedence and verification rung enforcement preventing unverified claims.
• fable-judge — 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 — work-identity deduplication, typed invalidation, and deterministic evidence reuse preventing repetitive test runs and agent thrashing.

Delivery Pack — Production Readiness & Continuity

• fable-release — audit and certify repository merge and release readiness against required quality gates, clean git working trees, and verified distribution artifacts.
• fable-handoff — create a real resumability contract for another agent/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.

Evolution Pack — Agent Learning & Durable Knowledge

• fable-learning — extract structured learnings, reusable patterns, failure lessons, and agent-kernel Playbooks from completed sessions.

System Pack — Architecture, Scale, Reflexes & Cognitive Primitives

• fable-architecture — evaluate scale, domain decoupling, and resource intensity vectors, lock out monolithic scaffolds when thresholds cross limits, enforce dual-transport boundaries (REST vs. gRPC), and prescribe multi-language stack matrices before scaffolding.
• fable-eco — provision curated capabilities, manage reproducible capability locks, verify host integrations, and compile capability execution contracts.
• fable-context-thrift — conserve token budget by eliminating redundant reads, batching queries, and targeting lookups.
• fable-council — convene 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 just be noise.
• fable-dataviz — choose truthful visual encodings, preserve metric semantics, and audit for misleading scales/transformations.
• 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, host-capability honesty, 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 — Domain Specialization

• 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), 46 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
Hermes Agent	Skill + Rule	Rules in ~/.hermes/rules/fable.md and Hermes tool skills

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 →

Installation commands by host

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

DeepSeek Harness (DSH) Plugin installation:

dsh plugin add imMamdouhaboammar/get-fable

When configuring the DSH plugin's projectRoot, fresh routing state belongs to that project even when the host starts elsewhere. A routing preview does not create .fable state; applying the route writes it to the configured project.

Claude Code marketplace installation:

/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          # 53 system checks — skills, manifests, 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 — Curated Capability Ecosystem (fable-eco)

Provision verified development tools, fast search utilities, and curated MCP servers into your workspace with reproducible lockfiles (.fable/eco.lock):

# Discover which capabilities are installed on your machine
get-fable eco discover

# Plan capability installation for a curated profile (core, dev-fast, polyglot, mcp-core, agency)
get-fable eco plan core

# Provision the capabilities automatically
get-fable eco install core --yes

# Verify capability health and lockfile integrity
get-fable eco doctor

Profile	Included Capabilities	Target Use Case
core (Recommended)	ripgrep, fd, jq, git-lfs, gh	High-speed file search, JSON processing, and GitHub automation
dev-fast	core + uv, bun, ast-grep, hyperfine	Lightning-fast Python/TypeScript tooling and AST analysis
polyglot	dev-fast + rustup, go, just, shellcheck	Multi-language systems engineering and CI/CD validation
mcp-core	Curated MCP servers (filesystem, git, fetch)	Model Context Protocol tool enrichment for agent hosts
agency	Multi-agent CLI orchestration helpers	Parallel worker delegation and multi-model council deliberation

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 to 1,105 blinded evaluation cases across all 46 canonical skills. 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 46-skill corpus (1,105 blinded behavioral evaluation cases), ensuring transparent, reproducible evaluation before independent provider scoring.

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, Grok, and Pi manifests ship with the project/package

Documentation

The README tells the product story. The deep technical specifications and guides live here:

• Install & Initialization Guide (install-and-init-get-fable)
• Getting Started & CLI Usage Guide
• Canonical Skill Catalog (42 Skills)
• Host Compatibility & 32 Platform Matrix
• Multi-Host Installation Deep Dive
• Lifecycle State Machine & Evidence Protocol
• Deterministic Routing Precedence
• 5 Mechanical Lifecycle Hooks
• Curated Capability Ecosystem (fable-eco)
• System Architecture (ADR 0007)
• Behavioral Evidence & Evaluation Protocol
• Multi-Platform Plugin Distribution
• Release Verification & Gate Protocol
• Security & Trust Boundaries
• Support & Community
• Contributing

A better model helps.

A better harness helps too.

bun add -g get-fable
get-fable init

Get started · Explore the Skills · View releases · Report an issue

GNU AGPLv3 licensed

_{get-fable is an independent open-source project and is not affiliated with Anthropic.}