a reasoning graph for coding agents
zhèngmíng
rectification of names
名 · Confucius

Your agent reasons in a chat log.
Give it a workbench.

verstak is a set of skills plus an MCP server. As the agent works, it writes decisions, open questions, and module boundaries into a graph; the next session reads the graph and continues.

Bench is free · Forge $4.99/mo · Claude Code, Cursor, Codex.

What changes in your work

The agent reads and writes the graph while it codes. No step after the work, no summary pass.

01

It checks new work against standing decisions

When you settle on one queue instead of three, the agent writes the decision and its why into the graph. Later, when a change would cross that decision, the agent finds the node and flags the conflict instead of quietly re-deciding.

solves the agent silently re-deciding what you already settled
reasoning log
▸ task · add a second work queue
↵ found · a standing decision: one queue, not three
● flagged · this crosses it — raising the conflict
02

It picks up where the reasoning stopped

A session dies mid-refactor. The next one runs orient, finds the transformation still open in the graph, and continues from the exact question it stopped at.

solves the re-explaining at the top of every session
SESSION ENDS ? the next session continues the open path
03

It sees where it is guessing

Open questions and unverified assumptions are nodes with a lifecycle, so the agent can't drop one silently. Detectors raise contradictions and drift between the model and the code before they land in a PR.

solves confident code built on an unchecked guess
? RAISED the open question stays on top until it is resolved
04

Several agents, one graph

Run one agent on the code, another logging decisions, a third triaging risks. They work in the same graph under different mandates, and everything they write lands in one place you can read.

solves parallel agents that can't see each other's reasoning
code decisions risks one graph you can read, three mandates writing it

Kill the session. Run orient.

A recorded run, uncut: the session ends mid-refactor; the next one orients on the graph and continues at the open question. In the same run, the agent hits a recorded decision and raises the conflict instead of coding through it. Then open the graph yourself: the reasoning reads as a map you can traverse, node by node.

session · continue
$ session ended · mid-refactor
▸ orient · reading the graph
↵ open · transformation still running: split the queue
● resume · at the exact question it stopped at
▸ change · would add a third queue
⚠ conflict · standing decision: one queue, not three
↩ raised · handed to you, not coded through
graph · read
▸ decision · one queue, not three
↳ why · ordering is load-bearing
↳ crosses · worker pool, retry path
? question · backpressure limit
↳ state · open, blocks the merge
▸ boundary · queue module
↳ in · api  ↳ out · workers, metrics

Not a memory.
A reasoning layer.

Memory tools extract summaries after the work and inject them into context. In verstak, the graph is where the agent structures the work itself: decisions with their reasons, questions with a lifecycle. New work attaches to those nodes and gets checked against them.

01

Structures the problem while solving it.

Not a transcript kept after the fact. As the agent works, decisions and their reasons land in the graph as nodes, and new work attaches to them, so the structure of the problem is the thing you read back.

02

Tracks what it doesn't know.

Open questions and unverified assumptions are nodes with a lifecycle the agent can't quietly drop. It raises them, parks them, brings them back, and flags where the model no longer matches the code.

03

Built for agents working in parallel.

The graph is a shared workspace, not a chat log. Several agents work the same map at once, one coding, one logging decisions, one triaging risks, coordinating through it while you set direction.

For one, a personal reasoning assistant; for a team, a shared reasoning substrate.

Five moves your agent
learns to make.

Each comes from a tradition that spent centuries on it, and each leaves one concrete mark on your code.

zhèngmíng 名 · Confucius 01 / 05

Name it right.

Your agent reads what the function does, then renames it to match, so the name stops lying to the next person who opens the file.

Hand your agent one line.
It wires itself up.

npx verstak setup. Skills land in the agent, the MCP server registers, and your first session seeds the graph from the repo.

$ npx verstak setup
Add --claude, --cursor, or --codex to target one agent. The skills are public at github.com/verstak-ai/skills.
01 skills land

The agent pulls the five skills from a public repo and installs them under the verstak prefix. Read them first if you want.

02 mcp registers

It wires the MCP server into your agent and signs you in over OAuth. Approve it once, or drop in an access token.

03 the graph seeds

On the first session the agent reads your repo and seeds the graph in passes, keeping the structure the code already shows.

Plain answers.

Where does my code live?

In your repo. The graph holds what the agent writes about it, not the source.

What does the server store?

The nodes the agent writes: decisions, questions, boundaries, and their links.

What is an operation?

One graph call from your agent: a read, a write, or a search.

Which agents work?

Claude Code as a plugin; Cursor and Codex through the same skills and MCP server.

Bench or Forge.

Same skills, same graph on both plans. The line is operations.

Bench
Tinker freely
$0/month
1,000 operations / month
  • The whole method, all five skills
  • Claude Code, Cursor, Codex
  • MCP and skills bundle
Start free
for daily driving Forge
Build for real
$4.99/month
10,000 operations / month
  • Everything in Bench
  • 10× the monthly runway
  • Priority on new skills
Move to Forge

An operation is one call your agent makes to the graph: a read, a write, or a search.