Built for the agent era
The deploy button is your AI. The live URL is yours. The bragging rights are forever.
$git push fieldwick mainpushing 47 objects (118 KB)...detected Next.js 15 - using Nixpacksbuild [########----] 67%build complete - 41stls certificate issuedlive at flowing-otter-71.apps.fieldwick.com✓ live
Built for the builder who hands the keyboard to their AI. Email goes to an engineer on the team, not a help-desk script. Set a monthly cap and the platform throttles there - your AI cannot run up the bill past the ceiling you choose.
Live stack
Watch your stack wire itself up.
Frontend, API, database, cache, billing, email - all talking to each other from the second your AI says ship it. No glue code. No copy-pasted secrets. No DNS rituals.
Safety, built in
Every move your AI makes has a safety net.
The old platforms were built for careful humans typing slowly. This one was built for AI that ships fast and the operator keeping watch. Mistakes get caught. Bills get capped. Receipts get filed. You stay in charge.
Soft delete by default
Every destructive action is reversible for 7 days. Your agent can recover its own mistakes via `restore_service` (MCP) or `fieldwick restore` (CLI) without you restoring from backup at midnight. Domains are HARD delete on purpose - hostname uniqueness rules - and the tools warn about that distinction in their descriptions.
Confirm tokens for risky ops
Service delete REQUIRES a fresh single-use confirm token bound to (scope, targetId). The agent calls `request_confirm_token` THEN `delete_service` - either step alone fails. The two-step pattern is observable in the conversation transcript so you see the safety mechanism in action, not just hear about it.
Spend caps you set, agent respects
Set a monthly cap. The agent calls `get_billing_status` BEFORE deploying and gets back a structured headroom assessment (used%, remaining, recommendation graduated at 70/90 thresholds). At 90% of cap it surfaces the risk to you and offers to bump the cap with `set_spend_cap` - rather than silently failing the next deploy at the gate.
MCP server, native (27 tools)
Drop our config into Claude Code or Cursor in 30 seconds. Your agent gets 27 tools (14 read + 13 write) covering the entire customer journey: team -> project -> service -> deploy -> custom domain -> live serving + spend visibility + cap negotiation + pay-flow handoff + confirm-token-gated destructive ops. Same scoped, audit-logged rails as the dashboard.
CLI/MCP/dashboard parity
Anything your agent does via MCP, you can do from your terminal via the full `fieldwick` CLI (signup, login, whoami, services, deploy, scale, restore, env, billing, domain, audit-log, regions, open, init, logs, and more) - or from the dashboard UI. Inside a project directory, service-id-taking commands autodetect the service so you never copy-paste ids. Three surfaces, one audit log, one auth model, one source of truth.
Receipts: every mutation audited
Every confirm-token consume + every service change (create, deploy, env_set, scale, restore, delete) + every cap change writes an audit log row. Your agent reads its own past actions back through `list_audit_log` (MCP) or `fieldwick audit-log` (CLI) - same scoped, paginated surface you do. Your agent does not get to deny what it did.
Three-click signup-to-running-service
Built for the "I am not a real DevOps person" customer. Two parallel zero-paste arcs: (1) dashboard - sign up with email, click "Deploy your first service", click "Create + deploy", watch the build stream live. 3 clicks. (2) CLI - `fieldwick signup` then `fieldwick services create` then `fieldwick deploy`. 3 commands, zero copy-paste of ids (every CLI verb autodetects the service inside a project directory), AND zero copy-paste of bearer tokens on second-machine login - `fieldwick login` opens the dashboard with an 8-character code prefilled, you click Authorize, the bearer lands on disk through a polling loop. No env vars to set, no docs to read, no escape from the dashboard required mid-flow.
How it works
Three moves to a live website.
You do not learn anything new. You do not memorize a single command. You let your AI drive, and we make sure the car stays on the road.
- 01
You tell Claude what you want.
"Take this folder. Put it online. Call it bobsmuffins.com." Plain English. No commands to memorize. No DevOps degree required. Your AI already speaks our language.
Works with Claude Code, Cursor, and any agent that speaks MCP.
- 02
Your AI pushes the button.
Behind the curtain, we hand your agent the keys to a fortress: build the code, ship the container, point the domain, install the lock, stream the logs. You sit back. You watch a green checkmark appear. That is the entire move.
Soft-delete catches mistakes. Confirm tokens stop the scary ones. Spend caps mean your AI cannot bankrupt you.
- 03
The whole internet sees your app.
A real .com address. A real green padlock. A real website you can send to clients, share with family, or list on your business card. The internet does not care that an AI built it. It just works. And you are now, officially, a builder.
Bring your own domain or use a free fieldwick.com URL. TLS is automatic.
Under the hood
What is already taken care of.
A hard ceiling on your bill.
Set a monthly cap and the platform enforces it. With a cap in place your AI cannot run up the bill past the ceiling you choose, no matter how excited it gets.
Seven-day undo.
Anything deleted - by you or your AI - sits in a recovery vault for a week. One click brings it back. No support ticket required.
Dangerous moves need a code.
Deleting a site, dropping a database, releasing a domain - each one needs a one-time confirmation code. Your AI cannot slip and erase your work.
Bills written in English.
Your statement reads like a sentence, not a tax form. Hand it to your accountant or your spouse and they will know exactly what you paid for.
Support answered by a person.
Email goes to an engineer on the team, not a chatbot or a ticket queue. Most replies arrive the same day.
Built and run in America.
Small US-based team, on your time zone. When something needs attention, a human fixes it - usually before you notice.
For the builder
Your AI gets the entire dashboard, scoped and audited.
Twenty-seven tools through our MCP server. Eleven commands through the CLI. Every action your agent takes lands in an audit log you can read, sort, and export. Your AI has full hands on the wheel; you have full eyes on the road. That is the trade we built this whole platform to honor.
Hit the API right now
Two real endpoint shapes - the same JSON your dashboard, CLI, and agent read. Click to fire a request and see the response.
Fixture mode: responses are canned but match the shape of the real api.
# click an endpoint to fire a request
Dashboard
The AI-safety rails, visible on every page.
Not hidden behind "enterprise only" checkboxes. Every team gets the same scoped api, the same confirm-token guard, the same spend cap gauge, the same audit log. Agents and humans use identical surfaces.
- Cap
- $100 / month
- Action at cap
- throttle
- This month
- $82.00
Deploys refuse with HTTP 402 when projected spend would push you past the cap. Agents call get_billing_status before deploying + see the same headroom + can negotiate a cap raise via set_spend_cap rather than silently failing.
Soft-delete is reversible for 7 days via the Restore button. After that, the sweeper removes the record + sealed env vars permanently.
Every destructive op - delete, drop, remove - requires a token from the dashboard OR an explicit CLI flag. Humans in the loop by default; agents can suggest, not execute.
- service.deployactor: cursor · 2m agoRUNNING
- service.env_setactor: you · 12m ago
- confirm_token.consumedactor: you · 1h ago
- billing.invoice_paidactor: system · 2d ago
Every mutation writes a row: human via dashboard, human via CLI, agent via api token, system via webhook. Same table, same queryable surface.
Shown: real dashboard components rendered inline. The live build serves at app.fieldwick.com for hosted access, plus the same operations are reachable via fieldwick CLI and the MCP server (request_confirm_token + delete_service mirror the dialog flow shown above).
See it running
Demo recording in progress. Here is what the video will walk through, beat by beat.
- 1
Self-serve a brand-new app from scratch via MCP
Tell Claude "deploy my Node app at api.example.com". It walks list_teams -> create_project -> create_service -> set_env_vars -> deploy_service -> attach_domain -> get_domain (poll until tlsStatus=active). 27 tools across 14 read + 13 write cover the entire team -> project -> service -> deploy -> domain hierarchy.
- 2
Spend-aware deploys + cap negotiation
Before deploy_service, Claude calls get_billing_status and gets back a structured headroom assessment (used%, remaining, recommendation graduated at 70/90 thresholds). At 90% of cap it surfaces the risk to you and offers to bump the cap via set_spend_cap rather than silently failing the next deploy at the gate.
- 3
Confirm-token-gated destructive ops, observable in the chat
Service delete REQUIRES a fresh confirm token. The agent calls request_confirm_token THEN delete_service - either step alone fails. The two-step pattern is observable in the conversation transcript so you SEE the safety mechanism in action, not just hear about it. No dashboard hand-off needed; the safety is enforced at the protocol layer.
- 4
CLI + MCP + dashboard parity
Anything Claude does via MCP, you can do from your terminal: `fieldwick deploy` (autodetects serviceId inside a project directory) triggers the same builder + scheduler chain; `fieldwick billing status my-team` gets the same headroom decoration; `fieldwick scale --replicas 5` mirrors scale_service. The full `fieldwick` CLI, 27 MCP tools, one audit log, one auth model. Inside a project directory you never copy-paste ids - signup -> services create -> deploy is a 3-command zero-paste flow.
- 5
Recovery via soft-delete + restore
Accidentally `fieldwick service delete my-api`? It is soft + 7-day recoverable. `fieldwick restore my-api` (or restore_service via MCP) flips status back to stopped; one deploy brings it online. Domains are HARD delete on purpose (uniqueness rules); the tools warn about that distinction in their descriptions so the agent does not mis-promise restoration.
Pricing
Fair pricing. No surprise bills. Ever.
You set the monthly ceiling when you sign up. We throttle the moment you hit it. Your AI cannot run up the bill - the platform enforces the cap, not a polite warning. Every tier ships with every safety net turned on.
Starter
Kick the tires. Build something. We will not ask for a card. We will not chase you for a dollar.
- One live app. One region.
- Soft-delete safety net (seven days, free)
- Spend ceiling locked at zero - we throttle, never bill
- Community help from real builders
Builder
For the builder shipping with AI. Everything turned on. Your AI does the work, your card stays calm.
- Ship as many apps as you want, across every region
- Your AI gets the keys - twenty-seven MCP tools + eleven CLI commands, scoped + audit-logged
- Every safety net on: confirm tokens, soft-delete, agent-aware spend caps, full audit log
- Thirty days of logs - look back on what your AI did last week
- You set the monthly ceiling. We throttle there. Period.
- Real support from the product team - reply within a day
Team
For the shop putting AI in production. Locked-down defaults, full audit trail.
- Everything in Builder
- Multiple seats with proper role permissions
- Export the full audit log as CSV
- Priority support from the product team - reply within four hours
You pay only for what you use, on top of your tier's included credit. Every meter and every dollar shows up in plain English on your dashboard. Detail-shoppers can find the per-unit numbers inside; the rest of us already know the answer is fair.