Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Task Deck

    1

    A Persistant Deck for Long-Term Task.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Task Deck

    Task Deck

    Example session with this skill installed

    Use TaskDeck to migrate 500 markdown files to a new frontmatter schema in the ./content directory. Set batch size to 50.

    • Read your context and instructions
    • Compiled the task deck

    I have initialized the TaskDeck run directory and created the execution plan for the markdown migration. A background worker has been started to process 500 files across 10 batches.

    Migration Dashboard and Status

    The HTML monitor is now live. You can open it to track real-time progress, batch successes, and any validation failures.

    Run Metadata:

    • Run ID: run_20231027_markdown_migrate
    • Total Batches: 10 (50 items/batch)
    • Status: executing
    • Dashboard: ./task_runs/run_20231027_markdown_migrate/index.html

    Current Progress:

    Batch IDStatusItemsResults
    batch_001completed50/50Schema verified
    batch_002executing12/50In progress
    batch_003-010planned400Pending

    Next steps

    1. Open ./task_runs/run_20231027_markdown_migrate/index.html in your browser to monitor progress.
    2. Check logs/worker.log in the run directory if you see any batches marked as failed.
    3. Once the status hits completed, review the final_report.json for schema validation evidence.

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

    About this skill

    Name

    TaskDeck

    Summary

    Run long tasks with a progress page from the start. TaskDeck guides your coding agent through batching, checkpoints, recovery, and verified delivery, with a standalone HTML monitor for progress, issues, and estimated API costs.

    Description

    TaskDeck gives long-running work a clear plan, recoverable checkpoints, and a progress page from the moment it starts.

    Use it with a shell-enabled coding agent for batch document processing, data collection, migrations, asset generation, and analysis. It is built for AI-native product managers and developers who want to see what has actually finished, what needs attention, and where the outputs are.

    What you get

    • A monitor at startup. Open a standalone HTML page before the first batch completes.
    • Progress you can inspect. Separate committed successes, failures, review items, remaining work, and in-flight work.
    • Recoverable execution guidance. Stable item IDs, checkpoints, bounded retries, and process checks help the agent resume work without blindly repeating committed items.
    • An English dashboard. Search batches, filter statuses, inspect recent events, and follow local output links.
    • Freshness checks. Stale heartbeats and unverified processes are shown explicitly instead of pretending a worker is still running.
    • API cost forecasts. Display estimated input/output tokens and costs when the task uses external AI APIs. Unknown values stay unknown; different currencies stay separate.
    • An honest handoff. Verify results against the original success criteria and preserve the final snapshot, exceptions, and continuation instructions.

    How it works

    Ask your agent to use TaskDeck for a specific task. It establishes the scope, creates the run plan and initial HTML monitor, preflights a small work unit, and connects a task-specific worker or an existing job system. Durable checkpoints drive the status file; the bundled Python renderer converts that status into a browser-readable snapshot.

    The renderer uses the Python standard library and generates offline HTML without a frontend build, CDN, or web server. This Agensi edition embeds its template so the script can run unchanged from a temporary file.

    Requirements and boundaries

    Requires Python 3.9+, a coding agent with shell and filesystem access, a writable output directory, and a browser. Background execution and unattended monitoring depend on the host's process or job-management capabilities. TaskDeck supplies instructions, contracts, a template, and a renderer; the agent must connect or create the worker for your task.

    The interface and primary instructions are in English. Detailed execution, state, and interface references are in Chinese, so use an agent that can read Chinese references.

    The included preview uses clearly labeled illustrative data. It is not evidence of a running background job or measured performance. Cost estimates are forecasts, not billing reports. TaskDeck does not independently grant permissions to publish, write to external systems, send messages, or incur API charges.

    Compatibility note

    Requires Python 3.9+, shell/file access, a writable task directory, and a browser for local HTML. Unattended execution needs a host-supported worker or job system. English UI and primary instructions; Chinese reference docs. No third-party Python dependencies.

    Categories — select in this order

    1. Workflow Automation (workflow-automation)
    2. Productivity (productivity)
    3. Data & Databases (data-databases)

    The first category determines the main category page.

    Tags

    task-management, batch-processing, background-jobs, checkpoints, recovery, progress-monitoring, python, html

    Search keywords

    long-running tasks, resumable workflows, offline dashboard, batch processing, AI-native PM, progress tracking

    Use cases — one per entry

    • Process a document collection in recoverable batches.
    • Track data collection or migration with checkpoints and review queues.
    • Monitor long asset-generation or analysis tasks.
    • Resume interrupted work after checking process identity and saved results.
    • Hand off verified outputs with an exception list and a final HTML snapshot.

    Permissions — review the website's detected values

    • Shell / command execution: run Python and the task-specific worker.
    • File read: explicitly selected task inputs, state, checkpoints, and logs.
    • File write: the run directory, results, checkpoints, logs, HTML snapshots, and temporary execution files.
    • Background processes: only when the execution environment supports them, with saved process identity and cleanup.
    • Network: not required by the renderer or local HTML. A collection, migration, or external AI task may need specific services authorized separately.
    • Credentials: none bundled. Any credentials needed for a task must remain in the user's authorized environment.

    Requirements — one per line

    Python 3.9+ Coding agent with shell and filesystem access Writable task output directory Browser capable of opening local HTML Chinese-language comprehension for detailed reference documents Process manager or job system for unattended execution

    Known limitations

    • The renderer does not execute or supervise business jobs; the agent connects a task-specific worker.
    • Closing a session or rebooting the host may stop execution unless a durable mechanism has been configured.
    • HTML refresh only reloads the latest rendered snapshot. A worker or updater must produce new state and render it.
    • The dashboard is read-only; it does not provide connected pause/cancel buttons.
    • ETA requires measured throughput. Token and cost figures are estimates, with no currency conversion or billing reconciliation.
    • Agensi executes bundled scripts temporarily. Continuous monitoring needs a supported temporary process lifecycle; otherwise updates are rendered when the agent observes state.
    • Detailed references are in Chinese. The primary skill instructions and dashboard UI are English.

    FAQ

    Does TaskDeck include a universal background worker?

    No. It guides the agent to use an existing executor or build a small adapter for the current task. The included Python script validates and renders state.

    Can I close the chat and leave the task running?

    Only after the host has a supported background execution mechanism and the agent has verified the worker and its first durable checkpoint. TaskDeck does not guarantee that every environment survives a closed session or a reboot.

    Does the dashboard need a server?

    No. The generated HTML opens locally and contains its own state snapshot. Re-render it when status changes; the browser can reload the resulting file.

    Are the screenshots real task results?

    They are screenshots of the functioning TaskDeck HTML interface, rendered from explicitly labeled demo data. Counts, model names, prices, throughput, and ETA in the preview are illustrative.

    Do I need API keys?

    Not for the renderer or dashboard. Particular jobs may require service credentials, supplied through the user's authorized environment.

    What is preserved for recovery?

    The workflow calls for a stable run ID, input identity, batch and item keys, checkpoints, committed results, logs, and process identity. The adapter must actually persist these; a progress page alone is insufficient.

    Screenshots

    Upload 03-screenshots/taskdeck-example-en.png. This complete English screenshot is generated from 04-preview/taskdeck-demo-en.html. An optional 512 × 512 logo is provided as 03-screenshots/taskdeck-logo-512.png.

    Caption: TaskDeck's English progress monitor — illustrative demo data showing batch progress, review items, API cost estimates, and recent events.

    See it in action

    Use the request and response in 02-See-it-in-action.md. They describe the renderer demo actually produced for this package and clearly distinguish illustrative data from real job execution.

    Optional fields intentionally left empty

    • Demo video: no video was recorded or uploaded.
    • Support method: use your preferred contact channel; none is invented here.
    • License selection: no license field was found in the public form code, and the source repository has no LICENSE file. Do not describe it as MIT-licensed. Review Agensi's terms and rights declarations in your account.

    Requires Python 3.9+ and shell access. Background durability depends on host process management. Reference docs are in Chinese. Watcher mode needs host process supervision.

    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

    Money-back guarantee

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

    Trust & safety

    Security scan

    Security scan passed 13 days ago

    Requires

    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed13 days ago

    What's inside

    Frequently Asked Questions

    Task Deck solves the issue of agent timeouts and context loss by offloading tasks to background processes and maintaining a persistent state in local JSON files, allowing work to resume exactly where it left off.

    This skill requires Python 3.9 or higher and access to a local or cloud-based shell environment to manage the worker processes and render the HTML dashboard.

    You receive the complete skill implementation, including the background worker logic, the state-tracking framework, and the zero-dependency Python renderer for the HTML progress dashboard.

    Yes, Task Deck is designed to be framework-agnostic; as long as your agent can execute Python scripts and manage a directory structure, it can orchestrate batches using this skill.

    Task Deck uses an atomic batching system where each sub-task is logged in `status.json`; if a crash occurs, the system reads the last successful checkpoint and skips already-completed items to avoid redundant API costs.

    New in Agents & Orchestration