Atlarix — The Frontier Harness for Open-Weight Models

• 

  Right Panel -> Preview Tab

• 

  Right Panel -> Terminal Tab

• 

  Right Panel -> Error Tab

• 

  Help

• 

  Right Panel -> Automations Tab

• 

  Dark Theme Workspace Selector

• 

  Light Theme Workspace Selector

• 

  Right Panel -> Browser Tab

• 

  Workspace Chat

• 

  Settings

• 

  Tools

Atlarix — The Frontier Harness for Open-Weight Models

Atlarix is an agentic coding harness built for people who want to run open-weight and local models on their own hardware — privately, at their own cost. No forced cloud, no vendor lock, no per-seat AI tax. Bring your own model (Ollama, LM Studio, or any of ~160 providers), or run fully local. It runs natively on Arm64 via Apple Silicon — clone it and run it on any M-series Mac.

Inspiration

Most AI dev tools assume you'll rent someone else's model over someone else's cloud. That's fine until you care about privacy, cost, or control — and increasingly, developers do. Open-weight models got good enough to run real agentic coding workflows locally. What was missing was a harness lean enough to sit on top of them without dragging in a heavy indexing and telemetry stack.

That's Atlarix. And since the machines developers actually run local models on are increasingly Arm64 — Apple Silicon today, Arm64 laptops and servers tomorrow — building a harness that stays light and cool on Arm hardware isn't a nice-to-have. It's the point.

What it does

Atlarix is a desktop agent that drives a full coding loop — read, edit, run, test, review — against whatever model you point it at:

• Runs open-weight models locally through Ollama / LM Studio, or any OpenAI-compatible provider.
• Every commit is authored by you; Atlarix is credited only as Co-authored-by:.
• Sandboxes command execution and gates every edit behind an approval diff.
• Keeps the main process calm and cool on large repos.

How efficiency is the Arm story

Here's the honest engineering claim, and it's a real one: a harness that's lean is a harness that runs well on Arm. Over the last releases Atlarix got dramatically lighter — and these are measured, not hand-waved:

• Killed a file-descriptor leak that hit ~12,000+ open fds on large repos (one fd per watched file via kqueue). fd count now stays flat (~113) under real load, and the heat and CPU that came with it are gone.
• Collapsed retrieval to pure ripgrep — deleted the entire FTS5 / SQLite / BM25 indexing apparatus. Net −5,246 lines. Same search behavior as Claude Code / opencode, a fraction of the resident weight.
• Trimmed the dependency tree and the agent prompt surface — fewer moving parts, less memory, faster cold start.

On a thermally constrained Arm laptop, "doesn't spin up a background indexer that reads every file in your repo" is the difference between a tool you can run all day on battery and one you can't. That's the efficiency-minded design this challenge asks for — earned by subtraction, not by bolting on an Arm-specific hack.

How I built it

• Electron + TypeScript desktop app.
• Multi-provider model layer — provider-native /models first, models.dev catalog fallback, hourly refresh, last-good cache.
• Sandboxed execution via a native sandbox binary; edits routed through a diff + approval gate.
• Server-side proxy for the managed-credit path, so no secrets ship in the client bundle.
• Built and refined daily on Apple Silicon — so Arm64 isn't a port I bolted on for this challenge. It's the machine the whole thing was written on.

Challenges I faced

• Making local / weak open-weight models behave in an agentic loop. They stall, re-emit tool calls, and settle badly. Much of the work is harness-side: per-delta tool-call detection, stall auto-retry on fresh controllers, and idle budgets tuned for open-weight reasoning pauses.
• Staying light without losing capability. Deleting the index meant proving ripgrep-only retrieval held up under real use. It did.
• Cross-platform auto-update across macOS, Linux, and Windows without three separate broken update paths.

What I learned

The fastest path to "runs well on Arm" wasn't a special-case optimization — it was ruthless subtraction. Every megabyte of resident memory and every background file-watcher you delete is one an Arm laptop doesn't have to spend on heat and battery. Efficiency and simplicity turned out to be the same lever.

What's next

• Publish reproducible Arm64 benchmarks — cold start, resident memory, and end-to-end agent-loop latency running a local open-weight model on Apple Silicon and on a Linux Arm64 server.
• A one-command local + Arm64 quickstart so any developer can run a fully private, on-device coding agent on their own hardware.

A note on source: Atlarix is a real product, not a throwaway hackathon build, and it is not open source. I'm submitting it honestly as what it is rather than reshaping it to fit. What I can show is the shipped software itself — releases, its MCP integrations, and its skills , running on Arm64.

Built With

• agentic-ai
• apple-silicon
• arm64
• electron
• hono
• lm-studio
• local-llm
• model-context-protocol
• node.js
• ollama
• open-weight-models
• openrouter
• railway
• react
• ripgrep
• sqlite
• supabase
• typescript
• vite