⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

claude-code

rayp11@rayp11⭐ 15 stars· last commit 1mo ago· 8 open issues

Delegate coding tasks to Claude Code, an expert AI coding agent powered by Anthropic

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 15 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Truly Local. Always On. Ready for Tasks.

Your AI assistant, running on your hardware, working for you around the clock.

Python Ollama License

Discord


QuestChain is an AI assistant that runs entirely on your machine. No cloud, no subscriptions, no usage limits. Just your hardware running a capable local model 24/7. It reads your files, runs shell commands, searches the web, schedules jobs, and works through your task list while you sleep. Nothing leaves your machine.


Contents


Why QuestChain?

I tried OpenClaw and was having a lot of fun playing around with it. However, I couldn't afford the api token cost and I wasn't able to run local models quickly without having to buy even more expensive hardware. So I was inspired to create a framework which could run models as small as 3B autonomously and productively.

QuestChain is that framework: a party of micro agents all jam-packed with tool loadouts for specific tasks, fully autonomous, and with a twist of gamification.

At a glance

QuestChain
LanguagePython
Lines of code~9,000
Source files40
Multi-surface (CLI, Telegram, Web)✅
RPG progression✅
Custom async agent engine✅

RPG Progression

QuestChain isn't just a tool. It's a companion you build over time. Every agent starts at Level 1 and earns XP through real work: tool calls, completed tasks, background jobs, and extended conversations. The more your agent works, the stronger it gets.

Each agent has:

  • Levels (1-20)
  • A class
  • Achievements
  • Progression
  • Behavior
  • Tools

Classes

Classes are QuestChain's micro-agent system. Each class is a specialized agent with its own role, tool loadout, and independent progression. Keeping agents focused on a single domain is best practice for local models. A smaller context, fewer tools, and a clear identity means better decisions and fewer hallucinations.

ClassIconSpecialtyTool Preset
Custom🌀You decideYou configure
Coordinator🧭Routes work and communicates statusNo execution tools
Keeper📚Files & knowledgeFile tools
Explorer🔭Research & discoveryWeb search + browse
Builder⚒️Code & systemsFiles and shell; optional Claude Code
Planner🔮Planning & strategyFile tools
Scheduler⏱️AutomationCron only

Coordinator and specialists

Chat with Perseus to route work to Argus (research), Athena (workspace knowledge), Talos (building), or Zeus (planning and advice). Each specialist streams its own response under its own name. Direct chat is always available.

Perseus uses the same chat engine as every other agent: he can answer you directly or hand your request to a specialist. A conversation is one shared thread in the interface, with separate saved context for each agent. Perseus also receives attributed records of the other agents' requests, replies, and outcomes in that thread, so he can route follow-ups and remember completed work. Specialists see their own interactions, including work routed to them and any context supplied with a handoff. Starting a new thread starts fresh for all agents; reopening one restores their saved context. Every agent summarizes older history as the estimated context budget fills, including during tool-call loops. Use the web chat's conversation selector, terminal /history, or Telegram /history to resume a thread.

Athena's workspace knowledge role includes creating, editing, and deleting files with the built-in write_file, edit_file, and delete_file tools. These tools are enabled by default for the Keeper role and remain configurable per agent. Deletion accepts individual workspace files, rejects directories and symbolic links, and stays inside the workspace. Existing untouched Keeper presets gain deletion once when upgrading; customized permissions are preserved.

Create additional agents in the web UI, terminal, or Telegram with a name, tools, system prompt, and guidance describing when the coordinator should call them. Legacy agents are archived under ~/.questchain/legacy and can be migrated explicitly through any interface. Agent guide.

Cron Jobs

Automate recurring work from the Cron Jobs page, the terminal /cron menu, or Telegram /cron commands. Jobs share one persistent scheduler and run while QuestChain is open.

Each job has a name, instructions, a schedule, timezone, and assigned agent. The web UI uses a standard time selector; terminal and Telegram commands accept cron expressions. Create, edit, pause, resume, run now, or delete a job. The web UI shows its next run, last status, and result. Results also appear in the terminal, or on Telegram when connected.

/cron add Morning summary | 0 9 * * mon-fri | America/New_York | Summarize my notes
/cron list
/cron show JOB_ID
/cron pause JOB_ID
/cron resume JOB_ID
/cron run JOB_ID
/cron delete JOB_ID

Use weekday names (mon–sun); numeric weekdays follow APScheduler: Monday=0, Sunday=6. Pausing or deleting a job prevents future runs; a run already underway finishes.

