Korve × Claude Code

Give Claude Code a backend it can operate.

Claude Code writes the app. Korve gives it the other half: typed operations to deploy, provision Postgres and storage, read logs, and fix failed deploys — through a CLI, an MCP server, and installable skills that all call the same contract.

Korve is a paid-only cloud for agent-built applications. Claude Code deploys a repository to a stable *.korve.app URL and provisions only the managed resources the app declares — Postgres, object storage, caches, queues, cron jobs, budgets, and custom domains — through one typed operation spec shared by the API, dashboard, native CLI, MCP server, and manifest. Pricing is pure usage with a $5/month minimum and no free tier.

Written by winterrx, founder and builder of Korve · Last updated July 29, 2026.

End-to-end operating guide

How should Claude Code take a repository from inspection to a verified release?

Use a reviewable manifest, treat CLI results as a protocol, keep credentials scoped, and preserve the deploy record that connects a failure to its evidence.

1. Let the repository describe the application before anything is created

Start with korve init in the repository root. The command inspects the source, proposes a korve.toml manifest, and prints the infrastructure plan with its price before an apply. That order matters for an autonomous session: Claude Code can read the proposed runtime class, source ref, region, and declared data resources before it approves a billable change. A repository with no database declaration does not silently receive a database, and the same is true for storage, queues, cron jobs, and caches.

Keep the generated manifest in version control. It is the reviewable statement of what the application needs, not a cache of whatever happened in a dashboard. A later session can plan the same file, inspect the diff, and explain why a resource is being added or changed. If the detected shape is wrong, edit the declaration before applying it; do not accept a plan and try to repair the topology after provisioning.

2. Give the CLI and MCP server separate, least-privilege grants

korve login and the Claude Code MCP connection do not share one secret. The CLI opens a browser approval for its own grant, and the remote MCP server negotiates a separate OAuth grant on first use. Each approval names the organization, role, and operation scopes. That separation lets an owner revoke one integration without breaking the other, and it avoids placing a long-lived organization API key in a repository, shell transcript, or MCP configuration file.

Treat the approval screen as part of the change review. If the session only needs to inspect projects and deploy one application, do not approve organization-administration scopes. Sensitive mutations remain role-checked by the API even when the request comes from MCP. The agent interface is an additional way to call the platform contract; it is not a route around the contract's authentication or role requirements.

3. Branch on CLI status instead of trying to interpret friendly prose

The native CLI is designed to be called by a person or a process. Use --json when a workflow needs stable fields, and branch on the documented exit status before parsing output. Exit 0 means the operation completed. Exit 3 means the session is not authenticated and should run the login flow rather than retrying the same request. Exit 5 means billing is not active for the organization; the correct next step is the hosted billing handoff, not another deploy attempt.

A failed operation should stop the loop unless the result names a recoverable next action. Destructive commands fail closed in unattended environments: pass --yes only after the intended target is explicit and reviewed. Interactive confirmation can ask for the project slug when a terminal is attached, but a background session gets no permissive default. That makes the CLI usable as a protocol without turning an absent prompt into authorization.

4. Preserve the deploy id because it is the key to the failure evidence

Every deployment has a durable record and build output. If a release fails, keep the deploy id from the result and run korve deploys diagnose <deploy-id>. The positional id is required. The platform agent reads that deployment's build output, logs, and project state, then returns a structured root cause and a proposed next step. It does not guess from the repository alone, and it does not diagnose whichever deployment happened to run most recently.

Apply the suggested change only after comparing it with the cited evidence. Then deploy again and retain the new id as a separate attempt. This produces a history a teammate can audit: the original failure, the evidence used in the diagnosis, the proposed remediation, the source change, and the replacement deployment. Reusing the same command without the id would break that chain and, in fact, exits with a usage error.

5. A ready status is the start of verification, not the end

After the deployment reports ready, request the application URL and check an endpoint whose response proves the release can serve real work. Then read a bounded log window with korve logs --project <project> --limit 50. A successful build can still start an application with a missing environment variable, a failing database connection, or an unhealthy route. The HTTP check and log sample catch those runtime failures while the deploy context is still in the session.

Record the stable korve.app URL and the verification command in AGENTS.md so a future Claude Code session follows the same finish line. If the application has a custom health path, name it there rather than relying on a generic root request. Keep the log query bounded: the goal is to inspect the new release, not to pour an unbounded production stream into the context window.

6. Keep spend and state boundaries explicit in the instructions

