Star on GitHub
Document SSH remote setup
Start task →
Free & open source, MIT
Every agent starts where the last one stopped.
One shared memory across every agent, and a planboard that is your GitHub issues.
Downloads for macOS Windows Linux install steps
Free & open source, MIT
One shared memory across every agent, and a planboard that is your GitHub 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.
Claude Code
Codex
Kimi
Grok
Cursor
OpenCode
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 and OpenCode. 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 plain GitHub issues with labels, so nothing is trapped in
a local database. Agents update it with gh. Your teammates
see the same board without installing anything. Start task on a Todo
card opens a thread on that issue. Needs the GitHub CLI signed in, and
a project whose origin is on GitHub.
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 and OpenCode 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 issues | ||
| One git worktree per thread | sometimes | |
| Verify gate before a thread settles green | ||
| Spend caps and per-thread token burn | ||
| Six providers on your own subscriptions | sometimes | |
| MIT licensed, runs fully local | sometimes | |
| macOS, Windows and Linux |
Claude Code, Codex, Cursor, Kimi, Grok and OpenCode. 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 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.
The GitHub CLI signed in, and a project whose origin is on GitHub. Without those, threads, memory and everything else work exactly the same; the board simply stays off.
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 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.