Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    DragonhoardEmpystemic

    0

    Self-improving harness for coding agents, no fine-tuning: plan into task packs, verified DONE, lessons gated by a screen, a judge and you. Claude Code, OpenCode, Codex, Cline.

    $5

    /mo

    Subscription · cancel anytime

    Secure checkout via Stripe

    • Always the latest version
    • Delivered live to your agent via MCP
    • Cancel anytime, access ends at period end
    Security scanned
    DragonhoardEmpystemic

    DragonhoardEmpystemic

    Example session with this skill installed

    /dragonhoard:next Task: M1-T01 Implementation of the Auth interface. Load the pack and start the build loop.

    • Read your context and instructions
    • Compiled the dragonhoardempystemic

    I have started the workflow for task

    M1-T01: Implementation of the Auth interface. The task status has been updated to IN_PROGRESS in STATUS.md and the milestone journal.

    Task Execution Report: M1-T01

    1. Planning & Context

    • Goal: Implement src/auth.ts based on the interface defined in docs/auth_spec.md.
    • Scope: src/auth.ts, tests/auth.test.ts.
    • Lessons Loaded: L01: Use async/await for all DB calls, L04: Ensure 401 status for expired tokens.

    2. Pre-Build Verification

    • Interface Check: Found AuthInterface in src/types.ts at line 42.
    • Baseline Checks: Ran npm run lint and npm run test. Result: Green (42 tests passed, 0 failed).

    Focused Test: Created tests/auth.test.ts. Ran test and confirmed it failed with ReferenceError: Auth is not defined as expected.

    3. Implementation (Attempt #1)
    Modified src/auth.ts to implement the login and validate methods.

    4. Post-Build Testing

    • Focused Test: tests/auth.test.ts passed.
    • Standard Checks: npm run lint passed. npm run test passed (43 tests total).

    5. Recording

    • Journal entry created at tasks/M1-T01.journal.md.
    • Milestone M1-auth-scaffold updated.

    Next steps

    • Run /dragonhoard:next to begin the next task: M1-T02: JWT Token Provider.
    • Run /dragonhoard:learn to review if the token handling logic should be saved as a lesson.
    • Run git commit -m "feat: implement auth interface M1-T01" to persist changes.
    $5/mo

    Subscription · always the latest version

    • Secure checkout via Stripe
    • Cancel anytime
    • Delivered live via MCP

    About this skill

    plan · explore · verify · build · test · record one task at a time, learning as it goes

    tests MIT license Claude Code plugin Python stdlib only

    A self-improving harness for coding agents: it gets better at your project with every task, without fine-tuning, and without letting the model rewrite its own rules.

    The weights never change. What improves is the context: failures and fixes become lesson candidates, and each candidate passes a deterministic screen, a frontier-model judge and your approval. From the next task on, every model you use works with it, including a free one.

    Terminal demo: init a workspace, get the next task, the lesson screen rejects an injected instruction, a real lesson is approved, the session-start hook loads it, and stats shows lessons cited across the 96-task trial

    Learns, gated. Failures and fixes become lessons, each with provenance and a revoke. Nothing is approved automatically. One task, small context. Your plan becomes milestones and self-contained task packs; the agent loads one pack, not the whole repo. Evidence, not claims. Failing test first, real command output in the journal, and check must PASS before a task counts as done. Memory across sessions. Append-only logs and a generated digest let a fresh session pick up where the last one stopped. Frontier judge, cheap builder (optional). Hybrid mode lets a free OpenCode model build while Claude Code judges and re-verifies every result. Proven on a real build. In an open reliability trial, dragonhoard took a one-page plan to a playable 3D kart racer in 96 tasks with zero false "done"s. A headless OpenCode builder did most of the work for $4.60 of paid tokens while Claude Code judged. Results, evidence and what failed.

    Runs as a Claude Code plugin, and in OpenCode, Codex CLI, Cline or any agent that reads AGENTS.md. How it compares with Superpowers, Spec Kit, BMAD and others: docs/compare.md.

    How one task runs Each session works exactly one task through plan → explore → verify → build → test → record, then stops.

    • Step: What you get
    • plan: A wrong or stale pack stops the task instead of being quietly rewritten, so scope never drifts.
    • explore: Cheap parallel scouts for facts, spikes in isolated worktrees for open choices. Each choice is logged once and not argued again.
    • verify: No building on interfaces that don't exist or on a build that is already red. The test fails first, for the expected reason.
    • build: The diff stays inside the pack's file list: small, reviewable changes.
    • test: Two failed attempts at the same issue mean BLOCKED: no endless retry loop, no fake DONE.
    • record: Journal, events.jsonl and DIGEST.md let the next session start cold with full memory, and let you audit every claim.

    How it learns

    This is self-improvement through context rather than weights: the approach of Agentic Context Engineering (ACE, ICLR 2026). ACE improves agents by growing an itemized playbook, and it warns that letting the model rewrite its whole context causes "context collapse". dragonhoard's lessons are itemized, append-only and gated, so a bad lesson can't quietly overwrite a good one, and every lesson has an owner.

    What the trial showed

    7 candidates: 6 approved, 1 rejected. The rejected one was an injected "ignore previous instructions" lesson, stopped by the screen. Lessons carry across models. Most were approved while Claude built (M0–M3); in the hybrid phase (M4–M10), the cheaper OpenCode builder cited a lesson in 40 of its 82 journals. Not measured yet: how much the lessons raise the first-pass rate. That needs a lessons-on vs lessons-off run, which is designed in evals/lessons-ab. See it for your own project with dragonhoard.py stats. It prints, per milestone, the first-pass rate, the lessons in force and the journals that cite one.

    Modes

    • /dragonhoard:init asks which of two delivery modes to use:

    Full Claude Code (solo): this session builds; scout, spiker and judge are Claude subagents. Claude Code + OpenCode (hybrid): Claude Code orchestrates, judges and verifies with /dragonhoard:conduct; a headless OpenCode session builds each task on a cheaper or free model. Trade-offs, setup and measured costs: docs/modes.md.

    Install Requires python3 (stdlib only).

    Claude Code (plugin)

    • /plugin marketplace add edwinidrus/dragonhoard
    • /plugin install dragonhoard@dragonhoard

    or try a local clone for one session:

    claude --plugin-dir /path/to/dragonhoard OpenCode, Codex CLI, Cline, or any agent that reads AGENTS.md (copied into your project):

    git clone https://github.com/edwinidrus/dragonhoard.git ~/dragonhoard cd your-project python3 ~/dragonhoard/scripts/dragonhoard.py install --host opencode # or codex | cline | generic install copies the CLI and templates to .dragonhoard/, puts the skills where the host looks for them (as dragonhoard-init, dragonhoard-next, …), and writes role agents where the host supports them. It also adds a marked block to AGENTS.md (Cline: .clinerules/dragonhoard.md) that tells the agent to read the digest at session start. Re-run it to upgrade. Text outside the markers is never touched.

    • Host: Skills, Roles on their own model, Tier
    • Claude Code: plugin, yes (subagents), full
    • OpenCode: .opencode/skills/, yes (.opencode/agents/), full
    • Codex CLI: .agents/skills/, yes (.codex/agents/*.toml), full
    • Cline: .cline/skills/ (enable Skills in settings), no: inline, judge pauses, inline
    • Generic (Cursor, Gemini CLI, Copilot, …): .agents/skills/, no: inline, judge pauses, inline

    Details and sources: docs/hosts.md.

    Use

    In hybrid mode, /dragonhoard:conduct runs the same loop and a headless OpenCode session builds.

    • Command: What it does
    • /dragonhoard:init: Asks where the workspace lives (implementation/, improvement/, or your choice), confirms your check commands, then scaffolds the root files.
    • /dragonhoard:shape <plan.md>: Proposes a milestone cut and waits for your OK. Then writes the milestone folders, STATUS.md and task packs for the first milestone. /dragonhoard:shape M2 writes the next milestone's packs when it comes up.
    • /dragonhoard:next: Works exactly one task through the loop, records real evidence, and stops.
    • /dragonhoard:quick "<fix>": A small fix with no milestones: the same loop (lessons, failing test first, checks, journal) as one quick task Q<nn>. Hands off to shape if it grows.
    • /dragonhoard:explore: For an open choice: cheap parallel retrieval, up to 3 parallel spikes in isolated worktrees, a comparison by a frontier model. You pick; the decision is logged.
    • /dragonhoard:learn: Drafts lessons from journals, screens them deterministically, has the judge review them, then asks you to approve each. revoke L<nn> removes one.
    • /dragonhoard:models: The current model suggests which model fits each role, using the host's model list and the journey's evidence; you confirm.
    • /dragonhoard:conduct: Hybrid mode only. Delegates each task to the OpenCode builder, judges its requests, verifies every result (dragonhoard.py verify), escalates repeated failures, and runs gates.

    On other hosts the commands are the skills dragonhoard-init, dragonhoard-next, and so on.

    At session start, the digest is printed: by a hook in Claude Code, and through the AGENTS.md instruction elsewhere. Nothing is printed in projects without dragonhoard.json.

    What it creates in your project dragonhoard.json # {"root": "...", "checks": [...]} <root>/ ├── README.md CONSTITUTION.md STATUS.md ├── DIGEST.md LESSONS.md # generated from the logs ├── logs/events.jsonl # what happened, across the journey ├── logs/lessons.jsonl # lesson ledger: approved, rejected, revoked ├── templates/ # TASK.md + phase skeletons ├── quick/Q<nn>-<slug>.journal.md # quick tasks, outside the milestones └── M<n>-<name>/{CONSTITUTION,PLAN,PROGRESS,GATE}.md, tasks/<pack>.md, tasks/<pack>.journal.md Models Models are configured per role in dragonhoard.json. No model names are hardcoded: the current model suggests a mapping with /dragonhoard:models and you confirm it.

    • Role: Needs, Claude Code default, Job
    • scout: fast, cheap, reliable tool use, haiku, Read-only fact retrieval with sources. Run in parallel.
    • spiker: solid coding at mid cost, sonnet, One throwaway prototype per option, each in its own git worktree.
    • judge: strongest available reasoning, opus, Compares spike evidence and reviews lessons. Advises only: it can add warnings, never approve.

    Other hosts start with no models set. On hosts that can't run a subagent on its own model, the judge step pauses and asks you to switch the session to the judge model.

    Every lesson passes four gates: deterministic screen → judge → your approval → used from the next task on. Nothing is approved automatically.

    License MIT. See LICENSE.

    If the dragon saved you from a false "done", a star helps other people find it.

    Requires Python 3. Hybrid mode needs opencode on PATH. No multi-task concurrency in one session. Scaffolds specific root files.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 4 days ago

    Requires

    Python
    Off MCP
    Playwright
    Node.js
    vite
    rea-agents
    Git

    Permissions

    Terminal / Shell
    Environment Variables
    Listed4 days ago

    What's inside

    Frequently Asked Questions

    Dragonhoard prevents 'agent drift' by wrapping your AI in a rigorous plan-explore-verify-build-test loop, ensuring every code change is backed by evidence and passes automated check commands before being finalized.

    This skill is optimized for Claude Code and OpenCode, specifically utilizing a hybrid model approach where a high-reasoning model acts as a judge while more efficient models handle the execution.

    The 'Automated Memory' feature harvests lessons from every successful or failed task and converts them into gated procedural rules that are automatically loaded into all future sessions to prevent recurring bugs.

    You will receive the `dragonhoard.py` Python-based CLI, the core system prompts for orchestration, and a comprehensive integration guide for setting up your project root and delivery modes.

    Yes, Dragonhoard is language-agnostic and works with any project that supports standard CLI check commands like `npm`, `pytest`, `cargo`, `make`, or `ruff`.

    While it is highly effective for large-scale refactoring, the tool requires a structured project root and does not currently support multi-task concurrency within a single active session.

    New in Agents & Orchestration