AgentZero Lite — Bringing Multi-CLI and On-Device LLM to Windows (Part 1, EN)

A minimalist IDE for the AI era — manage multiple CLI agents in one window, mixing a smart big model with a lightweight on-device LLM in the same place.

1. Why another terminal — the rise of CLIs

flowchart LR
  classDef plat fill:#1e293b,stroke:#06b6d4,color:#e2e8f0
  classDef new fill:#312e81,stroke:#a855f7,color:#e9d5ff
  classDef gap fill:#7f1d1d,stroke:#ef4444,color:#fecaca

  subgraph mac["macOS / Linux"]
    direction TB
    A1["tmux"]:::plat
    A2["cmux"]:::new
    A3["amux"]:::new
    A4["agent-of-empires"]:::new
  end

  subgraph win["Windows"]
    direction TB
    B1["Windows Terminal"]:::plat
    B2["wmux (new)"]:::new
    B3["?? gap ??"]:::gap
  end

  mac -.plenty of options.-> goal["Multi AI Agent<br>same screen"]
  win -.long empty seat.-> goal
  B3 ==> agentzero["AgentZero Lite"]:::new

2. AgentZero Lite — one-line summary

• Spin up N real ConPTY terminals (no pseudo-PTY mimicry).

• Group tabs by folder via workspaces — keep separate CLI sets per project.

• An AgentBot chat panel forwards text or keystrokes to the focused terminal.

• An on-device LLM (Gemma 4) inside that chat panel coordinates the terminal AIs.

• WASM sandbox plugins let users add their own features.

• Voice input runs offline via Whisper.net + Vulkan.

• Single executable, no dependency beyond .NET 10, ~60 MB build.

flowchart TB
  classDef tab fill:#0f172a,stroke:#06b6d4,color:#e2e8f0
  classDef bot fill:#312e81,stroke:#a855f7,color:#e9d5ff
  classDef ws fill:#1e293b,stroke:#f59e0b,color:#fde68a

  user(("👤 User"))
  subgraph win["AgentZero Lite (single .exe)"]
    direction TB
    subgraph tabs["Tabs (N ConPTY terminals)"]
      direction LR
      T1["Claude tab"]:::tab
      T2["Codex tab"]:::tab
      T3["pwsh tab"]:::tab
      T4["build-log"]:::tab
    end
    subgraph side["Sidebar"]
      direction TB
      W1["▸ monorepo"]:::ws
      W2["▸ blog"]:::ws
    end
    subgraph bottom["Bottom panel"]
      direction LR
      P1["AGENT BOT<br>(Chat / Key / AI)"]:::bot
      P2["NOTE"]:::tab
      P3["LOG"]:::tab
    end
  end
  user --> tabs
  user --> bottom
  side -.context.-> tabs
  P1 -.focused tab.-> tabs

3. AI ↔ AI conversation — the Lite edition's signature feature

Learn AgentZeroLite.ps1 help. Use terminal-list to see tabs and terminal-send <grp> <tab> "..." to talk to the AI in another tab.

sequenceDiagram
  autonumber
  actor U as 👤 User
  participant C as Claude tab (tab 0)
  participant IPC as AgentZero IPC<br>(WM_COPYDATA + MMF)
  participant X as Codex tab (tab 1)

  U->>C: "Greet Codex and propose REST design"
  C->>IPC: terminal-send 0 1 "Hi Codex, ..."
  IPC->>X: text auto-typed
  X->>X: composes reply
  X->>IPC: terminal-send 0 0 "Hi Claude, ..."
  IPC->>C: reply auto-typed
  Note over C,X: No cloud relay<br>local IPC only

4. ChatMode and AIMode — a small assistant orchestrating big models

• ChatMode (CHT/KEY) — an input broker that forwards your text or keystrokes straight to the active terminal. Not an AI.

• AIMode — flip with Shift+Tab and the same chat box becomes an on-device LLM coordinator.

flowchart LR
  classDef cht fill:#0f172a,stroke:#06b6d4,color:#e2e8f0
  classDef ai fill:#312e81,stroke:#a855f7,color:#e9d5ff
  user(("User"))

  subgraph cht1["ChatMode (input broker)"]
    direction LR
    I1["chat input"]:::cht --> O1["forward to<br>active terminal"]:::cht
  end

  subgraph aim["AIMode (LocalLLM coordinator)"]
    direction LR
    I2["chat input"]:::ai --> L["Gemma 4<br>(on-device)"]:::ai
    L --> R{"routing"}:::ai
    R -->|"heavy reasoning"| T1["Claude tab"]:::ai
    R -->|"quick summary"| T2["Codex tab"]:::ai
    R -->|"direct"| O2["reply to user"]:::ai
  end

  user --> I1
  user --> I2

