Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    hutch: sandboxed delegation to cheaper coding agents

    1

    Write a precise brief and a narrow allow-list of paths 3.

    Free

    Security scanned
    hutch: sandboxed delegation to cheaper coding agents

    hutch: sandboxed delegation to cheaper coding agents

    Example session with this skill installed

    Use hutch to add seconds and days to parseDuration in src/duration.js, and make it throw on invalid input instead of returning 0. Keep it on a cheap model and only touch that file and its test.

    • Read your context and instructions
    • Compiled the hutch

    Use hutch to add seconds and days to parseDuration in src/duration.js, and make it throw on invalid input instead of returning 0. Keep it on a cheap model and only touch that file and its test.
    bakhodir@MacBook-Pro-Bakhodir .hutch % cat /private/tmp/claude-501/-Users-bakhodir--hutch/a86ebaac-0b22-41de-8646-ff383ba5ae4d/scratchpad/agensi/demo-result.md

    Summary

    The task ran in the hutch sandbox on a cheap model (HUTCH_KIND=script → deepseek-v4.1-flash on OpenCode Go) and took 7 min 18 s. hutch verify passed, and I reviewed the diff and re-ran the tests myself. parseDuration now supports d, h, m, s and throws a RangeError on anything it cannot parse. Ready to take: 3 commits, 2 files.

    What I did

    StepCommandResult
    State checkhutch statusmachine ok, project configured
    Brief + allow listbrief.md, allow = src/duration.js, test/duration.test.js4 behaviour rules, tests first, 2 commits, out of scope listed
    Model rulehutch needs-pro duration-unitsno sensitive paths → cheap kind allowed
    RunHUTCH_KIND=script hutch run duration-unitsexit 0, run.err empty, self-review.md written
    Verifyhutch export + hutch verifyboth files allowed, none protected, 15/15 tests pass offline
    My reviewread the diff, ran tests on the host, re-ran 3 mutationsall confirmed (see below)

    Sandbox isolation (hutch isolation, excerpt)

    model host via proxy http=400
    blocked proxy https://github.com
    blocked proxy https://registry.npmjs.org
    blocked proxy https://api.anthropic.com
    blocked direct https 1.1.1.1
    blocked dns github.com
    blocked host.docker.internal:22
    blocked host.docker.internal:5432
    CapEff: 0000000000000000
    

    Only the model API answers; every other host, port and DNS lookup is blocked, and the container has no capabilities.

    The change

    const UNITS = [
      ["d", 86_400_000],
      ["h", 3_600_000],
      ["m", 60_000],
      ["s", 1_000],
    ];
    
    // Ordered optional groups allow each unit at most once. The pattern is anchored
    // at both ends so nothing may surround the parts.
    const DURATION_PATTERN = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/;
    
    export function parseDuration(input) {
      if (typeof input !== "string" || input === "") {
        throw invalidDuration(input);
      }
      const match = DURATION_PATTERN.exec(input);
      if (match === null) {
        throw invalidDuration(input);
      }
      let total = 0;
      for (let index = 0; index < UNITS.length; index += 1) {
        const value = match[index + 1];
        if (value !== undefined) {
          total += Number(value) * UNITS[index][1];
        }
      }
      return total;
    }
    

    Commits from the sandbox

    be4c451 fix: always throw RangeError for non-string input
    c057dce feat: parseDuration supports d and s and rejects invalid input
    fbceb8d test: cover seconds, days and invalid input for parseDuration
    

    The sandbox agent's own independent review caught two issues before it finished, a wrong comment about the regex anchor and a non-string input that could throw TypeError instead of RangeError, and fixed both in be4c451.

    Verification

    Tests: 15/15 pass in the offline container and again on the host. The 2 original tests are unchanged (the diff removes no test lines).

    • Paths: only src/duration.js and test/duration.test.js changed. No dependency or config files were touched.
    • Mutations I re-ran myself (the sandbox reported 10, all caught):
    MutationTests that fail
    drop the ^ anchor7
    drop the empty-string guard1
    allow a repeated day unit (? → *)1

    Residual notes: very large numbers overflow to Infinity, and 01h / 0s are accepted. The brief did not forbid either, and the old code behaved the same way.

    Next steps

    1. Take the work: git switch -c duration-units refs/hutch/duration-units.
    2. Decide whether 0s and very large values should be rejected; if so, that is a follow-up task of the same size.
    3. hutch rm duration-units after merging.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    hutch splits coding work the way a senior engineer splits it with a junior: the cheap agent writes the code, your main agent writes the brief and verifies.

    This skill teaches your host agent (Claude Code, Codex CLI and others) the hutch loop:

    1. hutch status – detect what is missing on the machine or in the project, and set it up with your answers
    2. Write a precise brief and a narrow allow-list of paths
    3. Run the task in the sandbox with a model chosen by the kind of work
    4. hutch verify – changed paths are allowed and not protected, the project's checks pass offline
    5. Review the diff itself before taking the commits

    Isolation: the container has no capabilities, sees only its own clone of the repository, and reaches only the model API through an allowlist proxy. Results come back as a git bundle.

    Honest limits

    • The skill drives the hutch CLI; it does not replace it. You need Docker, git and an OpenCode Go subscription or a DeepSeek API key.
    • The model provider sees the code you send. Never put production data or credentials in a task.
    • verify passing is not acceptance – the skill makes your agent review the diff.

    Free and open source (Apache-2.0): https://github.com/byarashboev/hutch

    Requires Docker and local CLI installation. Sandbox has no host access or general internet access. Task scope is limited to files defined in the allowlist.

    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 9 days ago

    • Free with an Agensi account

    Requires

    Opencode
    Deepseek
    hutch CLI
    Docker
    Git
    python3
    macOS or Linux

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables

    Allowed Hosts

    opencode.ai
    deepseek.com

    File Scopes

    ~/.hutch/**
    ~/hutch/**

    Shell: runs the hutch CLI and git. Write files: the task brief and allow-list. Network: git clone of hutch at install time; inside the sandbox only the model API is reachable. Env vars: HUTCH_KIND and related settings. The API key is stored by the user in the OS keychain; the skill never asks for it in chat.

    Listed9 days ago

    What's inside

    Frequently Asked Questions

    Bounded coding tasks with clear files and tests: a feature in one module, a bug fix, missing tests. A cheaper model writes the code; your main agent only writes the brief and reviews the result. Not a fit for tasks that need the network, databases or other services (the sandbox reaches only the model API) or for large cross-cutting refactors. Sensitive code such as money, auth or concurrency requires a strong model.

    macOS or Linux with Docker, git and python3, plus an OpenCode Go subscription or a DeepSeek API key. The pinned opencode binary is arm64-only for now; on x86-64 you add its checksum to one Dockerfile line. Windows is not tested.

    It works on its own clone of your repository, never on your checkout. hutch verify rejects any change outside the task's allow list or in a protected path (dependency files, CI, agent instructions, secrets), then runs your checks offline. Nothing reaches your repository until you review the diff and take the commits.

    Only to the model provider you choose. The sandbox reaches nothing else: package registries, GitHub, DNS and your host's ports are blocked. Never put production data or credentials into a task.

    New in Agents & Orchestration