Changelog

The Hub and public portfolios were always meant to be readable by anyone — the routes were mounted outside the auth guard correctly — but a layout inside them fetched the signed-in profile unconditionally and threw. A logged-out visitor got an error page, which is an unfortunate property for the pages whose entire job is being sent to people without accounts.

The app shell pins the viewport so the three-column workspace can own the screen and scroll each column independently. The standalone read-top-to-bottom routes inherited that pin, which meant they could not scroll at all on a small screen — so anything below the fold was simply unreachable.

Access is gated on the connected key, and on nothing else. Turns on those models cost zero Clusy credits — including the work you don't see, since verification, sub-agents and context compaction stay on your key rather than falling back to a house model.

This covers model inference, not compute: the sandbox your notebook runs in is still metered as before. More on how it works.

Several things that made long notebooks unpleasant:

• Each notebook now gets its own tab on the canvas, so a project with several notebooks stops being one long scroll.
• The virtualized cell list measures real row heights instead of guessing, which fixes the scrollbar drifting and cells jumping as you move through a large notebook.
• The focus effect no longer re-centres the viewport on every keystroke while you type in a cell.

Uploads used to be routed through the API, which capped how much you could add at once. They now go direct to storage over short-lived signed URLs, requested in bulk. A dataset of several thousand images uploads in a handful of authorized calls rather than one per file, and the folder structure you dragged in is the folder structure you get.

Pairing adds three rows to the picker, badged Your machine: Claude Code Sonnet, Claude Code Opus and Codex. Set it up from Settings → Integrations, which gives you a pairing code and two commands to run:

npm i -g https://api.clusy.io/local-runners/clusy-runner.tgz
clusy-runner pair <CODE>

pair installs a start-at-login background service (launchd on macOS, systemd on Linux) so the machine stays online; pass --no-service to run it yourself. It opens no inbound ports.

Your Anthropic or OpenAI login never leaves your machine — Clusy spawns the genuine CLI and it authenticates itself, in its own process. Your notebook still runs in the Clusy sandbox; only the reasoning moves to your laptop.

Limits worth knowing: one turn at a time per machine, the machine has to be awake, and Plan Mode, sub-agents and batch experiments aren't available on a local-runner turn (branching is). More on how it works.

Only the first 20 files a cell wrote were persisted, and the rest were dropped without saying so — which meant a labelling job that wrote one mask per frame quietly delivered a fraction of its output and looked like it had finished.

The cap is now 100, and if a cell overruns it the agent is told, rather than the files vanishing in silence. It is still a cap: a job that writes thousands of files should write an archive.

Several things were wrong at once: files written from a terminal or to scratch were never persisted, the download route could 500 on a file that wasn't where it was expected, and the UI happily offered you a download for an artifact that had never been uploaded.

Files produced by terminal and scratch runs are now persisted, downloads are gated on the file actually existing, and an upload that stalls fails loudly instead of sitting at 0%.

The agent used to be able to add cells and run them, which meant every correction became a new cell at the bottom and notebooks grew long and repetitive.

It can now restructure what is already there: convert a code cell to markdown, read a cell before editing it, reorder, insert in the middle, and remove a cell that is no longer earning its place.

The read-only share viewer rendered every code cell as a CodeMirror editor. CodeMirror virtualizes against the window, so in a long page it concluded most cells were offscreen and stopped painting them — leaving a reader scrolling through empty stretches.

Code in the share viewer is now plain rendered text, which is all a reader needed.

Every turn does setup before the model is called — loading session state, history, your preferences, credentials. That work ran as a chain of sequential awaits, so each round-trip's latency stacked on top of the last before a single token could be produced.

The setup now runs concurrently, and prompt caches are held for an hour so a follow-up message doesn't pay a cold prefill.

The chat panel now tracks whether your viewport is genuinely pinned to the bottom. If it is, it follows the stream; if you have scrolled up to re-read something, it leaves you where you are and offers a jump-to-bottom instead of yanking you back.

A training cell that produces no output for several minutes looked, to the layer in between, like a dead connection — so it was cut, and you got "connection dropped while streaming" on a cell that was working.

The execution stream and the kernel channel now both keep alive through silence.

The plan opens as its own tab on the canvas. You can revise it, drop a step, or discard it outright. Approving it releases the agent to build; until you do, it cannot write a cell or run one.

The gate is enforced in the tool executor rather than asked for in the prompt, so it holds even when the model would rather get on with it.

Errors were surfaced as a one-line ename: evalue, which cut off exactly the part that matters — a CUDA out-of-memory message, for instance, arrived truncated before the numbers telling you how much memory was actually needed.

The cell's error output now carries the full traceback, and the agent sees it too.

A page reload used to leave the client with no record of the in-flight turn: the reply stopped rendering, the composer thought nothing was running, and sending the next message superseded the turn that was still going.

Active runs are now rehydrated on load — the in-progress reply re-renders from what has streamed so far, and the composer knows to steer rather than supersede.

