Claude Studio: one workspace for every project at once.

The key is paid for, the agent works, everything is fine. Except that you get less done in a week than you planned, and it is not clear where the week went — you do not remember asking for anything unnecessary. Claude Code has mechanics underneath that decide this directly: how many times the agent goes to the model for one question of yours, how big a context it drags along each time, whether the cache under it is still warm or has gone cold. The mechanics are public; nobody hides them. There is simply nowhere to see them mid-work, and by the time the week ends, the decisions that ate it were made days ago.

Claude Studio shows those mechanics — and, more to the point, takes them off you.

The idea is simple: a token should go into the work you ordered, not into re-sending a session that has gone cold. You no longer have to do the arithmetic in your head — the environment decides for itself whether to continue the current session or start a new one, and says out loud what each would cost. All else equal the key stretches over noticeably more work, and that is not the saving of a cheaper answer: it is simply that you stop paying for something you never knew about.

The panel itself is a browser window over a real coding agent running on your own machine. Not a cloud service and not another chat: the same engine as the editor plugin, the same subscription, the same computer, the same project folders. The difference is that the agent finally has a room around it.

One environment instead of three

This is the main thing, and most of the rest follows from it.

Normally, work with an agent is smeared across several places. The agent lives in its own app or in a terminal. The code is in the editor. Feel like checking from your phone how it all ended — now you need remote access as well, and you had to arrange that in advance: flag the session, turn something on, forward something. Half the state is always in a window you are not looking at, and the phone shows one session in ten at best.

Claude Studio is one address. The panel stays online for as long as the machine running the agent is on. Open it from the work laptop — every task is there. Open it from a phone in a queue — the same tasks, live, in the same state, including the ones running right now. Open it from somebody else’s computer you can log in from — them again.

Nothing has to be prepared for that. There is no “make this session remote” checkbox, no separate mode, no second interface “for mobile”. Any task is reachable from anywhere at any moment, because it lived on the server from the start and the browser only draws it.

One more thing follows from the agent running locally: it has your whole disk. It reads and edits real files, runs the tests, reaches the database through your own MCP servers, picks up your CLAUDE.md, your skills and your hooks — the same ones as in the editor. A cloud sandbox can do none of that, and, placed between the agent and the project, takes half the point away from it.

Servers wake up when they are needed

“One environment instead of three” has a very concrete price, and it is usually paid without looking. Every connected MCP server is a set of tool descriptions, and they travel in the system prompt of every request: not the one where the tool was needed — every one. Thirteen servers is about forty-two thousand tokens you pay at the start of any conversation, on a day you touched none of them.

Hence the habit of keeping one environment per job: one window with the database, another with the browser engine, a third one kept clean so as not to pay for the first two. Each with its own tabs, its own history and its own feeling that something somewhere is being finished without you.

Here you do not need that: the schemas load on demand.

The tool exists, the agent knows it exists — but its description reaches the context at the moment the agent actually decides to use it. The measured price of forty-two thousand tokens of schemas in the window is zero. So you can keep connected everything that might conceivably be useful, and pay nothing for it until the first call.

The practical consequence is exactly one, and it is about your head rather than your tokens: one working window for everything. Not “minimise three and open a fourth”, but one page holding every project and every task, in which nothing is left unread in the background.

Projects and tasks instead of chats

A message feed works as an interface right up to the second project. After that it becomes a heap of identical-looking sessions, and finding the one where you fixed the invoice import a week ago costs six openings.

Down the left of the panel runs a rail: projects, sub-projects inside them, tasks inside those. A task is not a session. It is a unit of work that lives for weeks: “invoice OCR gets multi-page PDFs wrong”. The panel changes the sessions underneath it by itself, when the old one stops being worth its price, and not one of them gets a line in the list. A task outlives its sessions roughly the way a folder outlives files.

You name the task. Half a second of work, and it settles two things at once: in a list of fifteen rows the right one is found by eye rather than by trial — and it can be called by voice with your hands full. “Open Approval chain” works; “open the session from Tuesday” does not.

Eight projects, a dozen or two tasks in each. That used to be a person’s week smeared over three editor windows and memory. Here it is one screen showing at a glance what is finished, what is waiting on you, and where something is happening right now.

That is the shift. The editor helped you handle files inside one project — an honest job, while files were written by hand. They are not written by hand now, and what has to be handled is projects: not “where is that function” but “which of the eight is waiting on my decision”. The scarce resource stopped being the machine or the time. It is your attention, and attention is what has to be allocated.

