Appearance
Driving it from an agent
jtakeit is built to be driven from here: the agent is the expected author of a site, and the MCP server is how it reaches the platform from the session it is already building in — judge the schema, attach the repository, build it, read why the build failed, hand the client a link — without opening the admin. Nobody is meant to hand-write the schema, the pages or the content; the platform's job is to run what the agent wrote.
The server is hosted and answers nothing without a token, and a token is only ever given when a person signed in to their account — a studio's, or a business's own — approves the connection.
What the agent needs
A terminal and git beside the chat: Claude Code, Cursor, Codex CLI, or any client that can run npx @jtakeit/astro create, write files and push a repository. A site here is a repository the agent writes; its code reaches the platform with push_code, or — for a site whose code is on GitHub — with git and our GitHub App, which a person installs. An agent in a browser tab alone — the Claude app with this server connected — has no terminal: it reads and writes the site's code on jtakeit with read_files and write_files instead, a few files a call (Connecting a site).
Connecting
Two lines, and nothing is copied. The first writes the server down; the second is the one that opens a browser, on the panel's own page, where you approve it:
claude mcp add --transport http jtakeit https://mcp.jtakeit.com/mcp
claude mcp login jtakeitInside a running Claude Code session, /mcp does what the second line does. Any client that speaks MCP works the same way — give it the address and it finds the rest; where the approval is started differs by client, and is usually a button beside the server. Most configuration files take this shape:
jsonc
{
"mcpServers": {
"jtakeit": { "type": "http", "url": "https://mcp.jtakeit.com/mcp" }
}
}The first call comes back 401 with a WWW-Authenticate header naming a discovery document; the client reads it, registers itself, and when it is told to authenticate opens a browser, where you approve on a page that says what is asking and where the answer goes. That is the whole of it — there is no key on any screen, because there is no endpoint that issues one to a person.
Somebody with an account approves. The consent screen is in the admin and needs the session you already sign in with: a studio's member, or a business that signed up for its own site («My business has a site, or wants one») — its agent works in that business's own account. Signing up in the middle of it is fine: the authorization waits thirty minutes, and the sign-in email carries a six-digit code to type on the same page, for a phone whose mail app opens links in another browser.
From claude.ai, the Claude apps, or ChatGPT
- Claude (claude.ai, the desktop app and the phone apps share connectors): Settings → Connectors → Add custom connector, name
jtakeit, addresshttps://mcp.jtakeit.com/mcp, then Connect and approve. The panel's first screen for a business does this in one click. - ChatGPT: until jtakeit is in ChatGPT's directory, only on the web and on the Business, Enterprise and Edu plans (Pro can read, not write) — Plugins,
+, Add custom MCP server, the address under Connection, OAuth, Create as a plugin, approve; in a chat,@jtakeit.
What you end up holding
An access token that works in the account you approved it for — your studio's, or your business's own — and belongs to you, the person who approved it: when you leave a studio, your agents stop with you, and a machine that has to outlive its installer is not what this is for — and a refresh token that renews it. The access token lasts an hour; the refresh token is rotated on every use, which means presenting a used one is a copy in somebody's hands and disconnects the agent on the spot. Your client does all of that without being asked.
Settings → Agents lists what is connected, when each was last used, and has a revoke beside each one. Revoking takes effect on the next call.
The tools
The reference has each one with its parameters. Grouped by what you are doing:
| writing a schema | validate_schema, get_registry |
| setting a site up | list_sites, get_site, create_site, attach_repo |
| building | trigger_build, get_build, get_build_log |
| shipping | commit_and_build — serving an earlier build is a person's, in the panel |
| showing somebody | get_preview_link |
| checking what is there | get_content, list_entries, import_branch |
| stocking a shop | set_stock |
| before a handover | preflight |
| working on this machine | open_dev_session, send_dev_schema, get_dev_files, close_dev_session |
Three of them take a second look before they act: commit_and_build with dry_run says what it would add, rewrite and delete (changed when any of the three names a file; unpublished when the draft holds what the published version does not; pending when the branch holds content the panel has not taken — a push over unsaved changes — which the save brings in under the draft first); trigger_build with kind: "candidate" builds into the preview and not in front of visitors; and preflight sends a real enquiry only when asked (send_real_enquiry), walks the booking chain only when asked (self_check) — on rows the business never sees, told to nobody — and places a test order only when asked (try_order): on Stripe's sandbox, under your session, so the business never sees it, and given back by Stripe's own message before it answers. With VAT on, the parcel goes to the business's own address, and the test payment is taxed on the sandbox as a live one would be.
set_stock sets the starting stock of SKUs that have not sold, one a line (FOX-S-RED 3). Once a SKU has sold, its stock is the owner's, in the panel (Shop → Stock): the tool leaves it as it is and names it. Nor can a push move the SKU itself: one an order named stays its variant's, and the save, import_branch and validate_schema refuse a draft that changes it or gives it to another variant (JTK_E_SKU_ORDERED). A variant that is not to be sold is taken off sale (on_sale: false); one removed, like a product deleted, keeps its SKUs from every other variant.
jtk import products writes the stock of a catalogue it brings in to .jtakeit/stock.txt (and stock-2.txt beyond 5,000 lines), one SKU and its count a line, for this tool: send the text of each file as stock with the site's id, and set it before anybody looks at the site, since a counted product is sold out until its stock is set (the shop on the site). get_site says what a stranger's shop page sent that the platform does not read, in shop_drops — each name, where it was sent, how many times this month — as booking_drops does for the booking page: fix the page, and try the checkout on the preview with preflight's try_order before anybody else uses it.
What it will not do
An agent builds the machine. It does not read what the machine collected.
Enquiries, the diary, the orders and the members are the client's own customers and the people who can reach them. A credential living in a config file does not carry them; open the panel as yourself.
It does not write content. No field writes, no page writes, no block writes. Editing belongs to the client in the admin and to you in the repository, and a tool that patched a field would be a third way of changing a site that nothing else knows about.
What it does instead is the other direction. Write the content in the repository where it belongs — versioned, diffable, reviewed with the code — and then import_branch so the panel and the branch agree. Do that before the next save or publish, or the draft is copied outward and writes over the commit.
It cannot launch a site on its own domain, and it cannot hand anybody a way into a site. Both are decisions about people, and nothing in a config file makes those.
It has no studio verbs. Suspending, promoting, archiving, the money, and everything about how clients are found are not here and will not be. They are all in the panel, and the panel, by hand says which screen, which person, and what has to be true first — so when somebody asks how to launch a site, hand it over, or bill a client, the answer is where, not no.
It cannot connect another agent. A credential that can make its own successor cannot be revoked: the one you kill has already made the next.
A session that works
Judge, attach, build, look, show:
validate_schemawith the schemanpx @jtakeit/astro schemajust wrote,jtk/schema.json— as text, with thejtk/files (the translations among them) and the site insite_id, or once it is pushed, by site and ref, and nothing is pasted. Both forms hold the tree to the site as its import does (a new currency isJTK_E_CURRENCY_SET); where the code is on jtakeit,push_code's push is the import, so judge the text before it. Fix everything it says: it returns all findings at once, so this is one pass.- The code, as
get_site'scode_sayshas it:push_codeand thejtk pushit answers with, or — for a GitHub remote, our App installed by a person —attach_repoonce the repository is pushed. commit_and_build, thenget_builduntil it settles. It commits the draft as a version and builds it, and says which files the commit changed (files); nothing goes public, and on a launched site the build is a candidate a person publishes. While the panel holds a person's unsaved changes it is refused (JTK_E_THEIR_DRAFT, naming them): ask them, thenwith_their_draft, orbranch_onlyto build your commits and leave their draft.trigger_buildis for rebuilding after that.get_build_logif it did not. Failures carryJTK_E_codes; look them up in the error reference rather than reading the prose.import_branchif you committed content or changed the schema on a GitHub repository, so the panel shows what the branch says (apush_codepush imports by itself). You will be told if you forget: a publish whose draft has not seen the branch's content is refused withJTK_E_OUT_OF_SYNCrather than overwriting it. The order is enforced, not remembered.get_preview_linkand give the person the URL, withlabelsaying whom it is for. It works for seven days (days, up to thirty), shows the preview and a test booking and nothing else, and never hands the site over — the owner's link does that, from the panel. The studio sees it in the panel's links and can reset it. Give it from the start — a person in a chat has no localhost. Until something of yours is on the site — only the kit's example is,get_site'slook.shown_readyis false — and before the first build, it shows a screen saying their agent is writing the site, with a build's step while one runs. After that it shows the draft drawn live wherelook.draws_liveholds: what you write intojtk/is there at once, without a build, and a build is needed only when code changed (src/, styles, components, packages). Kept open, it follows the draft and each build by itself. After the first build,get_site'spanel.linksare the panel's screens this site has, to give the person once.preflightbefore you tell anybody it is done. It says what a person would otherwise check by hand: a build is served, enquiries, bookings and orders have somewhere to go and the diary can take a booking, the address answers, nothing tells search engines to stay away, and the form delivers; withtry_order, that a shop takes an order and gives it back. On a site that takes bookings, run it withself_check: true: the server walks a booking through the whole chain on the build published now — booked as a visitor, confirmed, refused, moved, another time offered and accepted, «it suits», moved and cancelled by the customer, cancelled by the owner — and reads every letter of it, on rows nobody sees or is told of. Fix what a step names, publish, run it again; the site is notreadyuntil the walk has passed on the build published now. It does not check the form's script (try_bookingdoes), a letter's delivery, or the payment (JTK_W_PAYMENT_UNCHECKED: tell the owner) — the brief.
Working on the template on this machine is a different loop — open_dev_session, then send_dev_schema whenever the schema changes, get_dev_files to commit what was typed, close_dev_session when done — and working locally has it in full.
On a site in several languages, get_site says per language what is still to translate and what is outdated, document by document, with the file each translation is in. You translate in those files and push them like any content; no tool translates for you, and the machine translation the panel will offer the owner is not yours to call (a site in several languages).
Every result carries the contract number, so a transcript is still diagnosable after the format moves.