Local AI

AI that runs on your machine.

Open-weight models finally do real agent work — tool calls, multi-step plans, MCP. Arg0 points your agents at Ollama, LM Studio, or Apple's on-device models: same runtime, same workflows, zero per-token cost.

The landscape

Local AI grew up.

A year ago "local model" meant a chatbot that hallucinated tool syntax. The ecosystem changed on four fronts:

Tool calling went standard

Open-weight models are now trained for function calling, not just chat — Qwen3's native template, Hermes' <tool_call> tags, gpt-oss's OpenAI-format calls. Benchmarks like BFCL, TAU2-Bench and MCP-Atlas now rank models on agentic tool use.

Laptop-class is good enough

Mixture-of-experts architectures (Qwen3-A3B, gpt-oss-20b at ~3.6B active params) plus 4-bit GGUF quantization put serious reasoning inside 8–16 GB of memory — unified-memory Macs included.

A real ecosystem of models

Qwen3, Nous Hermes 4.x, Llama, gpt-oss, GLM-4.7-Flash, Gemma, Ministral, Granite — most under Apache-2.0 or MIT licences, downloadable and redistributable.

Alignment you choose

Hermes-style models are trained for neutral alignment and steerability — your system prompt wins. Pick the model whose behaviour fits the job, not the vendor's default.

Worth pulling first

qwen3

Safe default — native tool template + optional thinking, 0.6B to 235B

hermes3 / Hermes 4.x

Nous' steerable, neutrally-aligned agent line — hermes3 via Ollama, 4.x GGUFs via LM Studio or vLLM

gpt-oss-20b

OpenAI's open weights — function calling + structured outputs

llama3.1:8b

The most-pulled tool-capable model — the reference implementation

GLM-4.7-Flash

MIT-licensed MoE — strong τ²-Bench score at ~3B active params

In Arg0

Three ways in.

Local models are first-class providers — not a workaround. Agents, tasks, and workflows don't know or care where the model runs.

Ollama

Detected automatically once installed. Arg0 reads the `tools` capability tag, so tool-capable models — qwen3, llama3.1, hermes3, gpt-oss — just work as agents.

LM Studio / llama.cpp / vLLM

Any OpenAI-compatible endpoint connects in Settings → AI Preferences — including GGUFs like Hermes 4.3 that you download straight from Hugging Face.

Apple Intelligence

On-device Foundation Models on macOS, exposed inside Arg0 as a native agent runtime with real tool calls — no install at all.

Hermes models work too. Nous ships its own Hermes Agent app, but the models themselves are open weights — pull hermes3 in Ollama or load a Hermes 4.x GGUF through LM Studio or vLLM, and it shows up in Arg0 as a first-class agent model with tool calls and MCP access like any other.

Where it shows up

Local everywhere you assign work.

Every place Arg0 takes a model, it takes a local one — the UI doesn't change, only where the inference happens.

Settings → AI Providers

Managed AI

Arg0 credits — works out of the box

cloud

Ollama

localhost:11434 — 3 models found

detected

LM Studio

localhost:1234 — OpenAI-compatible

connected

Apple Intelligence

on-device Foundation Models

built-in

Your API keys

OpenAI · Anthropic · Gemini · DeepSeek

cloud

AI Providers — local servers sit next to Managed AI and BYOK as equals.

Agent — note-tidy

PROVIDER

Ollamalocal

MODEL

hermes3⌄

MCP TOOLS

filesystemshellsearch

Per agent — provider, model, and MCP tools are picked independently for each agent.

notes.tasks.md

Summarize this week's notes

agent: @qwen3 · mcp: filesystem

Publish the changelog draft

agent: @claude · cloud

Per task — a agent: line in .tasks.md routes one card to a local model and the next to the cloud.

Why local

Your hardware is the API.

Private by default

Prompts, files, and run logs stay on your machine. Nothing is sent to a provider — there is no provider.

No per-token cost

Local models don't consume Arg0 credits or a provider subscription. Run agents all day for free.

Works offline

No network, no problem. Agents keep working on a plane, in a train, or behind a firewall.

Same agents, same workflows

Local models plug into the same agent runtime, MCP tools, and .workflow.md automations as cloud models.

1

Install a runner

Grab Ollama or LM Studio — or use Apple Intelligence, which ships inside the desktop app.

2

Pick it in Settings

Arg0 detects local servers automatically. Choose the provider and model per agent.

3

Assign work

Chat, dispatch tasks from .tasks.md, or wire it into a workflow — exactly like a cloud model.

terminalfully local

# pull an agent-capable open model

$ ollama pull qwen3

$ ollama pull hermes3 # Nous' steerable agent line

# both appear in Arg0's provider list

$ # agent: @qwen3 in a .tasks.md card

# the whole run stays on this machine

✓ 14 steps · 3 tool calls · 0 tokens billed

Cloud when you want it. Local when you don't.

Managed AI, your own API keys, or a model on your desk — switch providers per agent, per task, per workflow.