sovel net-routed agentic os is a local-first reliability middleware for AI coding agents. It runs on your own machine as a Node.js command-line tool called sovel-brain and as a standard MCP server, and it gives your agents three things they tend to lack: persistent project memory, protection from repetitive failure loops, and controlled command execution. It connects to Claude Desktop, Cursor, Cline, and any client that speaks the Model Context Protocol.
The problem it addresses is easy to describe. AI coding agents lose track of what they decided an hour ago, repeat the same failed fix until your token budget burns out, and run commands with no supervision. The sovel net-routed agentic os treats those as engineering problems with deterministic answers, which is a way of saying the same input always produces the same checked result, rather than prompt-crafting puzzles. Memory lives in a local SQLite database, repeated failures trip a circuit breaker within two strikes, and every guarded command runs through a supervised execution path.
This page covers what the product does, what it deliberately does not do, how the three lifetime editions differ, and what your machine needs to run it. Every number here comes from the v1.3.0 release documentation and its published test results. If a figure is not in that documentation, it is not on this page.

What is SOVEL Net-Routed Agentic OS?
Direct answer: it is a local-first reliability middleware for AI coding agents. Middleware, in this case, means a software layer that sits between your AI agent and your operating system, watching traffic in both directions. The sovel net-routed agentic os runs as a Node.js CLI (sovel-brain) and a stdio MCP server, which is the standard way small programs exchange messages with AI clients, and it provides four capabilities:
- Persistent memory. Every project gets a local SQLite database in a
.sovel_memory/folder. At the start of each turn, the agent receives a dense summary of about 200 tokens covering what happened before, so a session that ended yesterday continues today instead of starting from zero. - Doom-loop protection. When an agent repeats or jitters around the same failing tool call, the loop breaker intercepts the pattern within two strikes and stops the cycle before it eats your token budget.
- Guarded command execution. Commands run through
sovel-brain guard, which supervises the process, records what ran, and applies rate limits so a runaway agent cannot hammer your system or an API. - Verifiable reporting. The
export allcommand produces reports in five formats: HTML, JSON, Markdown, PDF and DOCX. Each report shows what the engine observed, so you can audit a build instead of trusting a chat transcript.
The “net-routed” part of the name comes from the engine’s design vocabulary. Its eight internal modules are named after computer networking protocols such as OSPF and BGP, because the same ideas that keep data packets moving reliably across a network also keep an AI agent moving reliably across a long task. They are networking-inspired heuristics, which means practical rule-of-thumb methods borrowed from networking, not certified implementations of the actual protocols. Section below explains each one honestly.
What the sovel net-routed agentic os is not
Honest limits are part of the product, so here they are up front:
- Not a hosted service. There is no dashboard running on someone else’s servers. Everything executes on your machine, and nothing is sent anywhere. There is zero telemetry, which means the software does not phone home with usage data.
- Not an operating system. It manages agent behaviour; it does not replace Windows, macOS or Linux.
- Not a real network stack. The eight modules borrow names and ideas from networking. They are heuristics for agent control, not OSPF or BGP running in your kernel.
- Not a sandbox. Guarded commands still run with your user’s permissions. The engine supervises and records them; it does not imprison them.
- Not a point-and-click tool. You will live in a terminal. If that sentence put you off, this product is not for you, and the next section will not change your mind.
The three failure modes it fixes
Every feature in the sovel net-routed agentic os traces back to one of three failure modes that agents hit in real projects. Here is each one, what it costs you, and what the engine does about it.