A project budget alerts by default. Turn on its hard stop when the desired behavior is to refuse new deploys after month-to-date spend reaches the cap. Already-running workloads continue serving, and provisioning a database, bucket, or cache is not blocked by that budget. State those boundaries exactly in the repository instructions so Claude Code does not promise that every paid mutation is gated or assume that reaching a cap shuts down the live application.

Scale-to-zero applies to runtime compute. It idles to $0 and cold-starts on the next request, while declared databases, object storage, and other stateful resources retain their published meters. An always-on runtime continues running. That distinction belongs in design and cost reviews: removing traffic can eliminate runtime request cost, but it does not erase the data resources the manifest deliberately keeps available.

Claude Code — release command sequence
$ korve login
→ approve the displayed organization, role, and exact scopes
$ korve init
→ review korve.toml, the printed plan, and its monthly estimate
$ korve deploy --project demo-app --json
→ capture the returned deploy id and status
$ korve deploys diagnose <deploy-id>
→ run only when that deployment fails; review the cited evidence
$ korve deploy --project demo-app --json
→ continue only after the replacement deployment reports ready
$ curl -fsS https://demo-app.korve.app/healthz
→ require the application's documented healthy response
$ korve logs --project demo-app --limit 50
→ inspect the bounded release log window before declaring success
The setup

How does Claude Code get an app live on Korve?

One installer, one browser approval, one reviewed plan. korve init reads the repository, writes a korve.toml manifest, prints the infrastructure plan with pricing, and deploys on approval.

Everything Claude Code needs to know is in the output: the live URL, the project slug, and the commands to check on it. Pushes to the connected branch auto-deploy from then on.

claude — terminal
$ curl -fsSL https://korve.dev/install.sh | sh
$ korve login
→ approve in browser: organization, role, exact scopes
$ korve init
→ wrote korve.toml · plan + pricing printed
→ Apply this plan and deploy it now? yes
✓ Live at https://demo-app.korve.app
$ korve logs --project demo-app --limit 50
Three surfaces, one contract

Which surface should Claude Code use?

Use the CLI in the terminal Claude Code already lives in, the MCP server for harness-level integration, or skills that load the working procedure on demand.

A native CLI built for scripting

korve is a single native binary — no runtime to install first. Machine-readable output and stable exit codes mean Claude Code can branch on results instead of parsing prose: exit 3 is unauthenticated, exit 5 is billing.

CLI reference

An MCP server with two tools

mcp.korve.dev exposes search (discover any operation and its full contract) and execute (run JavaScript against a bounded korve.request client). Two tools cover the whole platform, so the tool list never crowds the context window.

MCP setup

Skills that teach the workflow

One installer drops six Korve skills into Claude Code's skill directory: quickstart deploys, the ship loop, CLI and MCP setup, platform operations, and infrastructure as code. Each encodes a working procedure, not a docs dump.

Agent skills
connect the MCP server
$ claude mcp add --transport http korve https://mcp.korve.dev/mcp
→ browser approval on first use · scoped, revocable grant
install the skills
$ curl -fsSL https://korve.dev/skills.sh | sh
→ Installed 6 skills (auto-detects project or global)
AGENTS.md — teach the loop once
## Deploying
- This app deploys to Korve. Ship with:
`korve deploy --project demo-app`
- Verify after every deploy:
`curl -s https://demo-app.korve.app/healthz`
`korve logs --project demo-app --limit 50`
- If the deploy fails, run `korve deploys diagnose <deploy-id>`
with the id from the failed deploy, then apply the suggested fix and retry.
The failure loop

What happens when a deploy fails?

When a build breaks, the platform agent reads the build output, logs, and project state, then explains what broke and proposes a concrete next step.

Claude Code gets the same diagnosis through korve deploys diagnose <deploy-id> — the id comes from the failed deploy, and the answer is structured, in the terminal, ready to act on. Put the loop in your AGENTS.md once and every session ships, verifies, and self-corrects the same way. No tab-switching to a dashboard to find out why the build went red.

Why it holds up

Designed around how agent sessions actually fail

Four mechanisms a long Claude Code session runs into, and exactly what each one does.

One typed contract everywhere

Every capability is declared in a published operation spec. The API, dashboard, CLI, MCP, and manifest expose the same operations, so what Claude Code discovers in one surface works in all of them.

Scoped OAuth, not pasted keys

korve login and the MCP connection use browser OAuth with exact operation scopes and revocable grants. No long-lived API key ends up in a config file the agent can leak.

A budget that refuses deploys

