SkillAgentSearch skills...

agent-nextup

Desktop app that keeps a long project handoff-ready for any AI agent — tasks, decisions and a live handoff snapshot as diffable files. MCP hub. Tauri + Rust + React, local-first.

Install / Use

claude mcp add white1024 -- npx -y github:white1024/agent-nextup

If the server publishes to npm under a different name, use that package instead — check the repo README.

About this skill
🔌

MCP Server

Model Context Protocol server

Quality Score

83/100

Category

Automation

Supported Platforms

Claude Code
Claude Desktop
Gemini CLI
OpenAI Codex

Our assessment of agent-nextup

agent-nextup scores 83/100 on our quality scale, 2135th of 2,790 Automation skills we index.

Its MCP Server is 17 KB long, well organised into 9 sections with 5 code examples: a thorough specification that gives an agent plenty to work with.

It has 3 GitHub stars, so there is little community track record yet; judge it on its content.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
3/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 7 days ago, so agent-nextup is actively maintained.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 92/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-15. Automated pattern scan on 2026-11-15. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

agent-nextup compared with similar skills

All 4 of these similar skills score higher than agent-nextup; compare them before choosing.

SkillScoreStarsUpdatedFormat
agent-nextup (this skill)by white10248337d agoMCP Server
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md
CowAgentby zhayujie10048.0ktodayCLAUDE.md

Frequently asked questions

How do I install agent-nextup?
Run claude mcp add white1024 -- npx -y github:white1024/agent-nextup. The install tabs above show the steps for each supported agent.
Which AI agents does agent-nextup work with?
It is written for Claude Code, Claude Desktop, Gemini CLI and OpenAI Codex, as a MCP Server file. Other agents that read the same format can often use it too.
Is agent-nextup safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 92/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is agent-nextup still maintained?
The repository was last updated 7 days ago, so agent-nextup is actively maintained.
<div align="center"> <img src="src-tauri/icons/128x128.png" alt="" width="88" height="88" /> <h1>Agent NextUp</h1> <p><strong>Agents forget. Projects shouldn't.</strong></p> <p>A desktop app that turns any long-running project into human-readable files an AI agent can take over from — with phase gates the engine checks against real state, not against what anyone claims.</p> <p> <img src="https://img.shields.io/badge/Tauri%20v2-Rust%20%2B%20React-informational" alt="Tauri v2, Rust and React" /> <img src="https://img.shields.io/badge/status-in_development-informational" alt="In development" /> <img src="https://img.shields.io/badge/license-MIT-informational" alt="MIT licence" /> </p> </div>

An AI session is short and forgetful; a real project is long and full of context. Most of the friction in working with agents comes from that mismatch — every new session starts by re-deriving what the last one already knew, and whatever never got written down is simply gone.

Agent NextUp keeps that context in files the engine keeps fresh. You make the decisions, your agent does the work, and a handoff stays possible at every moment.

[!IMPORTANT] Installers are on the releases page, for Windows x64, Linux x64 and macOS arm64. They are unsigned builds — Windows and macOS both stop the first launch, and reference/building has the click path past each. From 0.2.0 an installed copy updates itself when you ask it to, from Settings. Development is Windows-first. Quick start covers both downloading and building from source.

What it organises

Any body of work — software, research, a side business, life planning — into four things:

  • Project — a folder you chose. Every piece of state is a file you can open, diff, and commit.
  • Tasks — atomic units of work, each small enough to finish in one session, with a status and optional prerequisites.
  • Phases and gates — the project moves through phases from a template (the generic one runs plan → execute → review → retrospect), and each phase has exit gates the engine evaluates against real state.
  • Handoff snapshot — "where things stand and what comes next", regenerated by the engine on every state change. A new session, a new machine, or a different person reads one file and picks up the thread.

[!NOTE] Agent NextUp is not an agent and has no cloud backend. It is the management layer; execution belongs to whichever agent you already use — Claude Code, Codex CLI, Gemini CLI, or you.