Hence a small thing that saves hours: the rows do not lie. A green tick does not appear while subagents the task launched are still running. It used to — and that was a lie that cost the trust in the whole list.

When the agent asks

Work regularly hits a fork the agent should not settle on your behalf: trim the trailing space in supplier codes on import — or keep the value as it is and compare on TRIM. It stops and asks. This is where the time used to go: a ! beacon lit up in the list, and what was actually wanted of you sat at the end of the last turn, so to read it you had to open the task and scroll.

The beacon goes out because you answered, not because you looked at the row. The difference sounds small and turns out to be the whole point: until you answer, the task keeps asking, and it cannot be accidentally “read” and forgotten.

You can see it working

A turn unfolds in the feed as it happens: the reasoning types out live, every tool call lands as a card of its own — what it read, what it found, what it changed, what it ran and how that ended.

The point is not the spectacle. When you can see the agent going into the wrong file at the twentieth second, you stop it at the twentieth second rather than the twentieth minute — and the earliest intervention is always the cheapest. While a turn runs the send button becomes an interrupt button; the session survives that and remembers everything it got through.

Warm cache, cold cache — and why it is no longer your problem

Now for those mechanics. Worth understanding once, so as never to think about them again.

While the prompt cache is warm, the whole accumulated context is re-sent at a tenth of the price. It lives for one hour from the last request. Once that hour is up the same context travels in full and at full price — and the same message in a session gone cold costs roughly twenty times what it costs in a fresh one with a short brief. Hence a rule you learn once: the price of a turn = number of calls × size of the window. Neither the length of your message nor the difficulty of the question matters much; what matters is how many times the agent goes to the model, and how much text it carries each time.

Holding that in your head mid-work is impossible, and pointless. So the panel does three things for you:

• Predicts the size of the next turn — from your message and the task’s history. A short question and “go through the whole folder” cost differently before either of them starts.
• Says the verdict out loud, right above the input box: “continuing this session, the cache has 47 minutes left, this turn rides the cache — about A$0.11, cheaper than starting clean (≈ A$0.94)”. Or the other way round, when the other way round is cheaper.
• Carries the meaning across, not the letters. When the session does change, what travels into the new one is a compressed digest of the task, not the whole transcript. The task continues from the same place; the window does not.

None of this asks anything of you. The line above the input box is not a question but a report of what the environment has already decided; you can argue with it, and most of the time there is simply no need.

This arithmetic broke on us once and cost real money: the context counter was fed a turn’s spend instead of the window’s size, and the panel tore the session almost every turn. It has had a test of its own ever since — one that fails when the number drawn disagrees with the number measured.

A receipt under every answer

The same thing again, after the fact, in one line.

Two things matter. First: the price stands next to the decision, not in an invoice a month later. “Was that worth it” gets asked at the moment it can still be answered with an action.

Second: a subscription is not money, it is a share of a weekly window. The panel knows the live rate — what one per cent of this week actually costs us — and converts the percentages into currency itself. The rate is not a constant; it drifts with the models you have been working in.

The model per turn, not for life

The panel does not keep a list of models in its own code: it asks the same CLI that will do the counting afterwards. So a new model appears in the menu on the day it ships, and nothing has to be updated for that. Each one lists exactly the effort levels it actually accepts — not a common list, half of which returns an error.

The difference between them is not percentages but multiples, which is why the choice sits under the input box rather than in general settings: it is settled afresh every time. Working out somebody else’s architecture and renaming forty files from a ready list are jobs for different models, and there is no reason to pay for the second at the price of the first.

One window, as many columns as you like

Since attention is the scarce thing, the panel is built not to make you switch back and forth. The workspace is columns and floors inside one browser window: drag a task into the next column and watch two live feeds at once, or stack two tasks in one column.

A subtlety that surfaces after a fortnight: columns are needed less often than you would think. One task in one window reads better — whole, top to bottom, not cut across half a screen. And the other eight do not need watching with your eyes at all: that is what the rail is for, and every row on it says whether it is running, finished, or waiting on your decision.

That used to be the real chore — keeping several environments open and walking the circuit, checking whether anything had finished. Now there is nothing to check: the beacon in the rail changes by itself, and columns open when two things genuinely have to be seen side by side.

Each lane holds a long-lived session of its own, so one lane’s cache does not disturb another’s. A message sent into a busy lane queues and goes as soon as that lane frees up — rather than being lost, which is still the most annoying way there is to lose a thought.

By voice — and accurately

