Updated: 2026-10-09

Open GSD[1] is an open-source toolkit for steering coding agents (Claude Code, Codex, Copilot, Cursor and others) without losing the thread of a project. The name sums up its method: “Git. Ship. Done.”

The code lives in the open-gsd organisation on GitHub[2], mainly gsd-core[3] for the agent you already use and gsd-pi[4] for the terminal. This article, updated on 9 October 2026, covers the problem it tackles, how its loop works, which piece to install and what is still missing.

Key takeaways

  • Open GSD fights context rot: the quality drop an agent suffers as its context window fills up.
  • It structures work into five repeating steps: discuss, plan, execute, verify and ship.
  • The heavy work (research, planning, execution) runs in fresh-context subagents so the main session stays lean.
  • Two pieces carry the project: gsd-core 1.16.0, a command pack for the agent you already use, and gsd-pi 1.21.1, a standalone terminal agent.
  • Both are free software under the MIT license, install from npm, and continue the original GSD workflow created by Lex Christopherson.

Where Open GSD comes from

Open GSD continues the original GSD workflow that Lex Christopherson, known online as Taches, created. Its maintainers credit him on an origin page[5] and are rebuilding the framework, the CLI and the hosted pieces as an open ecosystem. That is why gsd-pi restarted its version numbers at 1.0.0 under the open-gsd organisation, and why its changelog starts there.

The problem it solves

Anyone who has run an agent through a long session knows the pattern: it starts sharp and, as its context window fills, it begins to forget decisions, repeat work or wander off. The docs call this “context rot.” It is not a one-off glitch, it is the cost of piling too much information into a single conversation.

Open GSD starts from that observation. Instead of cramming everything into one session, it splits work into phases and runs each task in a subagent that starts with a clean context. The session you talk to stays light; the heavy lifting happens elsewhere and comes back summarised. The project’s site puts it this way:

“Open GSD keeps agentic work from dissolving into context bloat: explicit task graphs, clean execution contexts, real verification, and git history that tells the truth.” (opengsd.net)

The workflow loop

The method runs five steps that repeat for each project phase:

  • Discuss: capture implementation decisions before anything is planned.
  • Plan: research, decompose the task, and check the plan fits a fresh context window.
  • Execute: plans run in parallel waves and each executor starts with a clean context of 200,000 tokens.
  • Verify: walk through what was built, diagnose and fix before declaring anything done.
  • Ship: open the pull request, archive the phase and move to the next.

If that sounds familiar, it is the same discipline behind other skills-and-subagents patterns. What Open GSD adds is the packaging: gsd-core 1.16.0 ships 72 ready-made commands, including /gsd-new-project for a new repository and /gsd-onboard for an existing one.

Which Open GSD tool to install

Start with gsd-core if you already work inside Claude Code, Codex or Cursor, and pick gsd-pi if you want an agent of its own in the terminal. The rest of the catalogue grew around those two, and by October 2026 two pieces are still announced rather than released:

Piece What it is Version (9 Oct 2026) Status
gsd-core Commands, skills and hooks that add the loop to Claude Code, OpenCode, Codex, Copilot, Cursor, Windsurf and other runtimes 1.16.0 Stable
gsd-pi The standalone terminal agent: Git worktrees, project memory under .gsd/, and a web control panel with gsd --web 1.21.1 Available
gsd-path A gated project pipeline that writes its handoffs to .project/ 1.5.0 Available
gsd-browser Browser automation over the Chrome DevTools Protocol, with MCP tools, assertions and traces 0.2.2 Available
gsd-graph Local knowledge graphs extracted from your project docs 0.4.0 New
gsd-loop Works a labelled GitHub issue queue into reviewed pull requests and leaves the merge to you 0.4.1 New
gsd-workbench A desktop app with approvals from your phone – Coming soon
gsd-cloud A hosted workspace that keeps project state across devices – Coming soon

Each of the two main pieces installs with one command. The gsd-core installer asks which runtime you use and whether to install globally or for one project:

npx @opengsd/gsd-core@latest

The gsd-pi package installs the gsd command globally. If you installed the older unscoped gsd-pi package, remove it first so its binary does not shadow the new one:

npm install -g @opengsd/gsd-pi@latest

The gsd-core installer requires Node.js 24 or later, and gsd-pi requires Node.js 22.18.0 or later plus a model provider. Our guide to installing gsd-pi with a local model walks through a first real task end to end, including the seven traps we hit along the way.

My take

I like the approach, partly because it is the one we already follow here. If you have built an agent with the Anthropic SDK or a RAG on Postgres, you know the bottleneck is not the model, it is holding focus for hours. Isolating each task in a worktree and its own context is sensible and hardly new, but having it packaged with commands and project memory saves real work.

I tried it on a small project, and the difference shows most on long sessions. The plan is written down and each executor starts fresh, so you are not constantly reminding the agent what was already decided.

The honest part: although the catalogue has grown to eight pieces, the core is still gsd-core and gsd-pi. The project also moves fast (gsd-pi went from 1.5.0 in July to 1.21.1 in October), so pin a version in anything you automate. It assumes your team already has access to a model provider, because Open GSD routes whichever one you give it rather than bundling its own. For small, one-off changes the ceremony is overkill; for long agent sessions it earns its place.

Frequently asked questions

Where is the Open GSD GitHub repository?

The project lives in the open-gsd organisation on GitHub[2]. The two main repositories are open-gsd/gsd-core[3], with more than 10,000 stars in October 2026, and open-gsd/gsd-pi[4]; the npm packages sit under the @opengsd scope.

How is it different from just using an agent?

A plain agent keeps everything in one conversation, which degrades as it fills. Open GSD splits the work into phases and runs each task in a subagent with a clean context, so the main session never saturates. In exchange it adds structure: for a small change it can be overkill.

Does it cost anything?

No. gsd-core and gsd-pi are free software under the MIT license and install from npm. What you do need is access to a model provider (OpenAI, Anthropic or a local server), because Open GSD bundles none of its own.

Which editors and agents does it fit?

The gsd-core installer supports Claude Code, OpenCode, Codex, Copilot, Cursor, Windsurf, Antigravity CLI, Kimi CLI and Kilo, so it works with the flow you already use. If you would rather not depend on any of them, gsd-pi runs on its own in the terminal.

Conclusion

Open GSD does not invent a new technique, it brings order to one that already works: plan small, execute in clean contexts, and verify before closing. With an MIT license and a one-command install, the cost of trying it is low. It is worth a look if you work with coding agents day to day, and the gsd-pi install guide is the shortest path to a first finished task.

Sources: opengsd.net[1], Open GSD origin page[5], open-gsd on GitHub[2], @opengsd/gsd-core on npm[6], @opengsd/gsd-pi on npm[7].

Sources

  1. Open GSD
  2. open-gsd organisation on GitHub
  3. gsd-core
  4. gsd-pi
  5. origin page
  6. @opengsd/gsd-core on npm
  7. @opengsd/gsd-pi on npm