Guilduo

Guilduo / MCP Task Management

MCP Task Management for Humans and AI Agents

Share work with Codex or Claude as a Quest with a clear goal, completion criteria and assignee. Read saved task state when a chat restarts, and hand work back when human judgment is needed. This guide follows a small UI fix from connection to review.

Keep work state beyond a conversation

A new chat can mean explaining the goal again: what changed, what remains and who should review it. Separate human task lists and AI conversations make it harder to distinguish implementation from acceptance.

Guilduo stores work as Quests that external AI clients can read and update through MCP. Humans inspect the same Quests in Guilduo / Relay Forge. Goals, completion criteria, next actions, assignments and Handoff states give the next session something concrete to read.

Model history, IDE files and running processes stay in the external environment. Registering an Agent does not start a model. A scheduled Quest or a ready Handoff does not automatically launch an Agent.

What you need to try it

You need access to the Guilduo / Relay Forge public beta, a Google account for sign-in and one Quest with a goal and completion criteria. AI integration requires an external client such as Codex or Claude supporting Remote HTTP MCP and OAuth.

External AI accounts, subscriptions and API charges are separate. Guilduo does not host a model or start it when an Agent is registered. Setup depends on connection and permission state; no setup-time or time-saving guarantee is implied.

Screen example and October 10, 2026 developer acceptance

Example Guilduo / Relay Forge Command screen showing assigned Quests and human review requests.
Illustrative fixture screen, not a screenshot of the actual acceptance Quest or a customer result.

The developer acceptance record dated October 10, 2026 reports Codex making a limited Quest update through process-only direct OAuth and reading it back. It also records the owner saving a text answer to a Human request in Web and the same Agent session reading that answer and resuming.

  1. The Agent reads the latest Quest and permissions, saves an authorized change and reads it back.
  2. The Human reads the request in Web App and saves an actual text response.
  3. The same Agent session retrieves the saved response and resumes its next step.

The exact model ID was openai/gpt-6-astra, with the canonical Skill explicitly selected. The record also covers no-op behavior and rejection of stale writes. This is historical developer acceptance, not a new run, customer case, verified Codex-to-Claude transfer or time-savings measurement. Desktop trusted-hook execution, refresh, revocation and reconnection remain unaccepted.

Read the dated public acceptance record · Try the interaction demo without saving data or connecting an AI

Try one small Quest first

  1. Open Guilduo. Sign in with Google and create a Quest with a goal and completion criteria.
  2. Follow the Codex setup guide or the MCP connection guide to connect your client, then check that it can read the same Quest.
  3. For writes, link an authorized Agent in Connections and specify its scope. Start with: “Read this Quest and explain the next step. Do not change it yet.”
  4. When human input is needed, use the Human Relay guide to save a request and answer. Agent readback, Handoff acceptance and completion of the original Quest remain separate checks.

Where this fits, and what you still need

This fits UI fixes, copy review and research review with explicit goals and criteria. It helps when a human must respond to AI work or multiple sessions need to inspect saved progress.

Model hosting, IDE operation, test execution and scheduled Agent launches sit outside this Quest workflow. Native synchronization with external To Do services is not a prerequisite you can assume. Prepare the external runtime and its permissions separately.

Read access does not establish write access. Check required quests:read or quests:write permissions on both the OAuth and Agent sides. Record only necessary task information, keep credentials out of Quests, and check artifact link access separately.

Connect, preview, save and reread

  1. Define one small Quest. Record the goal, completion criteria and next action. Use Backlog if the date is undecided. Planning, assignment and completion are separate states.
  2. Check identity and permissions. Connect a supported client to https://mcp.guilduo.com/mcp using OAuth. Link it to a registered Agent in Web App Connections. Read get_current_agent_context to verify the Agent and effectiveExecutionScopes. Execution permissions are the intersection of OAuth grants and Agent permissions.
  3. Preview the assignment. Use get_quest to read the target and its latest updatedAt. Preview assign_quest_to_agent with dryRun: true. Within delegated scope, save with that timestamp as expectedUpdatedAt and dryRun: false.
  4. Work externally and return the result. Edit and test in Codex or Claude's work environment. Use working, then review_required when the result needs review. Preview transition_quest_handoff; pass the state you read as expectedState when saving.
  5. Resume by reading saved state. In a new session, verify the connection and Agent permissions. Find the task with list_quests and read it with get_quest. Check criteria, assignee, results and outstanding review, then inspect external files or artifacts before continuing.

For ordinary updates, inspect the target and proposed changes before saving, then reread to verify them. Preview support depends on the tool: adding dryRun to create_quest or update_quest does not create a preview. Follow the published schema. On conflict, read current state and reconsider the change.

Example: fix a smartphone menu

This task is illustrative. It contains no real user data and does not represent an executed job or a quality guarantee.

What to record in “Fix the smartphone menu”
FieldExample
GoalLet visitors open and close the menu and reach the intended page on a narrow screen.
Completion criteriaNo horizontal overflow at 390px. Menu controls and links work. Record keyboard checks and human device review.
Next actionRead existing menu behavior and styles, then reproduce the issue.
Delegated scopeRelevant UI changes and verification. Publishing and deployment decisions are excluded.
Return informationChanged files, checks, artifact location and the interactions a human should verify.

A request to the connected AI could read:

Read “Fix the smartphone menu” in Guilduo and check its criteria and assignee. Preview assignment, save within my authorized scope, then make the fix. Check 390px layout and keyboard operation. Return the result for review with device checks still outstanding.

If tap comfort needs human judgment, the assigned registered Agent uses request_human_review to create a separate confirmation Quest. Specify where to check, what to do and what answer is needed. Preview first; save using the latest expectedUpdatedAt. The human saves a text response in the Web App, which the Agent reads with list_human_requests before revising or proceeding toward acceptance.

The human review response, Handoff approval and original Quest completion are separate operations. Answering the confirmation Quest does not complete the fix. Handoff records the transfer between assignees; even accepted leaves the original completion criteria to verify. See AI agent handoff for that workflow.

Start with one Quest and a read check

Sign in to Guilduo / Relay Forge. Use the Quest guide to define a small task, then follow MCP connection. See the client instructions for Codex or Claude.

Once the client reads the same Quest, check Agents and assignment and permissions. Preview and save one assignment. Verify connection, reads, writes, external work and review separately so a failure has a clear location.

Published sources and review date

Reviewed . Based on publicly published source revision 479b21113d5cd9590c552fed5f0b1de2631be2ed.

Consult Guilduo Docs for detailed operations and check your client's Remote MCP and OAuth support.