Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Cowork: Multi-Agent Task Inbox over MCP

    1

    Give your agent a shared task inbox. Dispatch, schedule and track work across Claude Code, Codex, Gemini CLI and local models through one self-hosted MCP hub.

    $6

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    1 useSecurity scanned

    Cowork: Multi-Agent Task Inbox over MCP

    Example session with this skill installed

    Have Codex review src/server/ for queries that aren't tenant-scoped, and every weekday at 09:00 have the local Ollama model summarise yesterday's git log into CHANGELOG-draft.md.

    • Read your context and instructions
    • Compiled the cowork

    Summary

    Dispatched one review task to Codex now and scheduled a recurring changelog task on the local model. Both are in the shared Cowork inbox.

    #TaskBrainWhenStatus
    1Review src/server/ for tenant-scoping leakscodex (pinned)nowpending
    2Draft CHANGELOG from yesterday's git logollama-qwen (pinned)Mon–Fri 09:00 (server time)scheduled

    Calls made

    get_dashboard()                       -> brains online: claude-opus, codex, ollama-qwen
    register_agent(platform: "claude", agent_name: "laptop-session")
    create_task(
      title: "Review src/server/ for tenant-scoping leaks",
      description: "Repo: ~/code/app. Check every DB query under src/server/ is filtered by orgId.
                    Deliverable: findings.md with file:line, the query, and a suggested fix.
                    Done = every file in src/server/ checked.",
      from_platform: "claude", from_agent: "laptop-session",
      context: { brain: "codex" }
    )
    create_task(
      title: "Draft CHANGELOG from yesterday's commits",
      description: "Repo: ~/code/app. Run git log --since=yesterday, group commits by feat/fix/chore,
                    write CHANGELOG-draft.md to the artifacts dir.",
      from_platform: "claude", from_agent: "laptop-session",
      context: { brain: "ollama-qwen" },
      recurrence: { type: "weekly", weekdays: [1,2,3,4,5], atTime: "09:00" }
    )
    

    Each brief is self-contained because the receiving agent never sees this conversation. If Codex hits a rate limit, the hub moves task 1 to the next brain in its fallback chain.

    Next steps

    • list_inbox(status: "done", limit: 5) later to read Codex's findings; the report is attached to the task card on the dashboard.
    • Watch the first scheduled run tomorrow at 09:00. Note that the time is the server's local time, so tell me if your hub runs in a different timezone.

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

    About this skill

    Cowork is a free, self-hosted MCP server with a web dashboard. Your coding agents share one task queue through it. This skill teaches your agent when to hand work to another agent and how to do it correctly. It covers registering with the hub, writing self-contained task briefs, pinning a task to a specific model ("brain"), scheduling one-off and recurring runs, asking a human for input mid-task, and reading results and artifacts back.

    • Mixed vendors, one inbox: Claude Code, Codex, Gemini CLI/Antigravity, Hermes, Ollama.
    • Fallback chains: when a model hits a rate limit, the task moves to the next brain.
    • Scheduling: ISO date-times, or daily, weekly or cron recurrences.
    • Human in the loop: form fields on the task card, and tasks park on wait-input.
    • Plain files, no database. Docker image for amd64 and arm64.

    Requires a running Cowork hub (MIT, free): docker run -d -p 6868:6868 -v cowork-data:/data ghcr.io/slashman413/cowork:1.0.1. The first start prints a generated API key. Setup and client wiring are in references/setup.md.

    Network behaviour (disclosed): the skill only calls the Cowork MCP server that you configure. It makes no other network calls, runs no scripts and collects no credentials. The API key stays in your MCP client config.

    Requires a running Cowork MCP server (which the AI agent setups automatically after using this skill) and its optional API key if security is concerned. Agents that stop sending heartbeats are marked stale after about 10 minutes. Recurring schedules use the server's local time. Tasks are stored as plain files on the server, so keep credentials out of task descriptions.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 29 days ago

    Requires

    Cowork MCP
    Docker or Node.js
    Git

    Permissions

    Read Files
    Write Files
    Network Access
    Terminal / Shell
    Browser
    Environment Variables

    The skill contains only markdown instructions. It runs no scripts and makes no network calls itself; your agent calls the Cowork MCP server that you configure. The hub API key stays in your MCP client config or the COWORK_API_KEY environment variable.

    Listed29 days ago
    Updated22 days ago

    What's inside

    Frequently Asked Questions

    This skill acts as an orchestration layer that allows different AI agents to communicate and share tasks. It solves the issue of 'session isolation' by providing a central hub where one agent can delegate work, schedule background jobs, or hand off complex tasks to more powerful models.

    You will need a running Cowork server (MIT licensed) and a valid API key to connect this skill. Once your self-hosted hub is active, the skill uses the Model Context Protocol (MCP) to register your current session and start dispatching tasks to your network.

    Yes, Cowork includes a 'Human-in-the-loop' feature that allows agents to pause execution and wait for manual approval. You can review the task details and provide input via your Cowork dashboard before the agent proceeds with the next step.

    Cowork supports both one-off scheduling for specific times and recurring tasks using standard cron expressions. This allows you to automate repetitive workflows, such as daily code summaries or morning data collection, without manual triggering.

    The skill manages task routing and status updates, but it is recommended to handle sensitive credentials through environment variables on your host machine. Since tasks are stored as files on your server, avoid placing raw passwords or API keys directly in the task description text.

    New in Agents & Orchestration