The microphone sits next to the send button in every window, on the computer and on the phone. It is not a separate “voice mode” but a second way to type, and on a long brief it is about three times faster than a keyboard.

By default the recognising is done by a local engine on the same machine — fast and free. But sometimes accuracy matters more than anything, and then your own key goes into the settings (an OpenAI one, for instance) and dictation runs through that. The difference shows exactly where a local model usually gives up: several languages in one sentence, proper nouns, file names, an interface you are building in somebody else’s language and dictating its strings verbatim. The key is yours and lives in your own key cupboard — no door in the panel hands its value back.

It works the other way too: an answer can be read aloud, by the same local engine, with the cloud as the fallback.

And one more, of the you-do-not-value-it-until-you-lose-it kind: everything dictated is recorded. If the text went into the wrong task, the turn broke, or you simply changed your mind about sending — that dictation is in a list of its own and comes back whole.

Anything at all in the input box

A screenshot from the clipboard, a PDF, an export from the accounting system, a Word document with a procedure, a diagram, an archive of logs, a screen recording — all of it drags into the input box or pastes straight from the clipboard. There is no “text and pictures only” limit: the file goes beside the message, not instead of it.

The agent reads them — not “sees an attachment”, reads: parses the table, pulls the text out of a PDF and out of a .docx, looks at the picture. Usually that is faster than any explanation: a screenshot of broken layout, or a page of a report with the wrong total, states the task in a second where a paragraph of prose only confuses it.

Which is why a screen recording is not exotic here. Thirty seconds of video showing exactly how the form breaks are worth a page of description — and, unlike a page of description, they can be watched again.

And back the other way: reports, not retellings

In the other direction the feed also shows rather than retells: a picture the agent made or found is drawn right there in the answer, and an HTML report, a PDF or a log opens with one tap without leaving the panel. Finished reports stack on a shelf inside the project, so something made last week does not have to be hunted by path through old messages.

Search across everything ever said

After a month of work the main question is no longer “how do I do this” but “where have we done this already”. Search runs across every conversation in every project at once: your messages, the agent’s answers, task names — on a fragment of a word, without the exact phrasing.

It finds what is no longer in the archive, too. Transcripts of old sessions get tidied away over time and the journal remembers longer — so something said six months ago comes back, and so does the task you once dictated in the car and have not opened since.

Bookkeeping nobody else has

Small receipts add up into reports — and this is the only way we know of answering “what did that feature cost us”.

“Sixty-one per cent of the week” is not an answer, it is a reason to worry. So the key has a screen of its own, and it answers five different questions, of which exactly one matters on a Thursday: will the remainder last until Monday.

And the last question of the same bookkeeping, the most uncomfortable one: what, in fact, came out of the money.

A separate screen answers a question that usually goes unasked, because there is nowhere to ask it: what is the context you pay for on every single request actually made of?

The MCP inspector lives there too. Every connected server puts its tool schemas into the system prompt of every request — the panel shows what each one costs in tokens and lets you clear the checkbox. The next session simply will not carry it.

And the machine itself

The key is not the only thing that runs out. The agent works on a real computer, and that computer sometimes gives out before the subscription does: the disk is full, the memory is eaten, every core is busy with something you started an hour ago and forgot. Finding out mid-turn, through a build that suddenly fails, is the normal way and a stupid one.

So three numbers sit right in the head of the project list: all-core load as a percentage, free memory, free disk. Not a separate screen and not charts — a line your eye trips over while looking for a task. When one of the three runs low the number goes yellow, then red.

The principle is the same as with money. A tool that reports somebody else’s spending in detail and stays quiet about its own has not earned any trust.

What it weighs

That is the second question people ask, right after “what is this thing”. An environment that lives on a machine around the clock owes that machine an account. The numbers below were not eyeballed: they are written by the same counter that draws the cards above, one probe a minute.

Read it like this. The panel itself costs almost nothing: forty-seven megabytes idle, eighty-five averaged over a day, seventy-three at the median. The weight comes not from it but from the engines that listen and speak on the same machine: speech recognition, synthesis and translation hold models in memory so as to answer in fractions of a second rather than in seconds. Their four hundred megabytes are the price of dictation never leaving the building.

The peaks look worse: at maximum the family held eight gigabytes. But that is not the panel. Those are agents and their MCP servers, raised for a particular turn: they appear when you ask for work and they leave with it. When no turn is running they are not there at all — and on the chart that memory shows up as exactly what it is, a line separate from the panel.