1. Output constraint — GBNF grammar forces every output to be {"tool": "<name>", "args": { ... }} and nothing else, enforced at the sampler level.

2. Tool execution — six-tool surface: list_terminals, read_terminal, send_to_terminal, send_key, wait, done.

3. Inject results back into context — as the next user turn.

4. Repeat until the LLM emits done.

stateDiagram-v2
  [*] --> Idle
  Idle --> Thinking: StartReactor(text)
  Thinking --> Generating: prompt prefill
  Generating --> Acting: tool_call JSON
  Acting --> Generating: tool_result injected
  Acting --> Done: done called
  Done --> Idle: one cycle complete
  Idle --> Idle: peer signal or<br>next user input

Who do you delegate the PM role to? That's AgentZero Lite's real question. It can be the smart cloud model. It can be the small on-device model directly. Letting the user actually have that choice is the point.

5. Voice — dual multitasking with hands and mouth at once

sequenceDiagram
  autonumber
  actor U as 👤 User
  participant K as Keyboard
  participant M as Microphone
  participant T0 as Tab 0 (Claude)
  participant T1 as Tab 1 (Codex)

  par keyboard channel
    U->>K: writing code
    K->>T0: "refactor this function"
    T0-->>U: diff response
  and voice channel
    U->>M: "summarize today's PRs"
    M->>T1: Whisper transcribe → auto-typed
    T1-->>U: voice reply (P3)
  end
  Note over T0,T1: two AI dialogs run in parallel<br>one human supervises both

• Whisper.net offline STT, GGML small (~466 MB) / medium (~1.5 GB) cached locally. Korean-strong turbo variants can be plugged in separately.

• CPU + Vulkan dual bundle — the Vulkan backend is cross-vendor: AMD, Intel, NVIDIA all run on the same binary. No CUDA lock-in.

• Even on multi-GPU laptops, Auto picks the dGPU correctly; if it picks wrong, manual override is one click.

• TTS output is in progress — Windows SAPI / OpenAI tts-1 plumbing is in, but the response-streaming pipeline is staged.

6. WASM plugins — bring your own feature

flowchart LR
  classDef host fill:#1e293b,stroke:#06b6d4,color:#e2e8f0
  classDef sand fill:#312e81,stroke:#a855f7,color:#e9d5ff
  classDef cap fill:#064e3b,stroke:#10b981,color:#a7f3d0

  subgraph host["AgentZero host"]
    direction TB
    LLM["LocalLLM API"]:::cap
    Term["Terminal Actor API"]:::cap
    Note["NOTE Panel API"]:::cap
  end

  subgraph sandbox["WASM sandbox"]
    direction TB
    Plug["Voice Note plugin<br>(manifest + html + js)"]:::sand
  end

  Plug -.explicit grant.-> LLM
  Plug -.explicit grant.-> Term
  Plug -.explicit grant.-> Note
  Plug -.no default access.-> X1[("✗ filesystem")]
  Plug -.no default access.-> X2[("✗ network")]

• Pull on-device AI capabilities that AgentZeroCLI exposes — call LocalLLM from inside a plugin.

• The first official plugin is Voice Note — STT-driven voice journaling, VAD-gated capture, sensitivity slider, pause/resume, LLM summary.

