One agent. Every model. Zero cloud.

Two years ago, running a frontier-class model on your own machine was a fantasy. That changed faster than almost anyone predicted. The reason this guide exists now, and could not have existed in 2024, is a single chart: the gap between open models you can download and the closed models you rent has nearly closed.

The Mac's advantage is not raw speed; a data-center GPU beats it on throughput. The advantage is one large pool of fast memory shared by the whole chip, which lets a laptop hold models that simply will not fit on a consumer graphics card, while sipping power and staying silent.

How the M5 Max stacks up against everything else with 128 GB

For an agent that decodes hundreds of tool calls per session, memory bandwidth beats raw compute, because decode is bandwidth-bound. The Mac wins this race against its closest peers despite Blackwell's FP4 hardware advantage.

A raw model only emits text. Something has to turn "dub this clip into English in my voice" into a real sequence of actions that ends in a file on disk. That something is the agent. Hermes Agent, from Nous Research, is the conductor that holds the baton.

The anatomy

The 70+ built-in tools

Tools tagged cloud need a key by default and get swapped for local equivalents in section 07; everything else is local.

How it thinks

Three mechanisms keep long jobs alive: todo (it tracks its own steps), compression (summarizes history to stay under the context limit), and delegation (offloads sub-tasks to subagents so the main thread stays clean). They are why a local agent can run a multi-stage media pipeline end to end without losing the plot.

What a single agent turn actually looks like

One real exchange. The user says "summarise the README in this repo and write a tweet about it"; the agent runs four tool calls and answers in about eight seconds on gpt-oss-120B.

# user prompt
> summarise the README in this repo and write a tweet about it

# agent turn 1: pick a tool, emit a tool call
tool: search_files(query="^README", path=".")
# runtime executes, result feeds back to context
result: ["./README.md", "./packages/foo/README.md"]

# agent turn 2: narrow to the root README
tool: read_file(path="./README.md")
result: 3,847 chars of markdown

# agent turn 3: internal reasoning, no tool call
The README describes a 2026 field guide for local AI on M5 Max with
Hermes Agent. Headline claim: 27B model at 77.2% SWE-Verified fits a
laptop. The thread should lead with that stat.

# agent turn 4: emit the answer (no tool call, free-form text to user)
A 27-billion-parameter model that fits a laptop now codes at 77.2% on
SWE-bench Verified. Local AI is no longer a compromise: 2026 field
guide for a private studio on a MacBook M5 Max with Hermes Agent.
https://m5ai.ivanm.dev

Note what does NOT happen: the agent does not narrate every step to the user, does not stop to ask permission for read-only tools (those are pre-approved), does not write chain-of-thought into the answer. The visible behaviour is "thought for 8 seconds, then answered". The invisible behaviour is the loop above. Hermes's /compress ensures the result of turn 2 (3,847 chars of README) is summarised before turn 5 if the conversation keeps going.

What the community actually reports

Independent of any vendor claim, community discussion across r/LocalLLaMA and Hacker News has been active and growing, praising the smoother setup and the built-in learning loop. A representative comment: the agent "actually remembers" a failure and "creates a skill for troubleshooting it." The honest consensus is not that Hermes replaces dedicated coding agents; for pure software engineering, the leaders are clear: Claude Code with Opus 4.6 holds 80.8% on SWE-bench Verified (highest reported single-agent), Aider's Polyglot leaderboard places Opus 4.6 around 85% edit-format, and Cursor Composer with Sonnet 4.6 sits in the mid-70s. Hermes does not publish a SWE-bench Verified number and is built for a wider job: orchestration, memory, scheduling and gateways. Treat marketing comparisons sceptically; benchmark for your actual workload. Nous shipped hundreds of security-tagged commits across the 0.12-0.14 release cycles (588 / 633 / 550 total merged PRs respectively) and there are no widely reported breaches; the lone disclosed CVE-2026-7396 (WeChat path traversal) was patched. Hermes positions itself as complementary to the older OpenClaw framework, with a built-in hermes claw migrate path that imports persona, skills, memory, channels and API keys.

A skill is just a folder with a Markdown file

Skills are the procedural memory: short, named, version-controlled how-to documents the agent reads and follows. Here is a real one from ~/.hermes/skills/release-it/SKILL.md, hand-written then refined by Curator after a few runs:

---
name: release-it
description: tag + push a release after CI green
tools: [terminal, file]
approvals: [git tag, git push]
---

