Get started with mcue: save, plan and use the Hub

Pick a chat where you're already working on something. Save where you are, open a fresh chat, and carry on. You'll see the benefit in this sitting.

Start with save and resume. Continue with plans, worked use cases, or the Hub. The CLI walkthrough is on this page too. You can stop after your first useful continuation and return to the rest when you need it.

Connect once

Already connected to mcue? Go straight to step 1.

Otherwise, connect mcue to your chat app and sign in with an account admitted to the alpha. Once signed in, the app can save work to your own projects; you can restrict or revoke it at any time. The hosted route needs no terminal. If access is blocked, use the access request shown by Hub before continuing.

1. Save where you are

Paste this into your existing conversation:

Help me continue this work in a fresh chat using mcue. Briefly show what we're doing, what we've decided, what's still open, and the next step. Keep suggestions separate from decisions. Reuse the right project if it exists; otherwise propose creating one. Show me where you'll save this and wait for my approval.

Check that it got the work right. Correct anything missing or wrong, then reply:

Save it. Confirm the save with mcue and read it back to check it matches. Then give me one ready-to-paste prompt for a fresh chat that resumes this exact work and helps me take the next step. Fill in the saved project and lane for me. If anything fails, tell me what needs fixing.

Wait for the confirmed save and your resume prompt.

2. Open a fresh chat and carry on

Open a new conversation in the same connected app and paste the prompt it gave you.

The new chat should pick up your next step and keep the decisions you've already made. Do the next small piece of work together. You shouldn't need to paste your old conversation or explain the project again.

That's the first success: you're continuing real work in a new chat.

If it gets something wrong or can't open a needed file, tell it what stopped you. mcue saves the work's state; files still need to be accessible in the new chat.

3. Turn the next piece of work into a plan

A closeout records what happened and where to pick up. A plan keeps the steps you're working through and their progress. Use one when the next piece of work needs more than a single action.

Continue in the same chat:

Read this project's current mcue state and active plan. If there's already a plan for this work, show me where we are in it. Otherwise, propose a short plan for the next useful result, with a clear finish condition for each step. Use the same project and lane. Show it to me before saving.

For example, a plan for a one-page project brief could be:

# Write the project brief

## Objective
Produce a one-page brief that makes the problem, scope and next action clear.

## Plan Steps
- [ ] Agree the problem, audience and scope in an outline.
- [ ] Draft the brief from the agreed outline.
- [ ] Check the draft against the scope and resolve open comments.

Use your actual work; this is only an example. Adjust the steps, then say:

Save this approved plan in mcue and confirm it was created. Read back its progress and current step. Keep using our existing project and lane.

You should see a saved plan with zero completed steps and the first step current. A checklist printed in chat is only a draft until mcue accepts it. Each lane holds one active plan; if one already exists, continue it or explicitly decide to replace it.

If the agent says its connection cannot create plans, use the terminal route below or a client exposing the hosted plan-creation tool. Saving an ordinary closeout doesn't create an active plan.

4. Work a step, then save the progress

Ask the agent to help with the current step. For the example, agree the outline before calling step 1 done.

When that step's finish condition is met, say:

Prepare a closeout for the work we just did. Include the result, where to find it, anything unresolved and the next action. Propose marking the current plan step done only if its finish condition is met. Show me the closeout and plan change before saving.

Check the proposal, then reply:

Save the closeout with that plan update. Read back the saved progress and current step, and give me an updated ready-to-paste resume prompt.

For the example, completing the outline should leave 1 of 3 steps done, with drafting current. The closeout carries the agreed outline or a reference the next chat can access.

Use in_progress when you stop halfway through a step. Use blocked when you can't proceed, and record what would unblock it. Neither means done. For example: “The outline is blocked until we choose the audience; save that and make choosing the audience the next action.” Review and save the proposed update as above.

5. Resume the plan in another chat

Open a fresh connected chat and paste the updated resume prompt. Then ask:

Read the saved plan progress and current step. Check the last closeout and the referenced work, then help me continue that step. Keep completed decisions unless I ask to revisit them. If something needed is missing, tell me before proceeding.

In the example, the new chat should start drafting from the agreed outline, with step 1 still complete. You shouldn't need to explain the outline again. This is the plan's payoff: the sequence, progress and work stay connected across sessions.

6. Finish or change the plan

Repeat work → reviewed closeout → progress update as you go. After the final check, save the final result and mark the last step done. All steps being checked doesn't automatically archive the plan.

When you're ready to retire it, archive the plan as done using the terminal command below. If you change direction, archive it as abandoned with a reason before creating its replacement. Closed plans remain available as history; closing a plan doesn't close the project or its lane.

