Document SSH remote setup
Start task →
Free & open source, MIT
Every agent starts where the last one stopped.
A free desktop app for running AI coding agents in parallel. Claude Code, Codex, Cursor and more, each in its own git worktree, with one shared memory and a planboard that is your GitHub or GitLab issues.
Downloads for macOS Windows Linux install steps
Your subscriptions, not ours. Solenta drives the CLIs you already installed and finds them on your PATH.
Shared memory
What one thread learns, the next one knows. Solenta injects a local memory server into every agent session automatically, so decisions and gotchas persist across Claude Code, Codex, Cursor, Kimi, Grok OpenCode and Muse Code. The tenth session on a project is better informed than the first.
Ruled out a rewrite of auth. Cookie session stays; refresh lives in src/lib/auth.ts.
The 401 retry is in src/lib/api.ts. Moving it breaks the refresh path.
Starts knowing both. Adds the expiry skew and leaves the rest alone.
The board is your project's GitHub or GitLab issues with labels, so
nothing is trapped in a local database. Your teammates see the same
board without installing anything. Start task on a Todo card opens a
thread on that issue. GitHub uses a saved token or your existing CLI
login. GitLab uses glab.
No local-only planner can copy this.
Document SSH remote setup
Start task →
Show remaining spend cap in the composer
Start task →
Lead the site with memory and the planboard
Inject the memory server into every session
One git worktree per thread
Everything stays on your machine. Solenta drives the CLIs you already have installed.
Seed, analyze, verify, judge, synthesize. Fan out agents per phase, give each phase its own provider, and watch every phase settle live.
Claude Code, Codex, Cursor, Kimi, Grok, OpenCode and Muse Code with sticky permission modes, model overrides and session resume.
A shell in the thread's worktree and an embedded browser on your dev server, beside the transcript. Screenshot the page into the composer, or let the agent click through it itself.
Dot, title, age. No project group headers. Threads that need you stay up top. Quiet runs sit in Working. Pin what matters; snooze and settle have their own shelves.
Workers share a crew task list and message each other directly. A shared per-repo code index goes into every dispatched prompt, so a fresh worker starts knowing where things live.
Hints, not solutions, on every provider. Autonomy steps up as reviews pass, and permission modes stay gated to the current rung.
Read-only questions about the repo, answered from the code index and shared memory. No worktree, no tools, no spend. Start work when you are ready to change things.
Requirements, design, tasks, each one gated until you approve. Then Dispatch forks a worker per unblocked checkbox, and Converge fills in what the repo is still missing.
Every agent diff gets a risk-ranked read order: CI and config first, then reuse, the critical path, tests, and the rest. Environment is a tab in the inspector, not a pile of cards.
A thread only settles green once its verify command exits 0. Guardrails protect the config a worker may not touch, and scan what it brings back for injection and secrets.
Merge rate, review tax, rework and cost per merged PR, read off git and GitHub, not off what the agents say about themselves.
Set a daily budget. A run that would cross it never starts. Token burn is visible per thread.
--serve-web puts the UI in a browser behind a token. Connections opens that UI on another machine through SSH. A remote project runs the agent on that host instead.
Working, idle, done, failed. Every thread at a glance.
Recurring prompts against any project: hourly, daily, weekly, with the provider and model you pick.
Every thread carries tools to drive the other threads. You describe the fan-out in plain language; the agent spawns, supervises and reports back.
Tabs and wrappers give each agent a window. Solenta gives the fleet a memory, a board and a verdict.
| Capability | Solenta | Tabs & wrappers |
|---|---|---|
| Shared memory across every agent | ||
| Planboard backed by your GitHub or GitLab issues | ||
| One git worktree per thread | sometimes | |
| Verify gate before a thread settles green | ||
| Spend caps and per-thread token burn | ||
| Claude Code, Codex, Cursor, Kimi, Grok, OpenCode and Muse Code on your own subscriptions | sometimes | |
| MIT licensed, runs fully local | sometimes | |
| macOS, Windows and Linux |
Compare documented workflows: Solenta vs Conductor and Solenta vs Claude Squad. See Conductor alternatives for both.
Open a thread per task in Solenta. Each thread runs the agent CLI you pick (Claude Code, Codex, Cursor, Kimi, Grok, OpenCode or Muse Code) in its own git worktree, so parallel agents never share a working copy. Threads that need you stay up top, and you can fork one task across several providers and keep the best diff. Read the parallel-agent guide.
Give every agent its own git worktree on its own branch. Solenta does that per thread automatically, and a thread only settles green once its verify command exits 0, so "done" means your checks passed, not that the agent said so.
No. Solenta is the desktop app that runs your coding agents. It drives the agent CLIs you already installed, on your own subscriptions, and adds shared memory, a planboard, worktrees, verify gates and spend caps around them.
Claude Code, Codex, Cursor, Kimi, Grok, OpenCode and Muse Code. Install the CLIs you want to drive and Solenta finds them on your PATH. Permission modes, model overrides and session resume are per provider.
Only inside the prompts your chosen agent CLI sends to its provider, same as running that CLI yourself. Solenta adds nothing on top: memory is a local SQLite file, plans are your own GitHub or GitLab issues, and there is no Solenta cloud.
No. Bring your own subscription or API key per provider. Solenta never resells tokens and never sits in the billing path.
A project whose origin is on GitHub or GitLab. GitHub uses a token saved per host in Settings, Git, or your existing GitHub CLI login. GitLab uses glab, including self-hosted hosts with "gitlab" in the name. Other features work without a board.
Yes. MIT licensed, with releases for macOS, Windows and Linux.
Solenta is MIT licensed and runs on your machine. It drives the agent CLIs you already installed. Plans live in GitHub or GitLab issues. Memory lives in a local SQLite file you can read and export. People who pick tools in 2026 ask who owns them. The honest answer here is you do.
Grab the archive for your platform, then install whichever agent CLIs you want to drive. Solenta finds them on your PATH.
Apple Silicon only. There is no Intel (x64) build yet.
%LOCALAPPDATA%\Solenta.A portable zip, not an installer. No setup wizard, no Start menu entry, and moving the folder later is on you.
tar xzf Solenta-*.tar.gz./solenta/solentaA tarball for glibc x64 desktops. No .deb, no .rpm, no AppImage yet.