1. Doom loops that burn tokens
Ask anyone who codes with agents and they will describe the same morning. The agent hits an error, tries a fix, the fix fails, and it tries again with slightly different wording. Twenty minutes later you are watching the same broken patch arrive for the fourth time, and your API meter has been running the whole while. Developer forums gave this pattern a name, the doom loop, and the complaints keep coming because the usual advice, re-prompting harder, tends to make the polluted context worse. The sovel net-routed agentic os attacks it mechanically: repetitive and jittered tool calls are detected within two strikes, the loop is interrupted, and the agent is forced to change strategy instead of re-arguing with the same error.
2. Context amnesia
An agent’s working memory is its context window, the slice of text the model can attend to at one moment. When the session ends or the window fills, the details vanish. The sovel net-routed agentic os keeps a local SQLite database using write-ahead logging, a storage technique that survives sudden interruptions without corrupting data, and injects a dense 200-token summary at the start of each turn. Your agent walks in knowing the project’s decisions, not guessing at them.
3. The MCP token tax
Every MCP server you connect announces its tools to the client, and each announcement costs tokens on every single request. Connect enough servers and a large share of every prompt is spent describing tools rather than doing work. The sovel net-routed agentic os uses lazy tool schema injection: tool descriptions are loaded only when a tool is actually needed, cutting prompt context bloat by a measured design target of 65 to 80 percent. Your model spends its attention on your code.
How the sovel net-routed agentic os works
Five steps take you from download to a supervised agent session. None of them need an account, an API key or an internet connection beyond the initial download.
- Install and verify. The engine needs Node.js 22.13.0 or newer, because it uses the
node:sqlitemodule built into modern Node. Extract the ZIP for your edition and runsha256sum -c SHA256SUMS.txtto confirm the files match their published checksums, which are cryptographic fingerprints that prove nothing was altered in transit. - Initialize memory. Run
sovel-brain initinside your project. It creates the.sovel_memory/folder with a SQLite database that will hold the project’s running state. - Connect your AI client. Run
sovel-brain mcpto start the stdio MCP server, then add one JSON block to Claude Desktop, Cursor or Cline. Any client that supports the Model Context Protocol can talk to it. - Run guarded commands. Prefix a command with
sovel-brain guard --and it executes under supervision. The loop breaker watches the output, the rate limiter holds concurrency in check, and the record of what ran lands in the database. - Check and export. Run
sovel-brain doctorfor a health report on memory, protocols and configuration. Runexport allwhen you need evidence: the sovel net-routed agentic os writes verifiable reports in HTML, JSON, Markdown, PDF and DOCX.

What the memory actually does between sessions
Memory that only stores data is common. Memory that resurfaces the right data at the right moment is the hard part, and it is where most agent setups quietly fail. The sovel net-routed agentic os closes each turn by writing what changed into the project database, then compresses the running state into a summary that fits in about 200 tokens. At the start of the next turn, that summary is injected ahead of your prompt. The agent does not re-read a transcript of everything that happened; it receives the distilled state, the same way a shift supervisor reads a handover note instead of the full logbook. Because the summary is dense by design, it costs a fraction of the context window, which is precisely the budget the engine is trying to protect.
Why local-first is the design, not a limitation
Most agent tooling in 2026 asks you to send your project context somewhere else. A hosted memory service means your code structure, your decisions and your client names sit on someone else’s servers, priced monthly. The sovel net-routed agentic os takes the opposite position: the machine you already own is the right place for agent state, and the sovel net-routed agentic os is built to make that position practical rather than punishing.
Practical means the SQLite file opens with any SQLite browser, so your agent memory is never locked in a proprietary format. It means the audit trail of guarded commands is yours to export, keep or delete. It means a laptop on a plane runs the full engine, because nothing in the core path needs a round trip to a server. And it means the sovel net-routed agentic os cannot silently change under you the way a hosted plan can, because the release you downloaded is checksum-locked and yours.

Security and privacy posture
Because the engine runs locally, its privacy story is short and checkable. Project memory, execution records and reports never leave your disk unless you export them yourself. There is no telemetry, no crash reporter phoning home, and no account system holding your data on a vendor’s servers. The licence token is a signed file checked locally at startup, so an offline machine still runs. Distribution integrity is handled with published SHA-256 checksums, and the release pipeline locks archives so the ZIP you download can be verified byte for byte against the tested build. If you work under client confidentiality or in a regulated shop, this is the part of the spec sheet worth reading twice.
The eight protocol-inspired modules
Each module borrows a working idea from networking and applies it to agent behaviour. The names are familiar; the jobs are agent-sized. To be plain about it once more: these are heuristics inspired by the protocols, not the protocols themselves.
| Module | Borrowed idea | What it does for your agent |
|---|---|---|
| OSPF | Link-cost routing | Picks between available tools by latency, reliability and token spend instead of always grabbing the first one |
| BGP | Boundary routing | Keeps a strict border between local machine work and cloud model calls, so private code stays local |
| EIGRP DUAL | Feasible successors | Pre-computes a fallback path so a failed step switches to a ready alternative instead of stalling |
| RIP | Hop count limit | Hard recursion cap of five hops, which stops an agent from chasing its own tail indefinitely |
| TCP AIMD | Sliding-window rate control | Cuts concurrency by half on repeated HTTP 429 responses, then eases back up, the way well-behaved network traffic does |
| ICMP | Heartbeat and watchdog | Two-second heartbeat pings with a 30-second hard stall timer, so a hung process gets caught and reported |
| QoS | Priority queuing | Your interactive edits queue ahead of background indexing, the way emergency traffic passes routine traffic |
| MPLS | Short path labels | Compact state labels let the engine forward context between stages without re-reading everything |