# When to use
User asks to "ship", "tag a release", or "cut v<N>".

# Pre-flight
1. Run `gh run list --branch main --limit 1`; verify status=success.
2. Read `CHANGELOG.md`; the top entry must have a version + date filled in.
3. Run `npm run validate`; must exit 0.

# Steps
1. `git tag -a v{N} -m "<extract from CHANGELOG>"`
2. `git push --tags`
3. Confirm to user with the new tag URL on GitHub.

# Failure modes
- CI red → STOP, tell user, do not tag.
- CHANGELOG unfilled → ask user to fill before continuing.
- Same tag exists → STOP, do not force-push.

The agent reads this on session start (only the skills relevant to the current goal land in the system prompt). Skills are shareable: hermes skill push my-skill publishes to agentskills.io; hermes skill install <name> imports someone else's. The Curator agent deduplicates and consolidates skills nightly; over weeks the studio's skill set converges on the patterns YOU repeat.

A multi-modal turn: text + image + voice in one prompt

The same agent loop drives every modality because the brain dispatches to tool servers, not to one model. A request that spans copy, design and audio is just three tool calls with the brain stitching the result back together. Worked example for "draft a launch poster + caption + read the caption in my cloned voice":

// USER
> draft a launch poster for the studio (1080x1350, IG portrait),
  write a 28-word caption, and read the caption in my cloned voice
  from ~/voices/me-15s.wav. Drop everything in ~/Desktop/launch/.

// TURN 1 · brain plans
need: brand colours, headline, body. Skill brand-kit has it.
read_file: ~/.hermes/skills/brand-kit/SKILL.md  (158 chars)
  → primary #4d8dff · accent #2ee6a6 · font Bricolage 800

// TURN 2 · brain drafts copy in-context, then calls image tool
gen_image:
  prompt:  "minimal portrait poster, deep navy gradient,
            headline 'One agent. Every model. Zero cloud.'
            in Bricolage 800 white, accent dot mint,
            grain texture, generous margins"
  model:   flux-2-dev
  size:    1080x1350
  steps:   28
  → ~/Desktop/launch/poster.png (1.2 MB, 14.6 s)

// TURN 3 · brain writes caption, then calls voice tools
write_file: ~/Desktop/launch/caption.txt
  → "One MacBook. One agent. Every open model.
        No subscription, no telemetry, no cloud round-trip.
        Sixty-three GB of brain on a laptop you can close."  (28 words)

clone_voice:
  reference: ~/voices/me-15s.wav
  model:     chatterbox-v2
  → voice profile cached as 'me' (3.1 s)

tts_speak:
  text:          <caption.txt>
  voice:         me
  exaggeration:  0.35
  format:        wav 24kHz
  → ~/Desktop/launch/caption.wav (412 KB, 2.9 s)

// TURN 4 · brain emits final answer
> Done. Poster at poster.png, caption.txt (28 words),
  caption.wav (12 s, your voice, mild emotion).
  Total: 22.7 s, 4 tool calls, 0 cloud calls.

What this shows: one brain (gpt-oss-120B) chooses tools, drafts copy, and never touches the image or voice models directly. The image model lives behind a gen_image tool, the voice clone behind two more. Swap FLUX for Qwen-Image and the brain does not need re-prompting. Swap Chatterbox for F5-TTS and the same. The skill folder is where this convention lives; the brain follows.

Sleeper features in 0.13 and 0.14

Six things from the last two release cycles that materially change what the studio can do:

OpenClaw, Claw Code, ClaudeClaw: three different projects

Names collide. The migration path Hermes ships is for one of them only.

What happens if Hermes itself gets abandoned

The fair question to ask before committing to any agent runtime: what is recoverable if the project dies tomorrow? The studio's architecture answers this on purpose. Everything you produce lives in formats older than Hermes and outlasts any single tool.

The brain is the model the agent reasons with. For an agent, the trait that matters most is not raw genius: it is reliably choosing the right tool and emitting a clean call, hundreds of times in a row. A model that is 2% smarter but fumbles one call ends the run. So this section covers how these models work, what makes each one different, how they are trained, and exactly how the 2026 field scores, before picking the ones that fit your Mac.

How a modern model works

What makes each architecture different

The whole field, scored and sized

Intelligence Index = Artificial Analysis v4.0 composite. SWE = SWE-bench Verified. "128GB" = fits on this Mac at a usable 4-bit quant. Top models are listed precisely because most of them do not fit, which is the honest part.

