gyve is the dev harness for coding agents. One MCP connection hands Claude Code, Cursor or your own agent your stack, the patterns to follow, current docs and the next step. Then it remembers what got done, for the next session and the next teammate.
claude mcp add --transport http gyve https://api.gyve.dev/v1/mcpFree trial, no cardAny MCP clientNever sees your code
Try it, right here
Pick what to build and which agent builds it. Run the path a step at a time and watch every check pass. Then switch agents half way: the new one has never seen the project and carries on anyway.
Press “Run next step” to start a session.
Autopilot is driving, handing the project to a new agent every few steps. Press any control to drive it yourself.
The problem
Your agent is brilliant and has no memory. So you retype the stack, the conventions and the gotchas, every session, for every agent, on every machine. Flip the switch.
How it works
gyve is to building software what a harness is to an LLM: the tools, the context and the procedure around the model. Every agent you use plugs into the same one.
The agent searches the catalog for the kits and path that fit what you're building.
get_project hands it the stack, the patterns to hold to, and the next step's instructions.
It does the step on your machine, then runs the step's done-when checks.
complete_step saves a note of what changed, so the next session starts there.
What your agent gets
The setup guides, the conventions, the gotchas and the definition of done that usually live in someone's head, served to the agent at the moment it needs them.
Few, well described and forgiving: find, brief, act and record. Pick one to see what comes back.
Everything to carry on: the stack, the patterns to hold to, progress, and the next step's instructions.
← {
"project": { "name": "Invoicer", "path_key": "saas-starter" },
"stack": [
{ "kit": "sqlalchemy", "patterns": ["Repository pattern…"] },
{ "kit": "stripe", "patterns": ["Your database is the…"] }
],
"path_patterns": [
"Routes -> services -> repositories"
],
"steps": [
{ "step": "run-locally", "done": true,
"note": "Stack up, signed in as the seeded owner" },
{ "step": "first-model", "done": false }
]
}
## Next step
# Add your first domain model
## Done when
- uv run alembic check reports no differences
- uv run pytest passes, including a test for the new routesEvery kit checked against its own docs and dated, with its llms.txt when it has one.
Each step ends with checks the agent runs before it can call it finished.
The mistakes models make from stale training data, handed over before the first line.
Verify the signature against the raw bytes before parsing
What people and agents did, in your organization's audit log, as it happens.
For the whole team
Every minute someone spends telling an agent how your stack works is a minute gyve could have handed over. And because progress is shared, Monday's session, Tuesday's agent and Wednesday's teammate all pick up where the last one stopped.
Your own estimate: people × sessions × minutes × 21 working days. It doesn't count the bugs from stale APIs.
Each step is finished with a note. Whoever is next, person or agent, starts from it, and leads see every step, who did it and when.
Works with ItsOpen
Every SaaS built on gyve's path ends at “Watch it in production”, and the catalog's ItsOpen kit takes it from there: uptime checks on the API and the dashboard, a report button for visitors, a status page, and a read-only key so your agent asks “is production OK?” before it touches anything.
Uptime checks, visitor reports and a status page, so you hear about an outage before customers do.
$ curl api.itsopen.dev/v1/agent/summary
{ "headline": "12 of 12 monitors up, no open incidents." }Questions
A rules file is one repository's notes, written once and slowly going stale. gyve's kits are checked against each library's own docs and dated, paths add the order to do things in and checks for when each step is done, and progress is shared by every agent and teammate on the project instead of living in one chat. Keep your rules file for what's particular to your code; gyve covers the stack.
Any client that speaks MCP over HTTP: Claude Code, Cursor, VS Code, the Claude API's MCP connector, the Claude Agent SDK, or your own. You connect with one key.
No. Your agent runs where it always does and works on your code there. gyve only holds your projects, which steps are done and the notes agents leave.
Every kit is checked against its own documentation and dated with when it was last reviewed. The catalog changes are reviewed like code and ship with every release. Where a kit publishes an llms.txt, gyve points agents to it for the newest reference.
Start a project with no path and just the kits you use: your agent still gets each kit's setup guide, patterns and pitfalls. You can add kits to a project at any time, and an agent can do it for you with add_kits.
Yes. Every tool call is recorded in your organization's audit log, every finished step shows who did it, when and their note, and any step can be reopened to have it done again.
Individual and Team start with a 14-day free trial and no card. Agents don't take seats, so you pay for people, not for how many agents they run. See the pricing page for every plan.
$ claude mcp add --transport http gyve https://api.gyve.dev/v1/mcp \
--header "Authorization: Bearer $GYVE_KEY"