Three lifetime editions of the sovel net-routed agentic os
The engine ships in three editions with the same feature set in each. The differences are seats, commercial scope and support level. All three are one-time purchases under a perpetual licence, which means you pay once and keep using the v1.x release you bought, with no recurring subscription fee. If a licence token ever expires, the entitlement survives: send your invoice ID to support@sovel.pro and a replacement token is reissued at no additional charge under the licence terms dated 15 November 2026.
Personal Edition
₹1,999 / lifetime
For solo builders and researchers who want reliable agent sessions on their own machine.
- 1 named user, 1 workstation
- Full engine: memory, loop protection, guard
- All five report export formats
- Strictly non-commercial use
- Lifetime updates for the edition
Support: documentation and email
Pro Edition
₹4,999 / lifetime
For developers who build and monetize their own products with agent assistance.
- 1 named developer, 2 owned workstations
- Everything in Personal
- Commercial rights to your own first-party products
- Priority email support, 2 business days
- Lifetime updates for the edition
Support: priority email
Agency Edition
₹9,999 / lifetime
For teams and studios delivering agent-assisted work to paying clients.
- Multi-seat team licence
- Everything in Pro
- Client project delivery rights
- Priority support with escalation
- Lifetime updates for the edition
Support: priority support
Prices shown exclude GST. Edition rights are governed by the End User Licence Agreement for each edition, effective 15 November 2026, available on the licence terms page.
| Edition | Users and machines | Commercial scope | One-time price |
|---|---|---|---|
| Personal | 1 user, 1 workstation | Non-commercial | ₹1,999 |
| Pro | 1 developer, 2 workstations | Own first-party products | ₹4,999 |
| Agency | Team, multi-seat | Client delivery included | ₹9,999 |
Who the sovel net-routed agentic os is for, and who should skip it
A good fit if you are:
- A developer or technical operator whose agents keep losing context between sessions and you want that fixed at the tool layer, not with longer prompts
- A team running long agent sessions where a single doom loop can eat a meaningful slice of your monthly token budget
- A builder who wants an audit trail: what ran, what failed, what the engine observed, exportable as evidence
- Comfortable in a terminal and happy to read a short runbook before the first guarded command
Look elsewhere if you:
- Want a hosted dashboard you can open from any browser with nothing installed locally
- Expect one-click autonomy with no review of what the agent did
- Need a certified network protocol implementation; the modules here are agent-control heuristics with networking-inspired names
- Are looking for a GUI product; this one is a CLI and an MCP server, and it says so plainly
What a lifetime licence costs compared with subscriptions
The agent-memory and agent-reliability market in 2026 is mostly subscription software. Public pricing pages, checked in November 2026, list hosted memory services starting around 19 US dollars per month for an entry tier, with team tiers reaching 125 dollars per month and beyond. A year of an entry plan costs more than the Personal Edition of the sovel net-routed agentic os, and the hosted plans keep charging as long as you keep using them.
The difference goes beyond price. Hosted memory services hold your project context on their servers. The sovel net-routed agentic os holds it in a SQLite file on your disk, with zero telemetry, and its licence verification checks a signed token locally. If those services change their pricing or shut down, your workflow changes with them. If this engine never updates again, the copy you bought keeps working, because a perpetual licence does not depend on a vendor’s server staying alive.
| Typical hosted memory tools | Sovel Net-Routed Agentic OS | |
|---|---|---|
| Pricing model | Monthly subscription, usage-metered | One-time perpetual licence |
| Entry cost per year | From about $228 (Starter tier, public pricing) | ₹1,999 once (Personal) |
| Where memory lives | Vendor’s cloud | Your disk, local SQLite |
| Telemetry | Varies by vendor | None |
| Scope | Memory layer only | Memory, loop protection, guarded execution, reporting |
That table is a factual comparison, not a claim that any competitor is bad at its job, and it is why the sovel net-routed agentic os prices the way it does. They solve memory for hosted applications well. This engine solves reliability for agents working on your own machine, which is a different job.