A provider failure ended the turn with a clean terminal frame rather than an error frame, so the chat rendered nothing at all — the turn simply appeared to stop mid-thought, and you had no way to tell a crash from a model that had decided to say nothing.

Previously, typing while the agent was mid-task superseded the whole turn — twenty minutes of work discarded because you wanted to add one sentence.

Now the message is picked up at the agent's next step. If it is in the middle of executing a cell, it finishes that cell and reads your message before deciding what to do next, so a correction lands without throwing away the work already done.

• Signing in on one Clusy subdomain signs you in across the others.
• Transactional email — verification codes, welcome mail — is live, with one-click unsubscribe on everything that isn't a security message.
• Deleting your account now cancels the subscription attached to it, instead of leaving a live Stripe subscription behind a deleted user.

If the agent kicked off a long execution, the chat could appear to die while the cells kept running — the reply watchdog timed the whole turn rather than the gap since the last streamed token, so a legitimately long run tripped it.

It now measures stream silence, and the long-running phases send heartbeats while they work.

A dropped kernel websocket would leave the project apparently alive but permanently unresponsive — cells queued and never ran, and the only way out was a reload. The gateway now detects the dead channel and reconnects it.

Auto stays the default and picks a model per turn. When you want to choose yourself, the picker now covers the full shelf, and the agent's own background calls — verification, sub-agents, compaction — route on the same entitlements as your foreground turns instead of falling back to a house default.

Which models you can reach depends on your plan. The pricing page has the current mapping.

Sharing gives you a short clusy.io/s/… link. The preview card is built from the notebook itself: its title, its author, its cell and experiment counts, and a cover lifted from the first real image output in the notebook.

Documentation is now public at docs.clusy.io — how branching works, how the sandbox works, how to pick a model, and how to get a first notebook running.

Cancelling before the model had produced any text or tool call could persist an empty assistant row in the history. On the next message, OpenAI-compatible providers rejected that row with a 400, and every subsequent turn in the session failed. The only fix was to abandon the session.

Empty interrupted turns are now dropped from history replay.

A published notebook keeps its cells, its outputs and its branches, and can be forked into a reader's own workspace in one click — so a result you share is a result someone else can run and change, not a screenshot of one.

The Hub is at clusy.io/hub, and inside the app under the Hub tab.

A plan describes work on the shared notebook, so it is no longer scoped to a single chat. Opening a plan shows its revision history, so you can read what changed between the version you approved and the version that ran.

• A crafted 404 page, rather than silently bouncing you to the homepage.
• security.txt published, so a researcher who finds something knows where to send it.
• Legal copy corrected to name the right entity (Clusy Inc.) with consistent governing law, and the privacy policy now identifies the data controller properly.

Attachments used to land in project storage only, so the agent would go looking on the filesystem for a file that was never on disk. They are now copied into the sandbox working directory (/home/user) before the turn starts, and notebook code can open them by plain relative filename.

Staging is best-effort — if a file can't be pre-staged the agent is told, and reads it from project storage instead. Up to 50 attachments per message.

The old first-run dropped you into an empty workspace and wished you luck. The new one walks from sign-up to a first executed cell: connect a data source inline (Kaggle, Hugging Face, an upload) without a detour through Settings, choose your theme, and land in a project that is already doing something.

A long turn used to produce a wall of individual tool rows and a dozen separate "Thinking…" blocks. Adjacent reasoning now folds into a single expandable block, and tool calls are grouped by category, so the transcript reads as a sequence of steps rather than a log file.

Both connect from Settings → Integrations with a personal access token. Once connected, the agent gets SQL query tools against that warehouse and can pull what it needs itself — so the data stays where it lives and you stop round-tripping extracts through your downloads folder.

Numeric columns now right-align in both header and cells and use tabular figures, so digits line up in columns and you can compare magnitudes down a column at a glance. NaN, None, NaT and <NA> render dimmed and italic.

Every cell that produced a plot was being auto-promoted into the Deliverables panel, which made it useless for its actual job — holding the handful of artifacts you want to take away.

Each pick becomes a chip on the message, and the agent resolves it into the artifact's current content — the cell's actual source, the plan's steps, the dataset entry — at send time, so it reflects the cell as it is now rather than as it was when you typed.

Limits: up to 20 references per message, and a referenced cell's body is truncated at 4,000 characters. Plans, datasets and papers only appear once the session has a plan.

We had built three different ways to look at the branch tree. Between them they added a lot of code and no clarity, and the telemetry said nobody was reaching for any of them.

They are gone. Branches are switched from the branch bar above the notebook.

Plotly charts had no font family set, and the iframe that renders rich output shipped a Latin-only font stack — so any agent-produced chart with CJK labels came back as rows of tofu boxes.

A project started from the launcher used to keep your raw first message as its name, truncated mid-sentence. It is now renamed from a short summary of that first turn, and notebooks left on a default label are named from what they contain once they have run.