In a chat-only client, finish the steps and record the outcome. Archiving the plan currently needs the CLI; ask the agent to prepare the exact command for the saved project and lane. You can keep working without archiving immediately. The current plan-update command changes progress, notes and blockers; it doesn't rewrite the step list.

Examples for your own work

The project-brief example above follows outline → draft → review. The same pattern works for research, code and projects that span many sessions. These are illustrative records: replace their results with what actually happened in your work.

Research: compare papers without restarting the review

You have a chat comparing papers on a research question. Some sources have been checked; others are still leads.

Plan: agree the comparison question and criteria → extract evidence from selected papers → write the comparison and identify gaps.

Example closeout: “Question and criteria agreed. Evidence extracted from papers A and B into the comparison table; paper C hasn't been checked. Step 1 is done; step 2 is in progress. Next: read C's methods section against the same criteria.” Include the table and source references, or accessible links.

Try this:

Prepare a mcue plan for this comparison. Keep checked findings separate from unverified leads. Show which step we're on and what would count as finishing it. Let me review before saving.

Fresh-chat payoff: the agent continues with paper C using your criteria. It doesn't treat a lead as an established result or ask you to reconstruct the comparison.

Software: carry a bug investigation into a fresh coding session

You reproduced a bug and ruled out one cause. The fix is still open.

Plan: reproduce with a failing check → implement the fix → rerun the check and relevant regression tests.

Example closeout: “Reproduced in tests/refunds_test.go; the empty-input case fails. Configuration mismatch ruled out. Step 1 done; step 2 current. Next: inspect the empty-input branch in refunds.go.” Record the actual command and result, plus the branch or working directory needed to continue.

Try this:

Prepare a closeout and plan update for this investigation. Preserve the reproduction, what we ruled out, and the next code path to inspect. Don't mark the fix complete while verification is outstanding. Show me before saving.

Fresh-chat payoff: the next agent opens the reproduction and investigates the remaining cause. It still needs access to the repository; Hub doesn't upload that code for it.

Longer project: prepare a workshop across several sessions

You've agreed the workshop audience and learning outcome. Exercises and timing still need work.

Plan: agree audience and outcome → draft the session and exercises → rehearse and revise the timing.

Example closeout: “Audience and outcome agreed. First exercise drafted; second still missing. Step 1 done; step 2 in progress. Keep the session to 45 minutes. Next: draft the second exercise using the same example.” Reference the working document.

Try this:

Resume our workshop project and use its saved plan. Keep the agreed audience, learning outcome and time limit. Help me finish the current step, then propose a closeout for review.

Fresh-chat payoff: you work on the second exercise immediately. When you're ready to rehearse, the plan advances without losing the constraints agreed in an earlier session.

Use the Hub

The Hub keeps saved project state reachable from connected clients and gives you a browser view of projects, plans and closeouts. Local-only CLI use is also available; connect to Hub when you want that state accessible across chats or machines.

Open or create your project

1. Sign in to the Hub with your admitted alpha account. If it asks for access, complete the invitation/access step first.
2. Open Projects. If the earlier chat already created your project, open that one.
3. To start in the browser instead, choose New project. Enter a short Project ID, a Name, an Objective and a Category. For the worked example: project-brief, “Project brief”, “Produce a one-page brief with an agreed scope and next action”, and work.
4. Choose Create project. You can use it from connected chat clients immediately; no repository or CLI installation is required for this route.

Use the existing default lane for your first sequence of work. A lane is a separately resumable stream inside a project; add another only when you have work with its own next action and progress to track.

Connect your chat app

Add mcue in your app's MCP/connector settings using https://api.mcue.dev/mcp, then complete the browser sign-in. The client connection guide covers the supported setup routes. Exact menus vary by client.

Ask the connected agent to read your mcue projects, then return to the chat and save the reviewed closeout from step 1. A client you connect can read and write the projects you own, and create new ones, straight away; there is no separate step to allow saves.

You narrow a client under Connections → Account access: Restrict to read or Revoke stops it writing to your projects and creating new ones, while it can still read them. To narrow a client on one project only, or cut it off from that project entirely, open the project in Hub and use MCP client grants; a project setting takes precedence over account access. A write from a restricted client is refused with a message naming the client and where to change it.

See your saved work and plan

From Projects, open your project and then Open lane on the stream you're working on. Check:

Use the connected-chat resume prompt to fetch current state in a new conversation. Copy packet is also useful when carrying a snapshot into a client without the connection; paste it and ask the agent to continue. A copied packet doesn't provide a live connection or save subsequent work back to mcue.

