Local Studio 3.0

Local Studio 3.0

Local Studio 3.0 is a new app. The custom interface we built through 2.x is replaced by T3 Code, the open-source agent harness from Theo Browne, Julius Marminge and the T3 Tools team. On top of it, Local Studio adds what it has always been about: your own models, on your own machines.

Credit where it's due. Almost everything you see — the thread UI, the composer, the terminal, source control, remote access, the mobile app — is T3 Code's work, used under the MIT License. Local Studio is a deliberately thin fork that tracks upstream closely. If you like it, star pingdotgg/t3code.

Download: localstudio.ai/download · macOS Apple silicon · macOS Intel · Windows · Linux x64 · Linux arm64. All files, including the .deb packages and controller binaries, are listed under Assets below.

Watch the one-minute tour: Local-Studio-3.0-launch.mp4 (vertical)

---

Why we rebuilt on T3 Code

2.x grew a lot of UI over a year: chat panes, agent dashboards, a custom session model, a Next.js frontend, an Electron shell, and a controller with dozens of modules. It worked, but every feature cost us twice: once to build and again to keep fast and correct. Long agent sessions were where it hurt most. Ordering of reasoning and tool calls, reconnects, streaming and long-thread performance each needed their own fixes, again and again.

T3 Code had already solved the hard parts of an agent UI, and solved them well:

• Fast in long threads. On a 209-message, 282k-token session, the thread opens with about 90 ms of main-thread work. A follow-up turn shows your message in about 20 ms and streams without dropped frames.
• Every major agent. Codex, Claude Code, Cursor, Grok, OpenCode and Antigravity work out of the box.
• Remote-ready. One server drives desktop, web and phone, with pairing, Tailscale and a published mobile app.
• Maintained in the open by people who use it every day.

So we stopped competing with that and contributed the part we're good at. Local Studio 3.0 is T3 Code plus local AI, kept under a strict 4,000-line budget of our own code, so that upstream improvements reach you quickly.

What's new

Pi and Oh My Pi as first-class providers

Pi and Oh My Pi now sit in the model picker next to Codex and Claude, and run on whatever models you've configured for them, local or remote.

• Streaming text and reasoning, with tool calls (shell, edits, MCP) shown as they happen
• Interrupt, steering, and native compaction
• Conversation rollback for both Pi and Oh My Pi
• Effective model and thinking level, read back from the CLI, so the UI always shows what is actually running
• Token usage and context-window tracking from each session's own stats
• Import existing Pi and Oh My Pi sessions during onboarding, so your history comes with you
• No approval prompts interrupting long autonomous runs
• Oh My Pi's large model catalogs (hundreds of models) now load reliably, using its chunked RPC protocol

A local controller, bundled

The desktop app ships with the Local Studio controller and starts it for you.

• It discovers every OpenAI-compatible server on the machine: vLLM, SGLang, llama.cpp, LM Studio, anything serving /v1/models.
• It exposes all of them through one gateway: /v1/chat/completions, /v1/completions, /v1/messages (Anthropic) and /v1/responses. Streams and errors pass through natively.
• The model id auto routes to the busiest live model across your machines.
• It launches pinned recipes from the local-ai-registry on free NVIDIA GPUs, without evicting what's already running.

Your whole fleet, over Tailscale

Settings → Local shows every machine you've connected, with GPUs, memory, live models, launchable recipes and usage. Machines on your tailnet are found automatically:

• Connect links a machine that already runs a controller.
• Install sets up the controller on a Linux or macOS machine that doesn't have one. It installs over ssh as a background service (systemd or launchd), binds to the machine's Tailscale address, shares your fleet key, and links it. It takes seconds and never overwrites an existing controller.

A model loaded on any of your machines is then usable from every machine, and from any agent.

On your phone

Local Studio is a T3 Code server, so the T3 Code mobile app (iOS, Android) and mobile browsers can pair with it from Settings → Connections. Start a turn on your desk and follow or continue it from your phone, over your LAN or Tailscale.

Every platform