Technical requirements
| Requirement | Detail |
|---|---|
| Node.js | v22.13.0 or newer (v24.x recommended); the engine uses the built-in node:sqlite module, documented at nodejs.org |
| Operating system | Windows, macOS or Linux; CI-tested on macOS, Ubuntu and Windows runners |
| AI client | Any stdio MCP client: Claude Desktop, Cursor, Cline and others |
| Storage | Local SQLite database with write-ahead logging per project (.sovel_memory/); the file format is the open SQLite standard |
| Network | Works offline after installation; licence verification checks a signed token locally |
| Reports | HTML, JSON, Markdown, PDF, DOCX export |
The v1.3.0 release passed 179 automated tests across three independently extracted deployment contexts, and its continuous integration matrix runs the suite on macOS, Ubuntu and Windows across Node 22.x and 24.x. Release archives are byte-locked with published SHA-256 checksums, so the package you download can be proven identical to the package that was tested.
Claims are cheap on a product page, so here is the receipt. The check panel below is the actual continuous integration result for the v1.3.0 release commit: seven successful checks, one for each operating system and Node version pair in the matrix, all green on the same push that produced the downloadable archives.

Every row in that panel maps to a real test pass on a real machine image, not a locally green run on one lucky laptop. If a future release cannot reproduce this panel, the release does not ship. That is the standard the 179-test suite exists to hold, and it is the reason the checksums on the download page matter: the archive you install is the archive those seven runners verified.
Frequently asked questions
Is SOVEL Net-Routed Agentic OS a cloud service?
No. The sovel net-routed agentic os runs entirely on your machine as a Node.js CLI and a stdio MCP server. Your project memory stays in a local SQLite file, and the engine sends no telemetry anywhere.
Which AI clients does it work with?
Any client that supports the Model Context Protocol over stdio, including Claude Desktop, Cursor and Cline. You add one JSON configuration block pointing at sovel-brain mcp and the tools appear in your client.
What exactly is an agent doom loop?
It is the pattern where an agent repeats or slightly varies the same failing action instead of changing strategy, burning tokens each time. The engine’s loop breaker detects repetitive and jittered tool calls within two strikes and interrupts the cycle.
Are the eight network protocols real implementations?
No, and the product does not claim they are. They are heuristics inspired by networking protocols, applied to agent control. The module names describe the borrowed idea; none of them implement certified OSPF, BGP or TCP behaviour.
Is there a monthly subscription?
No. All three editions of the sovel net-routed agentic os are one-time perpetual licences. You pay once, keep the v1.x release you bought, and pay nothing to continue using it. There are no recurring fees of any kind.
What happens if my licence token expires?
Your entitlement does not expire with the token, which is a technical security mechanism. Email support@sovel.pro with your invoice or order ID and a replacement token is issued at no additional charge, as set out in the licence terms effective 15 November 2026.
Can the Agency Edition be used for client work?
Yes. The Agency Edition covers client project delivery for teams and studios. The Pro Edition covers commercial rights to your own first-party products, and the Personal Edition is strictly non-commercial. The licence terms page lists the exact scope of each.
How does it behave on a machine with no internet?
Fully, with one narrow exception. After installation, memory, loop protection, guarded commands and all export formats work offline. The only online step is the initial download of the package itself, and licence verification runs locally against a signed token rather than calling a server.
How is this different from a hosted memory tool?
Hosted memory tools store facts about your users on their servers and charge monthly. The sovel net-routed agentic os keeps memory on your disk, adds loop protection and guarded execution on top, and sells as a one-time licence. It is reliability middleware for local agent work, not a memory API for hosted applications.
Choose your edition and put your agents on a leash
A concrete morning looks like this. You open Cursor on a project you last touched two days ago. The sovel net-routed agentic os hands your agent a 200-token brief: the migration you half-finished, the test that was red and why, the decision to keep the old parser. The agent picks up the migration instead of re-discovering the codebase. Halfway through, a build step fails twice; the loop breaker interrupts on the second strike and the agent switches to the fallback path EIGRP DUAL prepared earlier. You run sovel-brain doctor, see the session summary, and export a PDF for the client. Nothing left your machine at any point in that story.
Long agent sessions do not have to end in a doom loop, and your project’s decisions do not have to evaporate every time a context window fills. The sovel net-routed agentic os puts memory, loop protection and supervised execution in one local install, with a one-time price and an audit trail you can export.
- Buy Personal Edition (₹1,999) for solo, non-commercial work on one machine
- Buy Pro Edition (₹4,999) for developers monetizing their own products on two workstations
- Buy Agency Edition (₹9,999) for teams delivering client work
Every edition includes instant digital download, lifetime updates for the edition, complete documentation and email support at support@sovel.pro. Browse the rest of the catalogue on the products library or the shop, and see how the engine compares with other agent tooling in our AI coding agent comparison.