The old quest folder and periodic quest runner have been retired. Existing quest files remain on disk and are no longer executed. Recreate desired recurring tasks as cron jobs. The --quests and --no-quests startup flags have been removed.


Install

Step 1: Install Ollama

Download and install Ollama from ollama.com/download, then start it:

ollama serve

Leave it running, then open a new terminal for the next step.

Step 2: Install QuestChain

Windows: open PowerShell and run:

powershell -ExecutionPolicy Bypass -c "irm https://raw.githubusercontent.com/RayP11/QuestChain/master/install.ps1 | iex"

macOS / Linux: open a terminal and run:

curl -fsSL https://raw.githubusercontent.com/RayP11/QuestChain/master/install.sh | bash

Step 3: Run

questchain start

On first run, QuestChain walks you through a short onboarding conversation and optionally sets up Telegram. After that, it remembers who you are.

Web search (optional): Run /tavily inside QuestChain to set up your free Tavily API key and enable web search and browsing.

Startup Cheat Sheet

questchain start                      # Start with default model
questchain start -m qwen3:4b          # Use a specific model
questchain start -t <thread-id>       # Resume a previous conversation
questchain start --web                # Start with web UI (gateway + CLI)

Updating

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/claude-code/SKILL.md3.2 KBupstream ↗
    ---
    name: claude-code
    description: Delegate coding tasks to Claude Code, an expert AI coding agent powered by Anthropic
    ---
    
    # Claude Code Skill
    
    ## When to Use
    
    Use the `claude_code` tool when the user asks you to:
    - Write, create, or generate code
    - Debug or fix code issues
    - Refactor or improve existing code
    - Create new files or projects
    - Make changes to a codebase
    - Explain code in detail
    - Write tests
    - Review or analyze code
    
    Look for keywords like: "code", "write", "build", "implement", "fix", "debug", "refactor", "create a script", "make a program", "review", or any request that involves programming.
    
    ## When NOT to Use
    
    Do not use `claude_code` for:
    - General knowledge questions
    - Web searches
    - File reading (use your built-in read_file tool)
    - Simple shell commands
    - Memory/notes operations
    
    ## Parameters
    
    ### `task` (required)
    The coding task or prompt. Be specific about what to build/change, which files are involved, and any constraints.
    
    ### `complexity` (optional, default: `"medium"`)
    Controls which Claude model and timeout to use:
    
    | Value | Model | Timeout | Use When |
    |-------|-------|---------|----------|
    | `"simple"` | Haiku (fast) | 5 min | Explanations, small edits, quick code questions |
    | `"medium"` | Sonnet (capable) | 10 min | Most coding tasks, bug fixes, new features |
    | `"complex"` | Sonnet (capable) | 15 min | Large refactors, multi-file changes, complex implementations |
    
    ### `mode` (optional, default: `"code"`)
    Controls what Claude Code is allowed to do:
    
    | Value | Permissions | Use When |
    |-------|------------|----------|
    | `"code"` | Read + write/edit files | You need code changes made (default) |
    | `"review"` | Read-only access | Code review, analysis, understanding code without changing it |
    
    ### `context` (optional)
    Additional project context to include with the task. Pass relevant information from the conversation that Claude Code might need, such as error messages, user requirements, or file paths mentioned earlier.
    
    ## Examples
    
    ### Simple task — explain code
    ```
    claude_code(
        task="Explain what the create_genie_agent function does in genie/agent.py",
        complexity="simple",
        mode="review"
    )
    ```
    
    ### Medium task — fix a bug
    ```
    claude_code(
        task="Fix the bug where web_search results are not being displayed correctly",
        complexity="medium",
        mode="code",
        context="The user reported that search results show 'None' instead of snippets. Error traceback points to tools/web_search.py line 15."
    )
    ```
    
    ### Complex task — implement a feature
    ```
    claude_code(
        task="Add a new REST API endpoint that exposes Genie as an HTTP service with streaming responses",
        complexity="complex",
        mode="code",
        context="Should use FastAPI, support SSE streaming, and integrate with the existing agent.py create_genie_agent function."
    )
    ```
    
    ### Code review
    ```
    claude_code(
        task="Review the Telegram bot integration for security issues and potential improvements",
        complexity="medium",
        mode="review"
    )
    ```
    
    ## Writing Good Task Prompts
    
    Be specific in the task you send to Claude Code. Include:
    - What to build or change
    - Which files or languages are involved
    - Any constraints or requirements the user mentioned
    - Use `context` to pass error messages, stacktraces, or conversation details
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/rayp11-questchain-skills-claude-code.md

// REPO STATS

15 stars
8 open issues
Last commit: 1mo ago