Uses Git for project version control: stores selected deliverables and project records in a remote private Git repository for traceability and recovery, and uses Git worktrees to support multiple parallel workspaces.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Agent Co-Governance Toolkit Record the progress and key decisions made in the software workspace today."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Project memory and collaboration for AI tools.
Download TaskCarry · Start with the user manual · See the architecture
TaskCarry provides project memory, workspace collaboration, and project workflow governance for people working with AI tools. Bring ready stages into a shared project, preserve unfinished work, and resume supported interrupted operations from recorded and verified results. Task context, selected files, deliverable history, and next steps stay with the project across conversations and pauses.
Use it when one project has outgrown a single conversation: software and documentation advancing together, a research project with several workstreams, or a product with development, operations, and writing happening in parallel. Your AI tool helps do the work; TaskCarry gives that work a durable local record and a way to bring results together.
The current step-by-step examples use Codex. The toolkit exposes the same local engine through a command line and MCP, providing a foundation for other AI-tool integrations. Each host still needs its own connection and workflow verification.
Git already keeps file history. Project instructions such as AGENTS.md already explain how an AI assistant should work. A handoff message already helps the next conversation get started. TaskCarry connects these useful pieces to the changing state of a project.
What you already use | What it helps with | What TaskCarry adds |
Git | Versions, branches, and file changes | Which task a result belongs to, which stage was received, and what still needs to continue. |
AGENTS.md and Skills | Working practices and role instructions | Persistent records of the work actually saved, offered, integrated, or paused. |
Conversation summaries | Context for a person or another chat | Task records and file references you can update and revisit beyond one conversation. |
Manual handoffs | Coordination between a few workstreams | Reviewed plans, recorded operation results, and supported recovery when work is interrupted. |
For a short task in one chat, your existing tools may be enough. TaskCarry becomes useful when you repeatedly need to answer: Where did we stop? Which result is current? What has already joined the project?
Related MCP server: Codex Folders
Keep task goals, recorded decisions, current position, and next steps outside chat context. Save selected files and continuation notes when a task pauses, and read a focused agenda without losing paused work or completed history. Material references record where larger files live and whether a specified backup matches, so every file need not go into Git.
Give parallel tasks independent workspaces, then bring ready results into a shared project version. A useful stage can be delivered while its task continues. Explicit version relationships and matching change history show when a later stage replaces an earlier one, while keeping independent results available.
Project workflow governance connects the work people and AI produce with clear plans, checked updates, and recorded outcomes.
Capability | What it helps you do |
Reviewable integration plans | See which stages and files will join the project before carrying out the update. |
Workspace binding and conflict checks | Check the registered workspace and expected state, coordinate the toolkit's own writes, and identify concrete conflicts. |
Work-in-progress preservation | Retain supported local commits, staged changes, working files, and new files when adopting shared results. |
Interrupted-operation recovery | Check what actually happened, reuse a recovery method when its conditions match, and complete supported missing steps without blindly repeating finished work. |
Durable review and maintenance evidence | Reuse reviewed source relationships, track a selected round's receipts, and link a concrete defect to its tested fix and actual local setup. |
This governance focuses on project deliverables and their workflow. Host permissions and Agent authentication remain with your AI platform and operating environment; the architecture explains how these responsibilities fit together.
Memory comes from the tasks, notes, files, and deliveries you or your AI assistant explicitly connect. TaskCarry does not automatically collect all private conversations or capture unsaved editor content.
Your governance chat coordinates the project. It uses the AI capabilities of your host to understand the supplied work information, review the current state, and call TaskCarry tools. Specialist chats focus on their own tasks in clearly assigned workspaces.
TaskCarry stores records and performs the supported local operations. You retain decisions about project direction, priorities, business acceptance, and external delivery. The toolkit does not require a separate model API or train a model.
For example, software may have a usable module while experiments are paused and documentation is still a draft. Governance can receive the software stage and retain the other two tasks at their current positions. Nobody needs to mark the entire project complete just to preserve useful progress.
Work in your task chat. Continue the real task in its assigned workspace.
Save a useful stopping point. Record the current position and selected files when you pause.
Offer a ready result. Identify the stable version and the files it changes.
Bring it into the project. The governance chat reviews a plan and receives the stage through the tools.
Continue from shared progress. Update the workspaces that need those business changes, preserving supported local work and addressing concrete conflicts.
A received stage can be part of an unfinished task. A paused task can stay paused. Replacing an older stage requires a documented relationship and matching change history, so independent results are not discarded merely because a newer file exists.
Download taskcarry-0.2.0rc5-product.zip from the release page, then follow the Windows user manual.
Create the project directory and governance chat. The manual gives a concrete folder example and a copyable installation prompt. Fill in [Project name] and [One-sentence introduction].
Connect existing work or add task workspaces. Keep a suitable existing chat, or create independent workspaces for parallel tasks. Fill in [The actual work this chat is responsible for].
Ask governance to run its first review. It checks the connected project and reports the result in that same chat. You can then continue working and add scheduling when useful.
There is no separate report application to open. Initial setup feedback and everyday project summaries are produced by your governance AI in its chat, using TaskCarry records and tools. A configured host automation can perform those reviews on a schedule.
You do not need to learn the engine, inspect its database, or run developer tests before using the product.
This is an organization example. Choose your own roles and number of chats. If several existing chats share a working directory, retain one main writer there and move responsibilities that need parallel work into separate workspaces, as the manual explains.
Scheduled coordination: use your host's scheduling feature to ask governance to review connected work and produce a useful summary. Installing TaskCarry does not create a schedule.
Private Git: configure your own remote repository for selected committed results. File references help locate materials, but copying, backup, and remote synchronization remain explicit operations.
Additional AI tools: CLI and MCP provide integration points around one engine. The Codex guide is the current concrete onboarding path; it does not establish that every MCP client, model, or AI platform has been verified.
Multiple computers: the guide describes separate task branches and one integration computer. Real two-computer operation has not completed end-to-end validation; start after the local workflow is established.
TaskCarry uses Python 3.11+; Git is needed for Git workflows. It stores project state locally and includes four project Skills for setup, task delivery, governance, and recovery. Each control scope has one local store and one receiving baseline. Installation updates tools and Skills; adopting received business changes into a workspace is a separate, reviewed action. See maintenance and capabilities and limits.
Guide | English | 简体中文 | 繁體中文 |
User manual | |||
Architecture | |||
Maintenance | |||
Private Git and multiple computers |
How the workflow became simpler
CLI / MCP reference · Public Skills · Validation records
Questions, real use cases, clearer examples, translations, and code improvements are welcome. Start with Issues or the contribution guide. Remove private project information before sharing; the security guide explains what to keep out of a report.
The public code, documentation, templates, and examples use the MIT license, including commercial reuse under its terms. Your own project and materials remain yours to manage; using TaskCarry does not make them public. Dependencies and services retain their own terms. See license scope.
This server cannot be deployed
Durable, shareable and governed project memory with smart triage and explicit project composition.
Project management shared by people and AI agents, with persistent project state through MCP.
Shared project memory that keeps teammates and AI agents aligned across sessions.
Project memory for coding agents: requirements, decisions, code graph and delivery telemetry.
