A local AI agent —
with a console worth opening.
TARS runs as a single Go binary on your machine and opens a full browser console — chat with dockable Git Inspector, agent runtime flow graphs, message-level session forks, memory inbox review, scheduled jobs, and a background watchdog. Everything that matters has a UI.
Built to work beside a
human operator.
The name is an homage to TARS from Interstellar — practical, direct, built to work under pressure. TARS borrows that name as a north star for the kind of local agent runtime it wants to be.
Most agent frameworks live in the cloud, or ship as a thin CLI with maybe an HTTP API bolted on. TARS lives on your machine, owns its own memory, and treats the browser console as a first-class surface — not an afterthought. Every operating concern (chat, sub-agents, scheduling, memory review, approvals, analytics) has a real page.
Extension is intentionally lean: skills (Markdown + companion CLI) load only when invoked — not every chat turn. Plugins and MCP servers are gated, so the system prompt stays small and the agent stays focused.
The console isn't a viewer.
It's the cockpit.
Most local agent tools ship a CLI and call it done. TARS treats the browser console as a first-class surface — every page is a working tool, not a status read-out. Open 127.0.0.1:43180/console and these are some of the rooms you walk into:
Mission Control
Pulse, Reflection, plans, runtime runs, cron jobs, disk pressure, sessions, recommended setup actions — all on one screen.
Chat
Dockable panels: Sessions, Tasks, Health, Git Inspector, Skill Inbox, Cron, Prior Context. Message-level session forks. First-turn tier recommendation.
Lineage
Git-log–style tree of root and forked sessions. Fork point previews. Promote fork insights into Memory Inbox without mutating the parent.
Memory
Review-before-store inbox for reflection candidates. Edit stored knowledge inline. Compare Tool path vs Prefetch path recall.
Agent Runtime
List, tree, Gantt, and interactive Flow graph views. Replay scrubber, cost flow, file attention, git diff timeline, checkpoint restart.
Approvals
Risky cleanup plans and approved Git mutations gated before TARS applies them. Automation Audit log keeps every decision reviewable.
Analytics
Usage totals, daily token bars, model cost rows, tool/skill call counts. UTC day-bounded daily budget chip in the header.
Extensions
Skill Creator and MCP Server Creator with sandbox tests. Hub installs surface trust signals (score, last update, passing tests, install count).
Behind the console,
a careful runtime.
TARS draws a hard line at what should be in the binary versus what should be a skill. The runtime stays small; the rest is opt-in.
Sub-Agent Orchestration
Spawn read-only agents for research and planning. Per-task tier routing, allowlist policy, depth control. Parallel and compare modes.
Durable Memory
Markdown memory with semantic search via Gemini embeddings. Daily logs, reviewed experiences, nightly reflection — all auditable on disk.
Pulse Watchdog
Runs every minute. Catches cron failures, stuck runs, disk pressure, telegram errors — escalates to a narrow LLM decision call only when needed.
Nightly Reflection
Between 02:00–05:00 TARS extracts experiences from sessions, prunes empty ones, and grows the memory store. Deterministic Go, no LLM tool surface.
Scheduled Jobs
Tick-based scheduler at 30s resolution. Cron expressions plus @at one-time triggers. Per-job audit history, capped to keep state lean.
3-Tier LLM Router
Heavy / standard / light tiers map to provider+model bundles. Roles bind to tiers, credentials live at provider level, env-var JSON overrides.
Skills, Plugins, MCP
Skills are Markdown + companion CLI — only loaded when invoked, so the system prompt stays small. Plugins gated; MCP fully supported as a client.
Multi-Channel I/O
Beyond the console: Telegram bidirectional messaging, inbound webhooks, macOS Assistant popup, and a local API for scripts.
How TARS differs.
Two excellent local agent projects in this space — OpenClaw and Hermes Agent. Each has its own focus. Here's where TARS draws different lines.
| Dimension | OpenClaw | Hermes Agent | TARS |
|---|---|---|---|
| Language | TypeScript | Python | Go (single binary) |
| Primary UI | CLI | CLI + API | Browser console (CLI/Telegram/webhooks too) |
| Sub-agents | ACP + subagent runtimes, Docker sandbox | ThreadPoolExecutor (max 3), ephemeral prompt | Per-task model tier, allowlist policy, depth control |
| Model routing | Per-agent model override | Per-child override, MoA (4 frontier models) | 3-tier bundles (heavy/standard/light), role→tier mapping |
| Memory | Session transcripts | Honcho/Holographic plugin hooks | Markdown + semantic + review-before-store + nightly reflection |
| Background | — | — | Pulse watchdog (1-min) + nightly reflection batch |
| Scheduling | — | — | Session-bound cron + audit logs |
| Extensibility | Built-in tools | Toolsets | Skills + companion CLIs + gated plugins/MCP |
Comparison is from the TARS perspective and intentionally simplified. Read the source for each project to form your own view.
One binary,
two registries.
TARS isolates the chat tool surface from system internals. The user-facing registry can never call ops_, pulse_, or reflection_ tools — those are reserved for the runtime itself. Pulse uses narrow Go interfaces and only one LLM call. Reflection is fully deterministic.
┌─ cmd/tars (cobra) ──────────────────────────────────────┐
│ serve · service · init · doctor · status · cron · ... │
└──────────────────────────┬──────────────────────────────┘
│
┌──────────────▼──────────────┐
│ tarsserver (127.0.0.1:43180) │
└──┬─────────┬──────────┬──────┘
│ │ │
┌───────▼──┐ ┌────▼─────┐ ┌──▼─────────┐
│ chat │ │ pulse │ │ reflection │
│ agent │ │ watchdog │ │ nightly │
└────┬─────┘ └────┬─────┘ └────┬───────┘
│ │ │
┌────▼────────────▼────────────▼─┐
│ memory · cron · ops · llm │
└────────────────────────────────┘Three steps to a running agent.
On first launch, the wizard walks you through provider and tier configuration. The console boots in setup-only mode until an LLM is configured.
Install
macOS / Linux — pre-built binary with console
brew tap devlikebear/tap brew install devlikebear/tap/tars
Initialize workspace
tars init
Start the server
Runs in the terminal until Ctrl+C.
tars serve # console at http://127.0.0.1:43180/console