grasp
grasp
Review what your coding agent did, decision by decision.
AI agents write code faster than people can review it. grasp shows you what the software does now compared with before (real outputs, not the agent's summary), walks you through each decision with Approve / Reject, warns you what the change could break, and sends rejections back to the agent.
Install in Claude Code (no Go needed):
/plugin marketplace add arsaljamal/grasp
/plugin install grasp@graspWork as usual, then type /grasp:review. For a pull request without an agent session, see PR mode.

Start here: guess, then see; and what it could break | Reject with a note for the agent |
|
|

How it works
you ask ──► agent decides ──► agent changes files
│ │ │
└──── grasp reads the session (hooks + transcript) ────┐
│ │
agent calls record_decision (MCP) every edit is linked to
"what, why, files, alternatives, risk" the decision that explains it
│ │
└────────► review page ◄──────────────────┘
approve · reject · comment
│
agent calls get_review_feedback (MCP) and follows it next timeShow, don't tell. The agent gives a short command that demonstrates a change (for example: start the server, send an empty title, print the response). grasp runs it on the code from before the session and on the code now, and shows both outputs side by side. The agent cannot fake them: grasp runs them itself. Decisions with no demonstration say so.
Guess first, then see. On the start card the new output stays hidden until you think about what it should be. Then you say whether it matched. Anything that surprised you is flagged before you approve it.
What it could break, checked by grasp, not the agent. It flags existing tests the agent changed or weakened, and finds code elsewhere in the project that uses a function the agent changed but was not updated (or a deleted function that is still called).
Decisions, not lines. Each decision shows why, the options the agent rejected, the risk it saw, and the exact changes that carry it out.
Nothing hides. Edits that no decision explains are grouped as changes with no recorded reason. Files a decision names but never touches are flagged as unverified claims.
Works without cooperation too. If the agent records no decisions, grasp groups edits by what the agent said just before making them, and marks those groups as inferred.
One thing at a time. Each decision is a card; the code and the full reasoning stay hidden until you ask for them. Watch plays the session like a reel: story bars on top, one animated scene per step (the request typing out, decision cards flipping in, changed lines sliding in, commands running), with speed control and tap-to-skip.
Closes the loop. Rejections and comments become instructions the agent reads through
get_review_feedbackat the start of its next task.
Related MCP server: Pingfusi
Quick start (Claude Code)
The plugin (above) downloads the right grasp binary on first use and checks its checksum. Then work as
usual and type /grasp:review when you want to review.
Or install the command yourself and set up one project:
go install github.com/arsaljamal/grasp/cmd/grasp@latest
cd your-project
grasp init # adds the MCP server (.mcp.json), hooks (.claude/settings.json) and a CLAUDE.md note
claude # work as usual
grasp serve # open http://127.0.0.1:7080 and review; it updates live while the agent worksAlready have sessions? grasp import --latest loads the newest Claude Code session for this folder, or pass
transcript files: grasp import ~/.claude/projects/<project>/<session>.jsonl.
Reviewing a pull request (no agent session)
Most changes reach reviewers as a pull request, not as a live agent session. Check out the branch and run:
grasp pr -base origin/main -title "PR title" -body "PR description" -explain
grasp serveWithout -explain, each commit becomes a decision (its message is the reason) and you still get the full
"What it could break" check. With -explain, Claude Code reads the diff (as files, with no write access),
records the real design decisions, says where to look first, and demonstrates behavior with show_behavior,
which runs on the base commit and on the branch. Every claim is linked to the actual diff, and test files
are grouped with the code they test.
Commands
Command | What it does |
| Set up Claude Code in this project. Merges into existing config files, never overwrites them. |
| The review page, on 127.0.0.1:7080 by default. |
| Load a branch or pull request from git; |
| Load Claude Code transcripts. |
| Print reviewer feedback as Markdown instructions (the same text the agent gets). |
| The MCP server the agent starts: |
| Claude Code hook entry point. Always exits 0, so it never blocks the agent. |
State lives in .grasp/ in your project: parsed sessions, reviews.json (commit it to share verdicts with
your team) and decisions.jsonl (decisions from agents grasp has no transcript for).
Safety
show_behavior runs shell commands the agent writes, from your project folder, so treat it like giving the
agent shell access: approve it per call, or allow it only where you would allow the agent's own shell. The
"before" side runs in a temporary git worktree of the commit the session started on; your working files are
never touched. Each run is stopped after 90 seconds, along with anything it started in the background.
Other agents
Any MCP-capable agent can call record_decision and get_review_feedback; those decisions show up in an
agent log session. Full timelines (edits, commands, Watch mode) currently come from Claude Code transcripts.
Adapters for other agents' logs are welcome.
Status
Early, and built in the open. Tested end to end with Claude Code on a sample service (docs/example.md). Ideas next: checking decisions against a written spec, a GitHub PR check that blocks merges with rejected decisions, and team views across many sessions.
License
MIT
Available Tools
3 toolsget_review_feedbackA
Get reviewer verdicts and comments on your earlier decisions. Rejected decisions and comments are instructions to follow.
Returns: items
record_decisionA
Record a decision before making the changes that carry it out, so reviewers can approve or reject it. Use one call per decision (architecture, data model, API, business rule, dependency, security, performance, testing, quality).
Inputs: why (required), kind (required), files (required), title (required), +2 more. Returns: id, status
show_behaviorA
Show reviewers what a change does. grasp runs your command twice, on the code from before this session and on the code now, and shows both real outputs side by side. The command runs from the project root with sh; it must start and stop anything it needs and print a short result. Use one call per behavior you want to demonstrate.
Inputs: title (required), command (required), expect, decision. Returns: result, summary
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
Each tool occupies a distinct phase of the review loop: record_decision writes, show_behavior demonstrates evidence, get_review_feedback reads reviewer verdicts. No two tools could plausibly be selected for the same intent.
All three names follow a strict verb_noun snake_case pattern (get_review_feedback, record_decision, show_behavior). The verbs accurately signal direction (read/write/demonstrate).
Three tools is minimal but each maps to a necessary step in the submit-review-revise workflow, so nothing feels padded. It sits at the low end of the comfortable range, leaving little room for auxiliary operations.
The core loop (record decision, demonstrate behavior, collect feedback) is fully covered. Minor gaps exist around inspecting previously recorded decisions or withdrawing/amending one, but the workflow can proceed without those.
Maintenance
Related MCP Connectors
Hosted review records for AI coding agent changes: inputs, outputs, checks, open questions.
Visual testing for coding agents: your agent sees every UI change it makes and triages each diff.
Issue tracker for coding agents: a real backlog, plus a risk-ranked review of every change.
Human-in-the-loop for AI coding agents — ask questions, get approvals via Slack.
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables humans to review AI-generated code changes through a GUI: agents freeze git diffs and add findings/diagrams, while reviewers annotate and save decisions returned as an exact correction prompt.17302 npmISC
- AlicenseNot gradedqualityAmaintenanceLets AI coding agents hand off in-progress work to real human reviewers, who pin comments to the exact elements that are wrong and send back a verdict. The agent then revises and re-files until a person approves, so only human-signed-off output reaches the user.38 npmMIT
- AlicenseNot gradedqualityAmaintenanceEnables AI coding agents to publish their work mid-task and hand it to a real human reviewer, who pins comments to the exact elements that are off and returns an approval verdict. The agent then iterates on that human feedback until the work is signed off.38 npmMIT
- AlicenseNot gradedqualityAmaintenanceEnables AI coding agents to request real human reviews mid-task, receiving pinned feedback and approval verdicts so they can iterate until approved.38 npmMIT