The last figure is the counter-intuitive one. Thirteen connected MCP servers weigh 41.7k tokens of tool descriptions, and for years that was taken as a tax on every request: the more servers connected, the dearer every turn. We measured it. In the window they come to zero. The current CLI defers the schemas: only the names travel in the prompt, and the full description loads when the model actually reaches for a tool. Skills work the same way — a name and one line, the body read when needed. The price of a spare server is not a tax but a slightly longer list to search.

This paragraph is precisely what the context breakdown exists for. Until the numbers are drawn, “switch off what you do not need” stays a superstition: half of what people habitually disable costs nothing, and what you pay for is the thing you never think about.

The cage

The panel is published on a domain of its own behind Cloudflare Access: from outside it is reachable by nobody but the owner, entry is a one-time code by email, and after that a signed token on every request, which the server checks itself and never takes a header’s word for.

Everything above means a process on your machine executing arbitrary code in your name. So half the work on the panel is refusals rather than features.

• The server listens on the loopback only. Exactly one tunnel connector reaches it from outside — nothing else does.
• A second person lives in a sandbox. Owner and colleague are separate roles: a colleague sees only the folders allowed to them, and somebody else’s row is neither signed nor drawn, even when asked for.
• One door outward. A guest of the panel is allowed exactly one outgoing action (send an email through our own CRM, with a limit and a notification to the owner). Publishing, deploying, git push — closed.
• Secrets never leave the process. Values from .env are read in the server’s memory; only key names travel to the browser, and the config editor hands values back masked. A test of its own runs a live turn with a canary in it and fails if the canary leaks anywhere.
• The agent does not restart its own house. The panel goes down for new code only when it has no turn left running, and it warns beforehand — with a “later” button.

Forty-odd automatic checks run this before every “done”: the queue, the restart, row separation, secret leakage, recovery after a crash, behaviour on a phone. Not because we love tests, but because each of them appeared after something broke quietly.

What else is inside

Briefly — the things that do not warrant a chapter but are felt in the work:

• Several subscriptions at once — each lane can have its own, with separate settings homes; one key’s limit no longer stops all the work.
• A turn diagram — agent lanes on a timeline, the orchestration graph, and a map of where the attention went, by file.
• A turn that trips over an API error is not lost: it parks and re-sends itself until it gets through.
• A crash is survivable. A process killed mid-turn comes back, sees the unclosed turn in the journal and carries on by itself.
• Ten themes with an automatic day / evening / night schedule, and the panel installs on a phone as an app.
• A Telegram bridge — a guest writes into the chat, the message becomes a task in the bound row, the answer goes back.
• The panel refreshes its own tab when that tab is free — and never mid-turn.
• A first run with a tour that hands control back the moment you touch anything.
• Its own hearing, its own voice and its own translator — speech recognition, synthesis and translation run on engines on this same machine; the cloud comes in only when they could not cope.
• The panel says when the connection is gone. Not a grey dot nobody notices, but a shade with the reason — and with what the panel is doing to come back.
• The panel picks itself up — a watchdog that depends on nothing inside it notices the silence and opens a repair session; the repair only counts once the panel has answered three times running that it is alive.
• GitHub sync per project, by a checkbox in the project menu and only where you put it.

The usual way — and this way

This is not an argument with the code editor: it is needed, it is not going anywhere, and the end of this article says so as well. On the left is what work with an agent built into a familiar development environment looks like. On the right is the same thing here. Almost nowhere is the difference about capability. It is about where the state lives.

Not one line on the right would be possible if the panel tried to be an editor. It does not try: the code is still written by hand where it was always written, both programs look into the same folder quite happily, and that is exactly what all this was for.

What Claude Studio is not

It is not a cloud service. Nothing is hosted, nothing is signed up for, your code goes nowhere. There is a price for that: you need a machine that stays on.

It is not an autopilot. The panel does not make the agent smarter — it makes it visible and countable. The decisions stay yours; you simply make them now knowing the price.

If it comes down to one thing, it is this. You stop watching the key, the spend and the tokens — the environment does that. And you start watching projects, of which one person can now have eight rather than one, because for the first time all of them are visible at once, and it is immediately clear which one is waiting for you.

We built this for ourselves, and it is the same work we do for clients: take a process nobody can watch by hand, put it on one screen, and stand the number next to the decision instead of in next month’s invoice. The other thing we built that way is open too — a dashboard over Xero and MYOB, ranked by the dollars at stake. If the systems you run do not talk to each other yet, that is the joining-up work; if what is scattered is knowledge rather than data, it is a corporate knowledge base. This site is our own case study too — how it was built and what it runs on.