Intelligence Index · top open weights (higher is better)

SWE-bench Verified · coding (open weights)

Tool calling · BFCL v4 (the agent metric)

MMLU-Pro · reasoning breadth (open weights, 2026-05-25)

GPQA Diamond · graduate-level science (open weights)

GDPval-AA · real-world agentic value (Elo, open weights, 2026-05-25)

τ-bench retail · multi-turn customer-service agents (closed-vs-open reference)

The models that fit your Mac, in detail

gpt-oss-120B · the reliability brain

OpenAI's open model. It is the most dependable at "using tools" of anything you can download, which is the single trait that decides whether long agent jobs finish. It fits comfortably and lets you dial how hard it thinks.

Qwen3.6-27B · the all-rounder

Alibaba's open model and the best balance for this build: fast, small enough to leave room for media, and genuinely excellent at coding and agentic work. If you run one model, this is the safe pick.

Nemotron 3 Super: the open hybrid

NVIDIA's contender. Different inside: it mixes three kinds of layers (long-context Mamba, attention, and the MoE experts you already know). Holds 91.75% on a million-token retrieval test, which no other open model touches.

Qwen3-Coder-Next: the small fast coder

Alibaba's specialised coding model. Three billion active parameters, scores 70.6% on the coding test. The best self-hostable coder under 100 GB.

The cloud-only leaders, briefly

These do not fit your Mac, but you should know what sits at the top of the open leaderboard:

The 2026 tooling

Lane × server × quant: picking quickly

Each lane in the studio wants a different pairing. This collapses the decisions into one table.

Reasoning-format settings, per model

Hybrid-thinking models need explicit configuration or they emit chain-of-thought that breaks downstream parsers. Copy-paste:

# gpt-oss-120B (Harmony format, native reasoning effort)
model: ollama/gpt-oss:120b
extra_body:
  reasoning_effort: high   # low | medium | high

# Qwen3.6 family (hybrid thinking; disable all three knobs)
model: ollama/qwen3.6:27b
extra_body:
  reasoning: off
  reasoning_budget: 0
  chat_template_kwargs:
    enable_thinking: false

# GLM-4.7 / 5.1 : same triple flag as Qwen3.6
# DeepSeek V4 : same triple flag

# Llama 4 Scout : pythonic tool-call parser required
model: ollama/llama4:scout
extra_body:
  tool_call_format: pythonic

# Gemma 4 31B : watch for repetition loops past ~11 tool calls. Reset session on detection.

Citation: llama.cpp issue #13189 documents the full triple-flag fix.

This is where local AI stopped being a compromise. The brain writes and reasons; these models produce the media. Each is a different machine with its own architecture, its own training, and its own leaderboard. Below: how each kind works, the full field of options with arena scores, the apps that run them on Mac, and how to prompt them.

Images

Text-to-image arena · open weights (Elo)

Video

Music

Worked ACE-Step prompt: a 47-second balkan-folk demo

Anatomy of one actual prompt that produces a clean output on the first try. Total wall-clock on M5 Max: ~18 seconds.

# Tags (3-7 words; specific instruments + bpm beat adjectives)
tags: balkan folk, accordion, violin, minor key, 92 bpm, male vocal, live feel

# Structure (markers shape sectioning + dynamics)
lyrics: |
  [verse]
  Sutra zora pada na grad,
  jutarnji povjetarac nosi pjesmu.
  Korak po korak kroz tihu ulicu,
  vrijeme za pjevanje bez razloga.

  [chorus]
  Pjevaj sa mnom, pjevaj glasno,
  pjesma stara, srce mlado.
  Pjevaj sa mnom, pjevaj glasno,
  do jutra, do jutra, do jutra.

  [instrumental]

  [verse]
  Akordeon pamti svaku ulicu,
  violina zna svaku stazu.
  Korak po korak kroz tihu jutro,
  pjesma za one koji slušaju.

  [chorus]
  Pjevaj sa mnom, pjevaj glasno,
  pjesma stara, srce mlado.

# Render
duration: 47
guidance: 7.5
seed: 1492

Why it works: the tag block names three instruments and pins bpm + key + vocal register before any adjective; the lyric block stays under 140 words (124 words across two verses + chorus repeat + instrumental break) so ACE-Step does not have to truncate mid-phrase; the [instrumental] marker gives the diffusion transformer a clean breath where it can foreground the accordion solo. The seed makes the output reproducible; drop the seed to re-roll the take.