Features

  • Files are the whole product. No database. Snapshots and search indexes are rebuildable derivatives; the ledger is append-only and is the audit record. If Agent NextUp vanished tomorrow, your project would still be readable.
  • Gates you cannot mark yourself. min_tasks(n), all_tasks_done, artifact_exists(path) and the rest are computed from disk, never self-reported. manual_confirm is the inverse — only a human can satisfy it, and no tool exists for an agent to do so. Forcing any gate demands a reason and is written to the ledger. (the full set)
  • A reversed decision says so. Decisions carry ids, and one that overturns an earlier decision names it. The old decision is kept and shown struck through as SUPERSEDED — never edited, never removed, because the ledger is append-only and a decision that quietly vanished would read as one that was never made. The next session can see both what was decided and that it no longer holds.
  • A handoff that is never stale. The snapshot regenerates on task, decision, milestone, and phase changes, so it is never older than your last action.
  • Claimed done is not done. Completing a task records a claim; verification is a separate mark that requires evidence, and the bulk archive sweep collects only verified work, deliberately leaving the rest on the list where you can see it.
  • Agent reach is an allowlist. Agents reach your project through the hub — nextup-mcp, a local MCP server bundled with the app that the agent CLI starts for each session. One master switch decides whether agents reach the hub at all; with it on, read-only tools need no further setup, and writes are authorised per tool, with the gatekeeping ones off by default unless you choose, when creating a project, to grant everything. Every call — including denied ones — lands in the ledger.
  • Parallel agents can't jump the queue. Give tasks an assignee and prerequisites and the engine refuses out-of-order starts and finishes. Claims cannot be stolen.
  • A terminal that runs the real CLIs. A genuine PTY process per agent CLI, rooted at the workspace. Sessions belong to the app, so switching projects doesn't interrupt them, and a running terminal can pop out into its own window.
  • Projects can feed each other. Wire workspaces into a directed graph and one project delivers to another's inbox, with attachments. A member's agent can publish but never route — routing is a human action, a per-edge automation a human switches on, or a coordinator project a human puts in charge. Inbox content is defined as data, not instructions.
  • One project can run the team. Name a project as a team's coordinator and its agent gets the app-level view: the flow graph, routing on a member's behalf, the roster — it can bring a project in, take one out, even create a new project to bring in — and, member by member, a read of the task text, ledger and specs you would get by opening it. Naming a detail read leaves a line in that member's own ledger, so being read is not invisible; the cheap per-member summaries do not. A coordinator is not a member of the team it runs; it sits above the flow, with no node on the canvas. What it does not do is the work: no creating tasks, advancing phases, or marking anyone's result verified. The one write it has inside a member is the sign-off — archiving a finished task, which folds that task's spec delta and is refused until the task is verified — and that is a separate grant from reading. Authority is per team, granted tool by tool, and the coordinator cannot grant it to itself.
  • A spec layer that stays current. specs/<capability>/spec.md records what the system does now; task bundles hold the deltas, and archiving a verified task folds its delta into the main spec — a task carrying deltas is refused archival until it is verified, because folding turns a claim into truth, and a delta changed after verification is refused until it is verified again. The folding is enforced; writing the delta is prompted by the agent's operating protocol.
  • Search and portable backups. Full-text search over the workspace (language-agnostic chunking into an SQLite FTS5 index), and export/import of the management layer — tasks, specs, ledger and handoff material — as a zip you can carry to another machine. Your own source files are not in it: they travel with the folder, or with git.

[!NOTE] Four of the bullets above are capability modules, not always-on features: collaboration (assignees and prerequisites), teams, team coordination, and the spec layer. You tick them on when you create the workspace, and a fresh project ships with none of them enabled. Every other bullet is always on.

How it works

A managed workspace is an ordinary folder. Abridged to the parts you will actually open:

my-project/
  AGENTS.md            entry point + engine-maintained state block
  project.yaml         phase / progress / updated, synced line by line
  nextup_docs/          operating guide for a headless session
  memory/              cross-session memory, one fact per file
  .mcp.json            hub connection for the agent host
  .nextup/
    workflow.json      phases, AI instructions, exit gates, position
    agent_access.json  per-tool authorisation
    ledger.jsonl       append-only event ledger
    snapshots/latest_handoff.md
  tasks/  artifacts/
  specs/               only when the specs module is on

The entry point is AGENTS.md — the filename agent hosts look for; Claude Code gets there through a one-line CLAUDE.md shell. The engine rewrites the fenced block on every state change and never touches anything you hand-write outside it:

<!-- NEXTUP:STATE:BEGIN -->
> ⚙️ Maintained automatically by the Agent NextUp engine (hand edits are overwritten on the next update); updated 2026-07-29T09:52:38Z

**Status**: Demo project (domain: coding) — 2 tasks: 1 todo / 1 in progress / 0 blocked / 0 done; current phase **Spec** (1/5, template Software Development).

**Instructions for this phase**:
- Read the handoff and context.json. If the requirements are still vague, call the Skill tool with align-scope and settle what done means first.
- Turn the settled scope into vertical-slice tasks with their dependencies: call the Skill tool with slice-work.
- Record key technical choices (framework, data structures, boundaries) as decisions.

**Exit gates** (evaluated by the engine against real state):
- [x] min_tasks(1) — 2/1
- [x] min_decisions(1) — 1/1

**Next steps** (up to 5; ▶ = in progress):
- ▶ [P0] T-0001 — Design the data model
- · [P2] T-0002 — Write the user documentation

**Blockers**: none right now.

**Recent decisions**:
- `2026-07-29T09:52:38Z` Files are the source of truth; the index can always be rebuilt
<!-- NEXTUP:STATE:END -->

That block is real output rather than a mock-up — cargo run -p nextup-core --example gen_demo -- <dir> en produces it — abridged here by one trailing line that points at the full snapshot.

Delete the markers and the engine stops touching the file entirely. Continuity is a guarantee you can revoke.

Both listings above are abridged. The authoritative account of what lands on disk, which files are the truth and which are rebuildable derivatives, is the disk contract.

Quick start

Download an installer from the releases page:

| Platform | What to take | |---|---| | Windows x64 | .msi or .exe to install — or the _portable.zip, which needs no installer at all | | macOS arm64 | .dmg | | Linux x64 | .deb, .AppImage, or .rpm |

Nothing carries a publisher certificate and nothing is notarized, so the first launch is stopped: SmartScreen on Windows, Gatekeeper on macOS. reference/building has the click path past each. From 0.2.0 on, Settings → About → Check for updates installs a newer version for you, verified against a signature first; nothing is checked in the background. Earlier versions and the Windows portable zip mean coming back here for it.

<details> <summary><strong>Or build from source</strong></summary>

Prerequisites — Rust (stable, MSVC toolchain on Windows), pnpm, and WebView2 on Windows 10. You don't need to manage Node: the repo pins the version and pnpm fetches it.

git clone https://github.com/white1024/agent-nextup.git
cd agent-nextup
pnpm install
pnpm tauri build     # the first build takes a while

The installer lands under target/release/bundle/. If you are developing, pnpm tauri dev runs the app without installing.

</details>

Then:

  1. Create a project — launch the app, choose Initialize new project, pick a folder, name it, pick a workflow template, and tick any capability modules you want (collaboration, teams, team coordination, specs — all off unless you tick them). Templates ship built in for software, research, business, life planning, and anything else; drop a JSON file into ~/.nextup/templates/ to add your own, with no recompilation.
  2. Connect an agent (optional) — authorise the write tools you wa

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars3
CategoryAutomation
Updated7d ago
Forks0

Languages

Rust

Trust signals

92/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 low