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 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.

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.

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 v3 (the agent metric)

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

Voice & dubbing

TTS quality: open voice models (community Elo, May 2026)

Transcription

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

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

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

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

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

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.

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.'"

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.