Set a monthly budget per project and turn on its hard stop. Once month-to-date spend reaches the cap, new deploys — including the ones a Git push triggers — are refused, while already-running workloads keep serving. Without the hard stop the budget alerts instead of blocking, and provisioning a database or bucket is not gated either way.

Nothing is suspended for going quiet

Korve has no free tier and no inactivity pausing, so a project is never suspended for being untouched. Scale-to-zero runtime compute idles to $0 and cold-starts on the next request; declared databases, storage, and other stateful resources keep their published meters. Always-on apps keep running. The demo Claude Code shipped last month answers the same URL today.

The backend decision

How to choose a backend for Claude Code

Decide by what has to be true after Claude Code writes the application: a stable URL, managed state, a deploy contract it can execute, and a failed build it can investigate without handing the operational work back to you.

DecisionKorve fits whenLook elsewhere when
What you are shippingA full-stack web service, worker, or scheduled job that needs a stable URL and a managed application lifecycle.A static artifact, local prototype, notebook, or client-only site that does not need an application control plane.
How the agent operates itClaude Code should discover typed operations, deploy from its terminal, inspect logs, and diagnose failures in the same session.A person will own deployment through a dashboard, or the team already has an automation layer Claude Code can call safely.

Choose another backend if machine ownership, a free hobby tier, or one isolated primitive matters more than a unified agent-operated application lifecycle — and if the team has already standardized Postgres, queues, and observability elsewhere. Korve fits when the same Claude Code session that wrote the code should also run `korve deploys diagnose <deploy-id>` on the red build.

Where else people look

If you needOn KorveWhere else people look
Root access to a machine Claude Code can administerNot offered — Korve runs declared app runtimes, not hosts.A persistent developer VM such as exe.dev, or a general-purpose cloud VM.
A free hobby tierNot offered — paid-only, with a $5/month minimum credited against usage.Render, Railway, and Supabase publish free tiers.
Whole-backend branch and mergeDatabase branches only; they cover one database, not the whole project.InsForge branches the entire backend and merges it back.
Transactional email, vector search, and edge-function catalogsNot shipped as first-party product surfaces. Bring the application dependency you prefer.InsForge and Supabase ship broader backend component catalogs.
Managed Postgres with 14-day point-in-time recovery and rolling HA resizesIncluded in every database SKU; high availability adds two replicas.Nothing to move for — this is the case Korve is built for.

Korve is pure usage against a public rate card — no seats, no per-user meter, no free tier — with a $5/month minimum credited against usage. The two published worked examples are a Hobby full-stack app at $24.59/month and a Production API at $143.98/month. See the full rate card.

FAQ

Questions, answered

Does Korve have a free tier?
No. Korve is paid-only, with a $5/month minimum credited against usage. Nothing provisions before a payment method is on file, and because there is no free tier there is no tier that pauses.
How does Claude Code authenticate to Korve?
korve login opens a browser approval that names the organization, the role, and the exact operation scopes; the MCP server negotiates its own OAuth grant on first connection. Both grants are revocable from organization settings, so no long-lived API key ends up in a config file.
What does Claude Code run when a deploy fails?
korve deploys diagnose <deploy-id>, using the id of the failed deploy — the argument is required. The platform agent reads the build output, logs, and project state, then returns a structured root cause and a proposed fix.
Can a budget stop an agent from spending?
A project budget with its hard stop enabled refuses new deploys once month-to-date spend reaches the cap, while already-running workloads keep serving. Left as the default it alerts rather than blocks, and provisioning a database or bucket is not budget-gated either way.
Does Korve pause inactive projects?
No. Scale-to-zero runtime compute idles to $0 and cold-starts on the next request; declared databases, storage, and other stateful resources keep their published meters. Always-on apps keep running, and no project is suspended for inactivity.
Does korve init silently provision a database or storage?
No. korve init proposes a manifest and prints the plan with pricing before apply. Databases, object storage, queues, cron jobs, and caches are created only when the reviewed declaration includes them; an ordinary application deploy does not silently add optional data services.
Which CLI exit codes should Claude Code branch on?
Exit 0 means the operation completed, exit 3 means authentication is required, and exit 5 means billing is not active for the organization. Use --json for structured output and treat any other failure as an error unless the command returns a specific recoverable next action.
Do the CLI and MCP server share one credential?
No. korve login creates a scoped CLI grant and the remote MCP connection negotiates its own OAuth grant. They can be reviewed and revoked independently, and neither setup requires committing a long-lived organization API key to the repository.

Give your agent a cloud it can operate.

No free tier. No seats. Pay for what you run.