Linger is a free, open-source personal AI agent that runs locally on your PC via its PolyStrata engine, or routes tasks to Claude Code, Codex, or Pi.
Vamsi Tallapudi
Manager, Architect Technology at Cognizant
Linger is a free, open-source "personal agent" from SimplexAI Labs that you install on your own Mac, Windows, or Linux machine, and it runs a local AI brain (or routes to Claude Code, Codex, or Pi) without sending your files, inbox, or calendar to anyone else's server.
The project showed up on GitHub on November 19, 2026, and it didn't exactly sneak in quietly. Within a week it had crossed 1,000 stars, and by the ten-day mark some trackers had it closer to 1,800. That's the kind of trajectory that gets picked up by trending lists fast, and it's also the kind of trajectory where you should slow down and actually read the README before you hand an agent access to your email. So that's what I did.
Linger is built by SimplexAI, a startup founded by Tony Zhang (also known as Zhang Bo), an early DeepSeek team member who worked on DeepSeek V1 and led DeepSeek-VL before moving to a principal investigator role at Zhejiang University. That pedigree matters here because Linger isn't a wrapper around someone else's chat API. It's a genuine attempt to make a capable agent run on hardware you already own.
The core piece is an agent called "Another Me." It's not a chatbot you open and close. It sits there, watches your connected inbox, calendar, and Slack, builds a running wiki of the people and projects in your life, and decides on its own whether something deserves a notification now, later, or not at all. It learns from how you respond to those notifications and reviews its own calls every night.
Beyond the proactive layer, Another Me can:
team.md plan fileThis is the part that made it a trending repo. Linger's local inference runs on a separate SimplexAI project called PolyStrata, a mixture-of-experts inference engine that keeps the model's busiest experts loaded on your GPU and shuffles the rest between system RAM and SSD. That's how a 125-billion-parameter model (Qwen3.8-Flash-Next) can run on a 12GB consumer GPU, as long as you've got 64GB of system RAM to absorb the overflow.
SimplexAI claims PolyStrata is 2.7 to 3.5 times faster at prompt processing and 1.5 to 1.8 times faster at generation than plain llama.cpp on the same hardware. I haven't benchmarked that myself yet, and those are vendor numbers, not independent ones. Take them as "worth testing," not gospel.
The memory layer is markdown-based, not a vector database, and SimplexAI reports a 95% score on the LoCoMo long-conversation memory benchmark, ahead of Zep and Mem0 on the same test. Again: their numbers, their benchmark run.
Here's the actual headline feature for anyone already paying for a coding agent subscription: Linger doesn't force you to choose between "fully local" and "fully cloud." You configure the runtime per agent.
| Runtime | Runs on | Cost | Best for |
|---|---|---|---|
| Local (PolyStrata) | Your GPU + RAM | Free, no token fees | Privacy-sensitive work, background tasks, offline use |
| Claude Code | Anthropic's cloud, via your plan | Whatever your existing subscription costs | Harder reasoning, code-heavy tasks |
| Codex | OpenAI's cloud, via your plan | Whatever your existing subscription costs | Same, if that's the plan you already have |
| Pi | Cloud, via your plan | Whatever your existing subscription costs | Same |
So if you're already paying for Claude Code, Linger lets you keep using it for the hard stuff while routing routine background chores (watching your inbox, drafting a summary, running a shell script) to the free local model. That's a genuinely useful way to cut token spend without giving up capability. If you want a broader look at how Claude Code, Codex, and Pi stack up against each other on their own terms, we covered that comparison in our Claude Code vs Codex vs Pi breakdown.
You've got two paths: the desktop app, or Docker Compose if you're deploying to a home server or a box other people on your network will share.
Desktop app (simplest):
.dmg for Apple silicon Macs (macOS 14+), a .exe or portable .zip for Windows x64, or a .tar.gz for Linux x64.xattr -dr com.apple.quarantine /Applications/Linger.app in Terminal. The app isn't signed by Apple yet, so Gatekeeper will block it otherwise.Docker Compose (for servers):
git clone https://github.com/simplexai-labs/linger.git && cd lingercp .env.example .envdocker compose up --build --detach --waitprintf '%s\n' 'yourpassword' | docker compose exec -T teamhub teamhub-account create-owner --email [email protected] --password-stdinhttp://localhost:3000For local models specifically, run the guided installer: ./scripts/install/install.sh on macOS/Linux, or install.ps1 on Windows. It detects your GPU and RAM and installs whichever of the 12 supported models (Qwen, DeepSeek, GLM, and others) actually fits your hardware instead of just grabbing the biggest one and crashing.
If you'd rather test a smaller local model before committing 64GB of RAM to this, our guide on running Qwen3 locally with llama.cpp and Unsloth is a lighter starting point, and the Edge0 145B local-run writeup covers a similar squeeze-a-big-model-onto-consumer-hardware approach.
If you don't have a 12GB+ GPU sitting around, don't force it. Use the cloud runtime option and skip local models entirely. Linger still works fine as a memory-and-automation layer on top of Claude Code.
Mostly, yes, but read the license. It's not plain Apache 2.0. SimplexAI calls it the "Linger Open Source License," built on Apache 2.0 with extra conditions layered on top. The code is free to run, inspect, and modify for personal use, but before you fork it into a hosted commercial product, actually read what those extra conditions restrict. Most personal-use setups won't hit them at all.
I like that this exists. A 125B-class model running locally with no per-token bill is a real option now, not a hypothetical, and PolyStrata's expert-offloading trick is the kind of engineering that actually moves the local-AI story forward instead of just repackaging llama.cpp with a nicer UI.
That said, this thing is less than two weeks old as I'm writing this. It's going to have rough edges. You're also talking about giving an autonomous agent access to your signed-in browser, your inbox, your calendar, and shell commands on your machine. That's a lot of trust to extend to a project with a two-week track record, no matter how good the pedigree behind it is. I'd start it in a sandboxed VM or a throwaway account before pointing it at your real Gmail, and I'd watch the GitHub issues tab closely for the first month. The proactive "decides what to tell you" feature is genuinely cool when it works and genuinely annoying the one time it decides wrong, so give yourself a way to dial that down.
If you want the local-first angle without the always-on agent part, it's worth comparing against lighter local setups first, like what we covered in running Inkling 2 Mini locally, before jumping straight to a 64GB RAM requirement.
Linger is an open-source personal AI agent from SimplexAI Labs that installs on your own PC. It runs a local AI model through its PolyStrata engine, or routes tasks to Claude Code, Codex, or Pi using subscriptions you already have, and keeps your files and memory on your own device.
Running Linger and its local models costs nothing beyond your own electricity and hardware, since there are no per-token fees for local inference. If you route tasks to Claude Code, Codex, or Pi, you pay whatever those existing subscriptions already cost. The code is open source under a modified Apache 2.0 license with extra conditions for commercial hosting.
SimplexAI recommends a 12GB VRAM GPU and 64GB of system RAM to run the 125-billion-parameter model via PolyStrata. Docker deployments without local models need as little as 5GB of memory. Smaller models scale down from there.
Yes. Linger lets you pick the runtime per agent during setup, so you can use your existing Claude Code, Codex, or Pi subscription for harder tasks while routing routine background work to the free local model.
PolyStrata is SimplexAI's separate inference engine that Linger uses for local models. It keeps a model's most-used experts on your GPU and offloads the rest to RAM and SSD, which is how a 125B-parameter mixture-of-experts model can run on a 12GB consumer GPU.
Treat it with the same caution you'd give any brand-new autonomous agent. Linger is only a couple weeks old at the time of writing, with real capability but a short track record. Test it in a sandbox or throwaway account first before connecting your primary email and calendar.
New AI tools, automation workflows, and course drops — straight to your inbox. Join 2,400+ builders.
PostgreSQL 19 is out with REPACK (CONCURRENTLY), pg_plan_advice query hints, WAIT FOR LSN, and more. Here's what actually matters for developers.
Thinking Machines' Inkling 2 Mini is a 26B looped transformer at $0.15/$0.50 per 1M tokens that runs on a 32GB Mac, DGX Spark, or via GGUF on any PC.
Claude Fable 5.2 agents ran unsupervised for six weeks and solved two open black hole physics problems, including a calculation stuck since 2003. Here's how the setup actually worked.
Comments