Create plans through your connected agent or the CLI. The browser's Active plan panel shows progress; it isn't a plan editor. If a local change is missing in Hub, sync the project before expecting it to appear.

Save a closeout directly in the browser

You can record work done outside an AI chat. Open the lane and find Close out this lane. Fill in Intent, Outcome, Blockers, Next action and Resume pointer, then review and choose Write closeout.

For example, after an offline workshop rehearsal: intent “Check the session fits”; outcome “Rehearsal took 52 minutes”; blocker “Need to cut seven minutes”; next action “Shorten the second exercise”; resume pointer to your rehearsal notes. Use your real observations.

Wait for the success result and check the saved next move. The browser form records the closeout but doesn't offer plan-step controls; use the connected agent or CLI when you also need to advance a plan step. Save only to the lane the work belongs to.

Move between Hub and local work

For a project already in Hub, install the CLI, then run:

mcue hub set https://api.mcue.dev
mcue login
mcue whoami
mcue clone project-brief

Replace project-brief with your project's ID. If it's already local and linked, use mcue sync project-brief instead of cloning again. Run mcue attach project-brief from the working directory if you want that directory to identify the project automatically. Cloning brings mcue state locally; acquire source files separately.

For an existing local project that hasn't been linked to Hub, configure the endpoint and log in as above, then run mcue publish project-brief. In mcue, this creates a private Hub project and sends its operating state, including plans and closeouts. It doesn't publish a public page or upload your source repository. Use this route only when you intend to send that project's state to Hub.

Before changing machines or returning to a hosted chat, run mcue sync project-brief and check the result. mcue sync status project-brief shows the local cursor and pending changes; it doesn't contact Hub by itself. Keep unresolved local/Hub differences visible rather than assuming both sides match.

Using mcue plan in the terminal

These are the same operations expressed as commands. Use your existing local project and its actual lane. The example below assumes a project called project-brief with its default lane; replace those two names if yours differ. If your project only exists in Hub, follow the local setup guide and bring that existing project locally first.

Save the three-step Markdown example above as brief-plan.md in your working directory. Creating the plan imports that file into mcue; later edits to the source file don't update the saved plan.

mcue plan create project-brief --lane default --from-file brief-plan.md --title "Write the project brief"
mcue plan show project-brief --lane default

If an agent authors the plan, it adds --provenance agent to the create command. An existing active plan must be handled before creating another.

Mark step 1 in progress when you begin:

mcue plan update project-brief --lane default --step 1 --status in_progress

After you actually agree the outline, record both the outcome and progress together. Substitute your real result and artifact path:

mcue closeout project-brief --lane default \
  --intent "Agree the brief outline" \
  --outcome "Problem, audience and scope agreed in outline.md" \
  --next-action "Draft the brief from the agreed outline" \
  --resume-pointer "outline.md" \
  --plan-step 1 --plan-status done
mcue plan show project-brief --lane default
mcue resume project-brief --lane default --tier expanded

An agent-authored closeout adds --provenance agent. Expected result: 1/3 complete, step 2 current, with the outline available as the starting point.

If step 2 becomes blocked, record the actual reason. This standalone update doesn't create a session closeout:

mcue plan update project-brief --lane default --step 2 --status blocked \
  --blocker "Need an agreed word limit before drafting"

Once resolved, select the step again and record the resolution:

mcue plan update project-brief --lane default --step 2 --status in_progress \
  --note "Word limit agreed: 500 words; previous blocker resolved"

Blocker entries are retained in the plan's history; this adds the resolution rather than erasing the old entry. Use a closeout when the change also needs to update the lane's next action and blockers.

Continue the actual work, using closeouts with --plan-step 2 and then --plan-step 3 when those steps are done. Once all three steps are complete:

mcue plan close project-brief --lane default --status done --note "Brief checked against agreed scope"
mcue plan list project-brief --lane default --all

To retire a superseded plan, use --status abandoned and a note explaining the change. To inspect a closed plan, copy its plan ID from the list and run mcue plan show project-brief --lane default --archived PLAN_ID.

For a Hub-linked local project, standalone plan commands leave changes pending for sync. Run mcue sync project-brief before switching to a hosted chat. A linked closeout attempts sync automatically; check its result. If sync fails, the local save and Hub state may differ.

Keep using it

Start a session by resuming the relevant work. Use the plan to choose the next step. End meaningful work with a reviewed closeout that records both the result and any plan progress. Ask the agent for the next chat's prompt whenever you switch.