• A new plugin needs only manifest.json + index.html + *.js/*.css. Install in one click via Install Plugin Picker under the AgentBot [+] menu.

"Users build the features they need themselves" is more natural in the LLM era. AI got good at writing code, so the cost of making one plugin is collapsing.

7. Harness view — the framework grows alongside

harness/
├── agents/        — expert evaluators (security-guard, code-coach, test-sentinel, tamer)
├── engine/        — workflows (release-build-pipeline, pre-commit-review)
├── knowledge/     — domain notes (LLM prompt conventions, tool-calling survey)
└── logs/          — Mode 3 reviews, RCAs, evaluations all pinned here

1. Unit-test feedback — T1G..T7G live + headless TestKit suite catches regressions in protocol/state machines.

2. Live-run logs — %LOCALAPPDATA%\AgentZeroWpf\logs\app-log.txt captures every Reactor turn, peer signal, JSON parse failure.

3. Mode 3 RCA logs — per-regression dated post-mortems (symptom, root cause, patch, evaluation, deferred follow-ups).

4. Human as reviewer — accept or course-correct the harness's suggestions. Not "the AI does it all" but pair-programming with an iterative improver.

8. The on-device LLM era kicked off by open-model Gemma

• 2025-03 — Gemma 3 (1B/4B/12B/27B). 140+ languages, laptop · workstation target.

• 2025-08 — GPT-OSS 20B/120B (MXFP4 4-bit MoE). 20B runs on a 16 GB RAM edge.

• 2025 — Gemma 3n (PLE-based RAM saving). Mobile · handheld optimized.

• 2026-04 — Gemma 4 (small 128K, medium 256K context). Optimized for laptop local execution.

• 2026-04 — NVIDIA Nemotron 3 Nano Omni (30B-A3B Hybrid Mamba-MoE, 256K). Vision+audio+text, 9× throughput.

9. Will tokens really get cheaper than air?

10. Hybrid strategy — vendor-lock-free, choice belongs to the consumer

flowchart LR
  classDef cloud fill:#1e3a8a,stroke:#3b82f6,color:#dbeafe
  classDef local fill:#064e3b,stroke:#10b981,color:#a7f3d0
  classDef user fill:#7c2d12,stroke:#f97316,color:#fed7aa

  user(("👤 User<br>holds the choice")):::user

  subgraph cloud["Cloud (vendor)"]
    direction TB
    Cl["Claude"]:::cloud
    Cx["Codex"]:::cloud
    Gm["Gemini"]:::cloud
  end

  subgraph local["On-device (free)"]
    direction TB
    G4["Gemma 4"]:::local
    Wh["Whisper STT"]:::local
    Os["GPT-OSS"]:::local
  end

  user -->|"heavy reasoning"| cloud
  user -->|"PM · summary · STT"| local
  cloud <-.AI ↔ AI talk.-> local
  user -->|"WASM self-built plugin"| W["Voice Note etc."]:::local

• Multi-CLI — Claude, Codex, Gemini CLI all run side by side. A future CLI agent can slot into the same multi-view with almost no extra work.

• On-device ↔ cloud routing — AIMode's LocalLLM, acting as PM, decides where to send each task. Heavy reasoning → Claude, quick summary → Gemma. Agent usage cost stops being a vendor-bound thing and becomes the consumer's choice.

• Free voice-model combos — STT via Whisper, TTS via the best Korean-friendly model. Pick each separately.

• WASM plugins — internal tools and personal workflows: build them yourself. No vendor approval needed for a feature add.

• Harness view — see how each agent is actually working. Zero black box.

PlayGround value. AgentZero Lite is not aiming to "replace everything with on-device". It's a testbed for the partial-adoption hybrid strategy where small models step in for specific strengths. Not competing with Claude Code.

11. Closing — the agent serverless market is the real war

• Skill / MCP specs are interfaces. Anthropic created and opened them. By themselves they're a thin billing surface.

• Harness frame + agent serverless is where the real money is. Tokens aren't all of the cost. Token × tool fee (agent serverless) stacks into a double-billing structure. Because a harness orchestrates N agents, the contest is system-level, not single-agent-level.

• Benchmarks are losing discriminative power. Even Chinese models post higher LLM scores now. The real war happens in the agent serverless market.

• A B2B billing surface. A harness framework is exactly where you can attach pricing.

• IDEs keep getting heavier and pricier. Web/GUI tools layer in AI features and raise their subscription fees. Lighter attempts to control N things via CLI/TUI will keep coming.

• CLIs, once a developer's exclusive turf, recently picked up serious users in high-end creative and product-planning camps. The user base is widening.

• AgentZero Lite stakes its place in this AI upheaval as a PlayGround for validating the hybrid strategy of mixing diverse AI models (open × vendor) under user choice.

Appendix — sister repos worth a look

• harness-kakashi — a single-player practice harness. A Naruto-themed sandbox to get the feel of harnesses.

• pencil-creator — an experiment that uses a harness to auto-generate design-system templates.

• memorizer-v1 — a vector-search-based agent memory MCP server. Slated to become the harness's shared memory.

• DeskWeb — a qooxdoo-based Windows-XP-styled WebOS. Ships with 4 Claude Code Skills.

Sources

• AgentZero Lite — <https://github.com/psmon/AgentZeroLite> (README · README-KR)

• Anthropic tweaks Claude usage limits to manage capacity — The Register, 2026-03-26

• GitHub Copilot is moving to usage-based billing — GitHub Blog

• Gemma 3 — Google DeepMind, Gemma 4 model overview, Gemma 3n developer guide

• Introducing gpt-oss — OpenAI

• NVIDIA Nemotron 3 Nano Omni Powers Multimodal Agent Reasoning

• Sandboxing Agentic AI Workflows with WebAssembly — NVIDIA

• The Rise of AI Terminal Multiplexers — Beam

• tmux vs cmux — ice-ice-bear blog

• wmux — Windows tmux alternative for AI agents

• Whisper.net.Runtime.Vulkan — NuGet

NEXT