Comet: two workflows, one config file, and no upgrade path between them
Comet: agent skill harness for turning ideas into evaluated workflows
At a glance
- What is it?
- An agent harness for long-running coding tasks that splits into a Native flow for strong models and a Classic flow built on OpenSpec and Superpowers. What is unusual is the refusal to treat them as tiers, and the amount of the design that lives in the archive and the config file.
- Who is it for?
- Comet is worth a look if your coding tasks run long enough to need resumption, and if you are willing to be explicit about which workflow a project uses rather than letting a tool guess from task size. Two things to read before adopting it.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- rpamis/comet3,299 ★ · +234
| Repository | 2026-09-16 | 2026-11-15 |
|---|---|---|
| rpamis/comet | 3.1k | 3.3k |
234 Stars in the last 60 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Native and Classic are not tiers of each other
Comet offers two requirements workflows and insists they are peers. Native is for strong models: once requirements are confirmed, the agent chooses how to plan, implement, test, and review, while Comet handles state checks, acceptance, and the resumable archive. Classic is the OpenSpec plus Superpowers phase-governance model kept in full, with a five-phase flow, a state machine, phase checks, and scripts, for work that benefits from an explicit method and strong constraints. The project states plainly that they are not lightweight and heavyweight tiers and that neither upgrades into the other. What they share is the plumbing: configuration, status, the Dashboard, and the Eval entry points. Each has a permanent entry point, /comet-native and /comet-classic, and the shared /comet command reads only the project's .comet/config.yaml to decide which one to forward to, without guessing from task size or mixing changes, state, or directories between the two. A separate resume probe uses that same configuration file to restart a task through whichever permanent entry point owns it, which is the mechanism that makes a half-finished task recoverable without a human remembering how it was started.
The archive is one command, not a sequence of status checks
Archive handling is treated as a first-class feature rather than a cleanup step, and the design goal is that it never needs a repeated conversation with the runtime. Archiving first returns a single dry-run continuation command, together with explicit choices for finishing in an isolated workspace and the paths of anything blocking the archive. Continuing the workflow then lets the Runtime own the archive commit, so there are no repeated status queries and no manual commits of runtime files. The Native archive is described as one-way and resumable, and user-readable artifacts live under docs/comet/ by default, fully separate from whatever Classic produces. Two supporting details make that workable. Comet's CLI output identifies the next step and the decisions that need your input, and the task state itself lives in the project rather than in a daemon, which is what makes a run survive an interruption or a change of session.
Supervisor Changes split a goal along delivery boundaries
For requirements too large for one agent, Native can fan out, and the mechanism has named parts. Supervisor Changes split a goal into dependency-aware child changes rather than arbitrary subtasks. Dependencies and readiness are managed as a directed acyclic graph, so a child change becomes implementable only when its inputs exist. Multiple agents then work in parallel in worktrees that the Runtime creates, and the documented implementations for those workers are independent Codex sessions or Claude Code Agent Teams. Each agent implements and verifies its own change in isolation. Results are then integrated in dependency order, and only after that integration does the parent change go to its final acceptance. The isolation is the point: parallel agents do not share a working tree, and the integration order is enforced by the graph rather than by the agents negotiating.
The efficiency numbers come with their own caveat
The release notes publish a comparison, and the shape of it matters as much as the figures. The experiment aligned Native against the 0.4.0 Classic workflow across sixteen tasks with forty-eight runs per treatment. Among the forty-one paired samples where both treatments passed, Native used 76.8% fewer total tokens, 57.4% fewer agent rounds, and 47.4% less time. Across the full sample Native reached 87.5% on pass cubed, described as twelve and a half percentage points higher, while both treatments reached 100% on pass at three. The pass at three figure is the one that matters for a quality claim, and it is a tie. The token and round reductions only apply to the subset where both succeeded, and the notes themselves point to a separate evaluation report for the conditions and limitations behind all of it. Read the numbers with that filter attached.
Memory has to be correctable, not only sticky
The memory feature is described in terms of control rather than capacity. Personal Memory and Project Knowledge exist to retain collaboration preferences and reusable experience across tasks and to supply context progressively as a task proceeds, so the agent is not handed the whole history at once. The verbs are what make it usable: you can inspect what it holds, correct it, forget it, or pause it. New lessons start in a trial state and only gain supporting evidence through actual adoption and verification, which means a piece of knowledge does not become trusted just because the model wrote it down once. The same principle governs skills. Comet can author reusable Skill packages and organise them into distributable Bundles with /comet-any, and a bundle can be pushed to coding platforms with one command, in the same spirit as comet init. Evaluation then scores those skills with Rubric criteria, Pass@k, Pass raised to the k, and LangSmith. The distribution story is deliberately narrow: the package publishes a dist directory, the bin directory with the single comet entry point, and an assets directory, and the negations in that list are what stop a maintainer-only skill and its agent instructions from shipping to users. Everything else in the repository, from the build scripts to the dashboard sources, stays out of the tarball.
A pure Node runtime is what makes Windows viable
The runtime requirement is stated as a feature. Comet runs on Windows, macOS, and Linux without Bash or WSL, which removes the usual excuse for keeping a development tool off Windows. Two consequences follow. Cross-platform execution is the default rather than a port, and recovery is part of that: task state stays in the project so work can resume after interruptions or session changes, whether that was a crash, a closed terminal, or a different agent picking the work up. The Dashboard completes the picture as a three-pane view in the browser, where Native and Classic progress, Git worktrees, acceptance results, and archives can be inspected together, alongside management of Personal Memory, Project Knowledge, and plugin settings. A resume helper is exposed for the case where you do not remember which workflow a project uses, and it reads the same configuration file as the shared entry point.
Three generated runtimes, a check mode, and two lockfiles
The package manifest shows how much of the repository is generated. The build entry is a Node script rather than a bundler config, the dashboard is a Vite build pointed at a config inside domains/dashboard/web, and there are separate build scripts for the classic runtime, the native runtime, and the entry runtime.
"build:classic-runtime": "node scripts/build/build-classic-runtime.mjs",
"check:generated": "node scripts/build/build-classic-runtime.mjs --check && node scripts/build/build-native-runtime.mjs --check && node scripts/build/build-entry-runtime.mjs --check"That check target runs each builder with a --check flag, so generated output can be verified without rewriting it, which is what keeps three code paths from drifting. The package is ESM, publishes a single binary named comet from bin, and its files list uses negations to keep test files and a bundled maintainer skill out of the tarball. Tests run under vitest, types are checked with tsc in watch mode, and the repository carries directories for two agent tools alongside its own .comet state directory. It also keeps both a package-lock.json and a pnpm-lock.yaml, so pick one package manager before you start. The evaluation side is published as part of the package rather than kept private, with subdirectories for Langfuse, LangSmith, a local mode, scaffolding, and JSON schemas, alongside an environment example file for that harness.
Editorial conclusion
Comet is worth a look if your coding tasks run long enough to need resumption, and if you are willing to be explicit about which workflow a project uses rather than letting a tool guess from task size. Two things to read before adopting it. The Native and Classic comparison comes with its own measurement, sixteen tasks and forty-eight runs per treatment, reported with a pointer to the conditions and limitations, so treat the token and round reductions as one data point rather than a promise. And note that the runtime is pure Node with no Bash or WSL requirement, which is what makes the Windows path viable at all.
Frequently asked questions
What is Comet in AI?
An agent skill harness for coding, described as a resumable long-running task workflow and Skill platform. It provides two independent requirements workflows, Native for strong models on Comet's own runtime and Classic, which preserves the full OpenSpec plus Superpowers phase-governance model, plus tooling to create, distribute, and evaluate skills.
What is the difference between Comet's Native and Classic workflows?
Native lets the agent choose how to plan, implement, test, and review after requirements are confirmed, while Comet handles state checks, acceptance, and archive. Classic keeps the five-phase governed flow with stronger constraints. The project states they are not lightweight and heavyweight tiers and that neither upgrades into the other.
How does Comet's parallel delivery work?
Supervisor Changes split a goal into dependency-aware child changes, with readiness managed as a graph. Independent Codex sessions or Claude Code Agent Teams implement and verify them in worktrees the Runtime creates, and results are integrated in dependency order before the parent change's final acceptance.
Does Comet need WSL to run on Windows?
No. The runtime is pure Node.js and supports Windows, macOS, and Linux without Bash or WSL. Task state stays in the project, so work resumes after interruptions or session changes, and the CLI output names the next step and the decisions waiting on you.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/rpamis-comet)Star history chart for your README
[](https://hysenlabs.com/projects/rpamis-comet)Was this useful?