Lyric structure templates that survive a first take

ACE-Step is fault-tolerant on tags but unforgiving on length math. Two rules carry most of the load: total lyric words must fit duration × 2.6 words/sec, and each section needs enough time for the diffusion transformer to lock its motif. Templates below are battle-tested at 90-110 BPM; scale lyric counts proportionally for slower or faster.

Why this matters: ACE-Step's diffusion transformer plans the entire timeline at the start. Overshooting the word budget by 20% causes the model to truncate mid-phrase or speed the vocal beyond intelligibility. Undershooting by 30% leaves the singer trailing off into instrumental sections that were not in your prompt. The templates above hit the sweet spot for one-take outputs in the 90-110 BPM band.

Voice & dubbing

TTS quality · TTS-Arena Elo (2026-05-25)

All seven stages on-device. M5 Max time budget: about 3-5 minutes of processing per minute of source video. Alternate lip-sync: MuseTalk 1.5 (Tencent Music) for higher fidelity on close-up faces.

Transcription

ASR word-error rate: open models on English (HF Open ASR Leaderboard, 2026-05-25)

ASR WER · per source language (open models, lower is better)

Hermes ships four tools that phone the cloud by default. To make the studio truly air-gappable, each one is repointed at a local engine. After this, the machine can run with Wi-Fi off.

Training a text LoRA with MLX

# 1. quantize the base to 4-bit (QLoRA kicks in automatically)
mlx_lm.convert --hf-path Qwen/Qwen3.6-27B -q --q-bits 4
# 2. train the adapter on your JSONL data
mlx_lm.lora --model ./mlx_model --train --data ./data \
  --lora-layers 16 --batch-size 2 --iters 600
# 3. fuse the adapter back into a standalone model (optional)
mlx_lm.fuse --model ./mlx_model --adapter-path ./adapters

Image-LoRA training: tool chooser

Four tools dominate FLUX / SDXL / Qwen-Image LoRA training in 2026. Pick by base model and ergonomics.

The pieces only become a studio when one mind coordinates them. Hermes does this with five mechanisms, all configurable.

# route the heavy thinking and the uncensored writing separately
model: ollama/gpt-oss:120b          # orchestrator brain
delegation:
  model: ollama/qwen3.6-abliterated:agent   # subagent / content writer
custom_providers:
  - name: local-media
    base_url: http://localhost:8080/v1   # MLX-Audio / image gateway

Swap the brain in 30 seconds when the leaderboard moves

The whole point of treating the brain as a swappable component: the day a better open-weights model lands, you switch without re-architecting. Concrete recipe, valid for any Ollama-served model:

# 1. Pull the new brain (one-time cost; cached afterwards)
ollama pull deepseek-v4-flash:35b-a3b-q5          # ~24 GB

# 2. Hot-swap by editing one line in ~/.hermes/config.yaml
sed -i '' 's|ollama/gpt-oss:120b|ollama/deepseek-v4-flash:35b-a3b-q5|' ~/.hermes/config.yaml

# 3. Restart the agent; skills, memory, channels all carry over
hermes restart

# 4. Sanity check
hermes 'Confirm which model you are running, then list the first 3 tools available.'

What carries over: every skill in ~/.hermes/skills/, every memory entry, every channel binding (Telegram / Discord / Slack), every API key, every cron job, every MCP server registration. Nothing else needs to change because nothing else depends on the model identity. The brain is one row in one YAML file.

Every model class wants a different prompt style. Old "masterpiece, trending on artstation" spam hurts modern models. Here are the patterns that work.

Prompt patterns by model class

Per-brain prompting: what each Mac-fit model wants

The four orchestrator brains do not respond to the same system-prompt shape. Tune per model.

These are not hypotheticals; each is a chain of the tools and models already covered, expressed as a Hermes skill or cron job.

Real workflows

Music-video pipeline · script to render

End-to-end music-video generation, all on-device. M5 Max budget: about 5-8 minutes total for a 30-second video.

Podcast pipeline · script to mastered episode

Multi-speaker podcast from a script, all voice-cloned, with intro music, lower-thirds music beds and outro. M5 Max budget: real-time + a few minutes mastering for a 30-minute episode.

Roughly 120 GB is usable for models after raising the wired limit. These are real, simultaneous loadouts. The pattern is always: keep one brain resident, spin heavy media up on demand.

What fits my Mac? Interactive

Slide to your RAM budget. The model field table above and the budget bars above re-colour: green if it fits, amber if tight, red if you would need to evict the brain to run it.

