What Agentic-Nets Makes Possible Now
Agentic-Nets is a domain-general backend for designing, operating, observing, and continuously improving governed autonomous processes. The easiest place to begin is not an abstract workflow. It is a persona: a developer, health coach, analyst, researcher, operator, reviewer, or a complete team. The real advantage appears after that persona starts working, because every meaningful step lives in a net and becomes evidence you can inspect, compare, and use to improve the system.
Any process that can be represented as typed state, transitions, context, evidence, and authority boundaries can be modeled, automated, historically analyzed, and progressively optimized with Agentic-Nets.
That is a large claim, so it needs a precise qualification. Domain-general does not mean domain-omniscient. Agentic-Nets does not arrive knowing medicine, finance, logistics, research, product development, or your company. It provides the operating substrate. You provide the domain context, goals, policies, data, integrations, validation rules, and authority boundaries. Together those elements can become an autonomous process that is durable, observable, and governable.
Start With a Persona, Then Reveal the Net
For a newcomer, “create a workflow” is an awkward starting point. It asks the user to understand the machinery before understanding the benefit. “Create a health coach” or “start a safe product team” is different. A persona has a recognizable job, expertise, tone, responsibility, and boundary. People already know how to describe one.
In Agentic-Nets, a persona is more than a system prompt. It can have durable domain context, typed task and result places, tools, schedules, approval gates, communication links, capability flags, resource scopes, and a history of its decisions. A developer can be allowed to inspect and modify a repository but prevented from releasing. A coach can produce plans and track progress but never diagnose or prescribe. A financial reviewer can prepare evidence but require a human to authorize a consequential action.
The net is what turns the understandable persona into an operable system. Places hold typed state. Transitions route, transform, decide, call an API, invoke a model, operate as an agent, execute a command, or connect knowledge through typed links. Tokens carry the work and its provenance. The persona remains the front door, while the net makes its behavior explicit.
Four Ways the Reasoning Can Run
An autonomous process should not depend on one model provider or one deployment shape. Agentic-Nets separates the net, state, governance, and evidence from the place where reasoning happens. Today that gives a builder four practical choices.
- Server-run LLM and agent transitions. When a provider is configured, the master can execute
llmandagenttransitions directly with Claude, OpenAI, or Ollama. This is the straightforward mode for always-on services. - A connected MCP model. Codex, Claude Code, or another MCP client can lease an external AI transition, receive its prepared context and prompt, perform the reasoning with its own model, and return the result to the normal token flow. The client supplies intelligence while Agentic-Nets retains state and control.
- An unattended CLI-backed agent session. An agent transition can start a headless Claude Code or Codex session. This is useful when the persona needs a longer tool-using session, for example a developer working in a repository, while the net still owns the task, boundaries, and result.
- A one-shot command transition. A command lane can feed a bounded prompt to a headless CLI and capture structured output. It can also execute an ordinary program, script, build, test, or administrative command with no LLM provider at all.
This matters especially in Desktop Lite. A newcomer can install the local application without Docker and without configuring a server-side LLM provider. They can connect the MCP client they already use, create a persona, and let that client execute selected AI work. If they later want unattended operation, the same model can use a CLI-backed agent or command lane. If they move to an always-on server, the conceptual model does not change.
The USP Is Historical Observability
A persona prompt can be copied into many products. A visual workflow can be drawn in many products. The harder problem is preserving a trustworthy account of autonomous work and making that account useful for improvement. This is where Agentic-Nets is different.
Every firing changes explicit state and contributes to an event-sourced history. Inputs, outputs, transition identity, timing, failure, retry, and provenance can be analyzed later. The current token marking shows where work is now. The event trail explains how it arrived there. Structured status summarizes machine-readable progress. Protocol turns important milestones into a readable operational narrative inside the product, so a team does not need to use a forum thread as its primary reporting surface.
That creates two levels of truth:
- Protocol for people: what the team accepted, decided, completed, blocked, reviewed, and released.
- The event trail for evidence: the complete sequence underneath the narrative, available for audit, replay, metrics, and diagnosis.
Observability is therefore not only an operations screen. It is the memory required to optimize a persona or a whole process. Which context produced fewer revisions? Which reviewer catches failures earlier? Where does work wait? Which tool call is expensive? Which handoff causes rework? Did the new persona version improve quality without increasing cycle time? Those questions require structured historical evidence, not a folder of chat transcripts.
From Execution to Evidence-Based Improvement
The full product loop is not “ask an agent and hope.” It is a controlled cycle:
The Model Steward is the domain-neutral reviewer for this loop. It can inspect the current model, its nets, active and historical processes, event evidence, risks, bottlenecks, and optimization opportunities. Its default role is advisory and read-only. It should explain the evidence, propose a change, and make the expected benefit measurable. It should not silently edit the production model.
After approval, a changed persona, prompt, context package, tool, or net can be versioned and tested. Historical runs provide a baseline. New runs provide comparison data. Repeated successful reasoning can then be crystallized: stable parts move from expensive, variable AI judgment into deterministic map, pass, HTTP, command, or tool-net behavior. AI remains where judgment is valuable. Routine behavior becomes cheaper, faster, and easier to verify.
The Safe Product Team Is an Example, Not the Boundary
The first complete template is the Safe Product Team. It combines a Product Manager, Architect, Developer, Reviewer, Release Guardian, and Chronicle with a deterministic delivery backbone. Repository policy is explicit. Review and release effects are gated. Work writes structured status and meaningful Protocol milestones. The team can use a server model, a connected MCP client, or CLI-backed coding work depending on how it is deployed.
This is a useful example because it demonstrates planning, judgment, command execution, review, approval, reporting, and durable history in one system. It can become a reusable NetHub template that asks for deployment-specific bindings such as repository URL, target branch, workspace, test command, release policy, credentials, and reporting destination during installation. The portable package contains the team and its process. The installation profile supplies the environment.
But software delivery is only one domain. The same structure can describe:
| Persona or team | Typical net | Evidence to improve |
|---|---|---|
| Research analyst | Question → source collection → synthesis → evidence review → brief | Source quality, unsupported claims, review revisions, time per finding |
| Health coach | Goal → plan → check-in → reflection → escalation when outside scope | Adherence, useful interventions, missed check-ins, boundary escalations |
| Support team | Intake → classify → resolve or escalate → verify → follow-up | Wait time, reopen rate, escalation quality, recurring causes |
| Operations steward | Signal → diagnose → propose action → approve → execute → verify | False alarms, recovery time, failed actions, approval latency |
| Compliance reviewer | Case → gather evidence → assess policy → human decision → record | Evidence completeness, exceptions, decision consistency, audit history |
| Knowledge curator | Capture → classify → link → validate → publish → revisit | Stale context, duplicate concepts, retrieval quality, disputed links |
Link transitions and context nets make these systems more than isolated pipelines. A persona can connect a finding to a policy, a decision to its evidence, an incident to a prior lesson, or a product requirement to the code and release that implemented it. Over time the model becomes a living operational knowledge graph whose links are part of the process, not an afterthought.
NetHub as a Library of Operating Patterns
A useful platform should not force every newcomer to start with an empty canvas. NetHub is intended to distribute complete, inspectable operating patterns: individual personas, agent teams, nets, context systems, tool nets, tools, catalogs, models, and their dependencies. Credentials are environment bindings, not template content.
The Safe Product Team and Model Steward are strong first templates, but a starter library should also teach the core execution patterns in small pieces:
- Single guarded persona: one specialist with task, context, tools, result, and an approval boundary.
- Headless CLI reviewer: a canonical command token invokes Claude Code or Codex in read-only mode and returns a structured review.
- Human approval gate: autonomous preparation followed by an explicit wait before a consequential action.
- Context curator: captures, validates, links, and ages domain knowledge for other personas.
- Model Steward: reviews a complete model and recommends measurable improvements without changing it.
- Crystallizer: identifies repeated successful reasoning that can become a deterministic tool net.
- Scheduled operator: wakes on a schedule, evaluates state, acts within policy, reports, and returns to waiting.
These templates also give MCP clients a conceptual vocabulary. Instead of exposing a long catalog of unrelated tools, the MCP server can propose a starter pattern, explain its safety boundary, install or create the required artifacts, bind local resources, and then help the user inspect the resulting history.
What Agentic-Nets Does Not Promise
A domain-general runtime is powerful because its primitives are reusable, not because every process should be fully autonomous. High-risk work still requires validated data, qualified oversight, appropriate security, and domain-specific controls. Some decisions should always remain human. Some tools should never be available to an AI persona. Some proposed optimizations should be rejected.
Agentic-Nets is designed around that reality. Capability profiles and resource scopes limit access. Approval places make waiting explicit. Vault-backed credentials separate secrets from definitions. Remote executors can remain egress-only. Changes can be proposed, reviewed, versioned, verified, and compared. A so-called self-learning net should mean a governed system that learns from evidence and evolves through controlled changes, not a production process that silently rewrites itself.
Try Desktop Lite
Desktop Lite is the fastest way to try the persona-first experience locally. It bundles the Agentic-Nets services and tray application, runs on the local machine, and does not require Docker or a server LLM provider. Connect Codex, Claude Code, or another MCP client, choose a starter pattern, and create a persona or team whose work remains visible in the net.
Always-current release page: download the latest AgenticNetOS release from GitHub. At publication time the current version is v2.43.0.
- macOS for Apple Silicon, DMG
- Windows x64, MSI
- Debian or Ubuntu amd64, DEB
- Debian or Ubuntu arm64, DEB
- Fedora or RHEL amd64, RPM
- Fedora or RHEL arm64, RPM
Verify downloads with SHA256SUMS.txt and its signature. Browse all releases when a newer version is available.
The public repository, source components, deployment files, MCP server, and technical documentation are at github.com/alexejsailer/agentic-nets. The product documentation is at agentic-nets.com. For a wider map of systems that fit this backend, read Agentic-Nets Is a Backend, Not a Demo.
The Product Direction in One Sentence
Begin with a persona people understand, make its autonomous process explicit in a net, preserve every important step as evidence, and use that evidence to improve the next version safely.
That is the role of Agentic-Nets. It is not only a designer for agent workflows, and it is not limited to a software team example. It is a domain-general backend for long-lived autonomous processes whose state, authority, history, and evolution remain under control.