Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    gwitg

    1

    Delegate Codex work to subagents without progress polling.

    Free

    1 useSecurity scanned
    gwitg

    gwitg

    Example session with this skill installed

    I need to implement a new authentication flow, add unit tests, and get a quick independent review of the design.

    Use gwitg on this task.

    • Implement the core auth flow in the current agent
    • Delegate unit test creation to a subagent named auth-tests
    • Delegate an independent design/code review to a subagent named auth-review
    • Use the default worker policy (6-luna with high reasoning effort)
    • Do not poll running subagents for progress
    • Continue independent work in the parent while the delegated workers run
    • Integrate the completed results only after each worker finishes
    • Read your context and instructions
    • Compiled the gwitg

    I am using gwitg for this task.

    I will keep the core authentication flow implementation in the current agent and delegate the independent supporting work to parallel subagents. I will not use repeated progress checks while they are running. Instead, I will continue non-conflicting work in the parent and integrate results after each delegated worker completes.

    Delegation summary

    PropertyValue
    Parent taskImplement the new authentication flow
    Worker 1auth-tests
    Worker 1 roleCreate unit tests for the authentication flow
    Worker 2auth-review
    Worker 2 rolePerform an independent design/code review
    Default worker policy6-luna with high reasoning effort
    Judge selectionnone (internal decision in current agent)
    Execution modeParallel delegation for independent work
    Progress policyNo repeated polling or progress monitoring of running subagents

    Why this delegation is appropriate

    The test implementation and the independent review are both meaningfully separate from the parent’s core implementation work. They can proceed with bounded objectives and do not require tight step-by-step synchronization with the parent. This makes them good candidates for gwitg-style delegation.

    Parent work

    While the delegated workers run, the parent continues the main implementation work, including:

    • adding the authentication entry point
    • wiring request validation and middleware behavior
    • updating the login/session handling path
    • preparing integration points for the upcoming tests

    This follows gwitg’s core rule: the parent acts as an orchestrator, not as a progress monitor.

    Worker assignments

    auth-tests

    • write unit tests for the new auth flow
    • cover success, failure, and invalid-input cases
    • validate middleware behavior where relevant
    • report the changed files, test coverage focus, and validation commands used

    auth-review

    • review the design and implementation boundaries
    • check for risky assumptions or missing edge cases
    • identify coupling, naming, and maintainability concerns
    • report findings clearly without modifying the task scope

    Integration policy

    When each worker completes, I will:

    1. read the final result
    2. inspect the reported changes or findings
    3. integrate the useful completed work
    4. resolve any conflicts
    5. perform parent-level validation as needed

    Next steps

    • finish the parent-side auth flow implementation
    • wait for terminal completion events from auth-tests and auth-review
    • integrate the completed test work and review findings
    • run final validation across implementation and tests

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

    About this skill

    gwitg is an Agent Skill for OpenAI Codex that delegates suitable independent work to subagents and runs independent tasks in parallel when appropriate.

    Its central rule is simple: after delegation, the parent agent should not become a progress monitor. Workers are allowed to complete independently while the parent continues other non-conflicting work or waits for completion.

    What it does

    • Identifies work that can be delegated independently
    • Runs independent subagent tasks in parallel when dependencies allow it
    • Avoids repeated status polling and intermediate progress monitoring
    • Allows limited corrections, newly discovered constraints, and cancellation while workers are running
    • Supports recursive delegation when a subagent itself has independent subtasks
    • Keeps direct user controls such as /subagent separate from parent-agent orchestration
    • Optionally uses Clef or Jev as an advisory delegation judge

    The default worker configuration is 6-luna with high reasoning effort, but worker selection and delegation judgment are separate concepts.

    Typical uses

    gwitg is useful for tasks such as:

    • repository investigation
    • bug investigation
    • well-defined implementation work
    • test writing
    • independent code review
    • documentation investigation
    • codebase search
    • self-contained experiments
    • validation against explicit acceptance criteria

    Compatibility

    gwitg is currently designed and validated for OpenAI Codex and relies on Codex subagent behavior and controls such as /subagent.

    Claude Code, Cursor, Copilot, and other agent runtimes are not currently validated targets.

    Open source

    gwitg is free and open source under the MIT License.

    Source: https://github.com/Twil3akine/gwitg

    Only for OpenAI Codex. Requires Python 3 for the delegation judge. No support for Claude Code or Cursor. No progress monitoring by design.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Environment Variables
    Read Files
    Write Files

    File Scopes

    .gwitg/decision-model
    ~/.config/gwitg/decision-model

    gwitg uses the shell to resolve the current Git repository and run its decision-model resolver. It reads optional project-level and user-level delegation judge configuration. File writes depend on the delegated coding task; gwitg itself does not modify its configuration files. Network and browser access are not required by the skill itself.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    gwitg enforces a strict delegation protocol that prevents parent agents from wasting tokens on constant progress polling, allowing high-reasoning subagents to work autonomously in parallel.

    This skill is purpose-built for OpenAI Codex and its native subagent control systems; it will not function in environments like Cursor or Claude Code that lack the specific lifecycle APIs.

    The package includes the core delegation protocol, the decision_model.py resolver for task arbitration, and pre-configured 6-luna worker templates for high-reasoning tasks.

    While the skill excels at independent workstreams, the parent agent remains responsible for final integration and resolving any file conflicts once the subagents report completion.

    Setup is straightforward—once the skill is added to your Codex environment, you simply configure your external judge (like Clef or Jev) and define your delegation threshold in the configuration file.

    New in Agents & Orchestration