What it would cost to rent the equivalent

The studio is a capital cost (one Mac, once). Subscriptions are operating cost (monthly, forever). The honest comparison is what a comparable workflow runs through paid APIs and consumer-tier subscriptions, at moderate use: a working day of agent calls, ~40 images, ~10 song demos, ~30 minutes of voice clones, ~3 hours of transcription. Prices are list, May 2026; multi-tier discounts ignored.

1. Free the memory. Raise the GPU wired limit so models can use about 120 GB.
   

   sudo sysctl iogpu.wired_limit_mb=122880

2. Install the serving layer. Ollama for the brain (GGUF), and MLX/LM Studio for media and fine-tuning.
3. Pull the models.
   

   ollama pull gpt-oss:120b
   ollama pull qwen3.6:27b
   # raise context so the 70+-tool prompt fits
   export OLLAMA_CONTEXT_LENGTH=65536

4. Install Hermes. Pick one:
   

   # Recommended on macOS
   brew install hermes-agent
   
   # Or via PyPI (clean Python environments)
   pip install hermes-agent
   
   # Or via the official install script
   curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
   
   # Or on Windows
   iex (irm https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1)

5. Point it at local. Edit config.yaml (the orchestration block in section 10): brain, delegation model, custom providers for media.
6. Verify. Run hermes doctor, then ask it to write a file, generate an image, and transcribe a clip. If all three land, the studio is live.
7. Configure reasoning-format per model. Hybrid-thinking models need three knobs disabled to keep tool-call output clean. The cheat sheet is in section 6. Skip this and watch agents emit raw chain-of-thought into your terminal output.
8. Enable hermes proxy if you have any of Claude Pro, ChatGPT Pro or SuperGrok. The subscription becomes a localhost OpenAI-compatible endpoint that Codex CLI, Aider, Cline and Continue can all drive. Material cost-saving for multi-tool users.

#!/usr/bin/env bash
set -euo pipefail

# 1. Free the memory
sudo sysctl iogpu.wired_limit_mb=122880

# 2. Install serving layer
brew install ollama
brew install --cask lm-studio
pip install mlx mlx-lm mlx-audio

# 3. Pull models
ollama pull gpt-oss:120b
ollama pull qwen3.6:27b
export OLLAMA_CONTEXT_LENGTH=65536

# 4. Install Hermes
brew install hermes-agent

# 5. Initial config
mkdir -p ~/.hermes
cat > ~/.hermes/config.yaml <<'YAML'
model: ollama/gpt-oss:120b
delegation:
  model: ollama/qwen3.6:27b
custom_providers:
  - name: local-media
    base_url: http://localhost:8080/v1
YAML

# 6. Verify
hermes doctor
echo "Studio is live. Try: hermes 'write hello.txt then summarize it.'"

Reproduce the numbers in this guide

Every tok/s, prefill speedup, image-gen wall clock and ASR WER in this guide can be re-measured on your own Mac in under 10 minutes. If a number drifts more than ~15% from the ranges below, the most likely cause is missing macOS Tahoe 26.4+, an unraised wired limit, or a competing memory hog (Chrome, Docker Desktop). Probe in this order.

1 · LLM decode throughput (tok/s)

# Ollama: built-in eval-rate report
ollama run gpt-oss:120b --verbose "Write a 200-word essay about the M5 Max."
# → look for: eval_count, eval_duration, eval_rate (tokens/s)

# MLX equivalent (more granular, separates prefill from decode)
mlx_lm.generate --model mlx-community/Qwen3.6-27B-Instruct-4bit \
                --prompt "Explain unified memory in two paragraphs." \
                --max-tokens 256 --verbose

Expected on M5 Max 128 GB · macOS Tahoe 26.4+ · cold start, no other GPU load:

2 · Prefill speedup vs M4 Max (sanity check)

# Long-context prefill measurement: 8k-token prompt
mlx_lm.generate --model mlx-community/Qwen3.6-27B-Instruct-4bit \
                --prompt-cache-file /tmp/none \
                --prompt "$(yes 'context line ' | head -1000 | tr -d '\n')" \
                --max-tokens 1 --verbose
# → look for: prompt-eval rate. Compare against M4 Max ~85 tok/s.
#     M5 Max should land ~280-360 tok/s on the same prompt (3.3-4.0x).

3 · Image generation wall clock (FLUX.2 + Draw Things)