Platform	Download
macOS, Apple silicon	Local-Studio-mac-arm64.dmg, signed and notarized
macOS, Intel	Local-Studio-mac-x64.dmg, signed and notarized
Windows x64	Local-Studio-win-x64.exe
Linux x64 / arm64	AppImage and .deb
Controller only	Standalone binaries for Linux, macOS and Windows

Verify any file against this release's SHA256SUMS (shasum -a 256 <file>).

How 3.0 was tested

3.0 combines two pieces of work: the T3 migration (#471) and the release work (#472).

• Real CLIs. Pi 0.86.1 and Oh My Pi 18.4.8/18.4.10 were tested with streaming, tools, steering, interruption, resume, model and thinking switching, title generation, rollback (fork and branch), token stats, and real turns through the desktop UI.
• A real fleet. Controllers ran side by side on seven machines (a Mac, a 4× RTX PRO 6000 workstation, an Omarchy box and four DGX Sparks), next to existing engines without disturbing them.
• Real launches. A registry recipe was launched on a GPU, then put through readiness checks, restart reconciliation and stop. Streaming tool calls passed through a remote controller into SGLang over Chat Completions, Completions, Messages and Responses.
• Federation. End-to-end process tests cover federation cycles, cancellation forwarding, credential isolation, multi-endpoint routing, and usage that is counted once.
• Registry. It has 276 catalog recipes. On top of those, a backup of 326 captured configurations is pinned, including every recipe on the reference workstation.
• Tailnet install. A real install on a Linux x86_64 host took 4.6 s and produced a systemd user service with linger enabled. A host that already had a controller was refused and left untouched.
• Performance. On a 209-message, 282k-token thread, the production build opens the thread with about 90 ms of main-thread work. Follow-up turns stream with no long tasks.
• Packaging. CI checks that macOS builds are signed and notarized. Each desktop package carries its platform's controller, which starts with the app and stops when it quits.

Upgrading from 2.x

• 3.x is a new app with a new data folder. Your 2.x data is left untouched.
• Installing 3.0 on macOS replaces /Applications/Local Studio.app.
• 2.x doesn't auto-update to 3.0. 2.16.0 installs keep working and see "no update" until you install 3.0 yourself.
• Pi and Oh My Pi sessions can be imported during onboarding. Other agents (Codex, Claude Code and so on) use their own CLI logins.
• If you ran the 2.x controller on a GPU box, it can keep running. The 3.x controller listens on port 18091 and can sit beside it.

Known issues

• Read-only recipes. Archived captures and host-specific, privileged or multi-machine recipes stay read-only, and the UI shows why. Missing weights or scripts are reported, never invented.

• Cancellation. It is forwarded to the engine, but engines that ignore client disconnects (the tested SGLang build, for one) may keep generating.

• What auto measures. auto ranks the successful requests these controllers have seen, not an engine's earlier traffic.

• Pi and Oh My Pi gaps. They have no T3 MCP tool injection yet. Image attachments and interactive input dialogs are less tested than text turns.

• T3 cloud services. T3-hosted features such as T3 Connect stay off unless you configure them. Direct pairing over your LAN or Tailscale always works.

• Phones. Phone use was tested in iPhone browser emulation and on a real iPhone's browser over LAN. The native T3 Code app hasn't been through full acceptance against Local Studio yet.

• Windows installers aren't code-signed yet, so SmartScreen asks for confirmation (More info → Run anyway).

• Linux arm64 builds are new; please report anything odd on DGX Spark, Jetson or other arm64 machines.

• Install from Settings → Local needs key-based ssh access to the target machine, and supports Linux and macOS only.

• The mobile app is upstream T3 Code's. Pi and Oh My Pi threads may show there with a generic provider icon.

Help us test

This is the biggest change Local Studio has ever had. Tracking issue: #473. Bug reports, platform reports and PRs are all welcome.

Thanks

To Theo, Julius and every contributor to T3 Code, for building something worth building on. To the Pi and Oh My Pi authors. And to everyone who ran 2.x on strange hardware and told us what broke.

Full changelog: v2.16.0...v3.0.0