# FLUX.2 dev · 28 steps · 1024x1024 · MLX-Diffusion
time python -m mlx_diffusion.generate \
       --model black-forest-labs/FLUX.2-dev-mlx-4bit \
       --prompt "a still life of a brass accordion, dramatic light" \
       --steps 28 --size 1024

# Draw Things Lightning Draft (UI app, but timeable)
# Generate at 512x512, 4 steps, Lightning Draft schedule.
# Expected wall clock ~1.0-1.4 s per image.

4 · Transcription speed (real-time factor)

# 60-second clip; RTF = wall_clock / audio_duration. Lower is better.
time mlx_whisper --model mlx-community/whisper-large-v3-mlx \
                  --language en sample-60s.wav
# → expected wall clock ~3.8-5.2 s → RTF ~0.06-0.09

time faster-whisper-cli --model large-v3 --device mps sample-60s.wav
# → expected wall clock ~5.2-7.8 s → RTF ~0.09-0.13

5 · Music generation (ACE-Step)

time python -m ace_step.generate \
       --tags "balkan folk, accordion, violin, minor key, 92 bpm, male vocal" \
       --lyrics-file /tmp/lyrics.txt \
       --duration 47 --guidance 7.5 --seed 1492
# → expected wall clock ~16-22 s for 47-second output

6 · Putting it all together: the 5-minute smoke test

#!/usr/bin/env bash
# Save as bench-studio.sh; run after install completes.
set -euo pipefail
echo "== sysctl wired limit =="
sysctl iogpu.wired_limit_mb

echo "== macOS build =="
sw_vers -productVersion

echo "== brain decode =="
ollama run gpt-oss:120b --verbose "Count to 50." 2>&1 | grep eval_rate

echo "== prefill =="
mlx_lm.generate --model mlx-community/Qwen3.6-27B-Instruct-4bit \
                --prompt "$(yes 'x ' | head -500 | tr -d '\n')" \
                --max-tokens 1 --verbose 2>&1 | grep -E "prompt|generation"

echo "== whisper =="
time mlx_whisper --model mlx-community/whisper-large-v3-mlx sample-60s.wav

An agent that can run shell commands and an uncensored model that never refuses are powerful and need guardrails. Hermes ships them; keep them on.

• Dangerous-command blocking + approvals: destructive patterns (rm -rf, DROP TABLE) are blocked or require explicit confirmation.
• Secret-exfiltration scanning: the runtime flags attempts to leak keys or credentials, important when an abliterated model will follow any instruction it reads.
• MCP hardening: OAuth 2.1 PKCE for connectors plus OSV scanning of MCP servers for known-malicious packages.
• Air-gap checklist: local brain ✓, local media ✓, web_search off or local SearXNG ✓, no telemetry ✓. Then the network cable is optional.

Seven sandbox backends

Hermes ships more sandbox options than any competitor. Pick by trust level + cost.

Step back and look at the arc. A year ago, the best open model scored 22 and a private studio like this was science fiction. Today the gap to the frontier is single digits, a 27-billion-parameter model that fits a laptop codes like last year's best, and music, voice and images that rivalled paid services now run offline in seconds. The line on that chart is still climbing.

What you have built here is not a cheaper ChatGPT. It is a different relationship with the technology. The models are yours: they do not change under you overnight, they do not log your work, they do not disappear when a subscription lapses or a company pivots. The agent learns your patterns and keeps them. The voice clone, the LoRA of your style, the skills it wrote solving your bugs, none of it leaves the machine. In a market built on renting access to someone else's servers, owning the whole stack outright is the genuinely radical option.

It is not the strongest possible system. The trillion-parameter leaders still live in data centers, local video still trails, and the leaderboard you read today will be wrong next month. But the trajectory is unmistakable: every quarter, more of the frontier becomes something you can hold in 128 GB. The right move is not to wait for the perfect model. It is to build the studio now, learn how the pieces fit, and let it improve underneath you as the open field keeps closing the gap, which it will.

One agent. Every model. Zero cloud. Run it once, and the cloud starts to look like a choice rather than a requirement. That is the whole point, and it is already here.

How this page itself was built

Worth saying plainly: this guide describing the local AI studio was written using the studio it describes. Not as a stunt, as a stress test. If the architecture cannot ship a 220 KB single-page field guide with zero em-dashes, six JSON-LD blocks, working CSS scroll animations and an OG card that renders on Twitter, then it cannot ship anything more demanding. Here is the actual build stack, end to end: