What is the Paranet
The internet moves packets. It does not move work.
Apps, Application Programming Interfaces (APIs) and Software as a Service (SaaS) are all workarounds for that limit: stateless connections between fixed addresses, wired together by hand, brittle the moment anything changes. The Paranet is a new layer over the top of the stack you already run — built to move work between people, machines and organizations.
Anatomy of an intelligent network
Four pieces, each one zooming out from the last.
Actor, node, network, federation. Everything else on this page expands one of these four.
A new layer, not another app
Layer 8. Nothing below it is replaced.
The Paranet sits above the seven layers of the Open Systems Interconnection (OSI) model — a “Layer 8” that overlays what you already run. Your networks, your applications and your data stay where they are. What changes is how work moves between them.
Actors, skills, conversations, compiled plans
Four for four
| Built for documents | Built for work | |
|---|---|---|
| Who takes part | Apps at fixed addresses | Actors — participants with goals and memory |
| What they offer | APIs, wired by hand | Skills — matched when they are needed |
| How they talk | Hypertext Transfer Protocol (HTTP) calls | PnCP — the Paranet Collaboration Protocol |
| What they remember | Nothing between calls | Persistence — every conversation, every step |
Everything becomes an actor
A participant, not an endpoint.
Software, hardware, an AI model, a person — each is wrapped in a thin layer that gives it goals, plans, tasks, decisions, events and memory. An actor knows what it is trying to do, remembers what has happened, and can reason about what to do next.
Actorizing an existing system does not touch its internals. The wrapper registers what the system can do, and the system’s intellectual property (IP) stays its own.
The actor wrapper
Anything can be actorized
Adding an actor is modular, with zero disruption — the network gets smarter, nothing gets rebuilt.
Skills
Capabilities, not connections.
Actors declare skills. A skill is a discrete capability, named by a subject and an action, with a typed contract — for example airport / book_slot_for_window. Actors declare what they can do, not where they live. More than one actor can offer the same skill, and that inversion is the seed of everything else.
Skill matching
Work is matched, not wired.
An actor that needs something done does not call an address. It issues a skill request, and the node’s broker matches it to an actor qualified to fulfill it, at that moment. Providers can join, leave, upgrade or fail, and the match simply resolves differently. An actor that is offline never matches, and selection can weigh quality-of-service history and current load.
Conversations, not calls
The protocol is plumbing. The conversation record is the point.
Requests, responses, status updates and questions are grouped into conversations that persist over PnCP. Every message is recorded in a durable ledger — who asked, who answered, what happened — so the network is auditable by construction, in real time and after the fact.
Compiled AI · goal trees
You know what will happen before it happens.
Workflows compile into goal trees before they run. Generative AI is used up front, to build and validate the workflow; at runtime the plan executes as compiled code, so it runs the same way every time, at a small fraction of the cost of asking a language model to reason from scratch.
Execution is two-phase: the full plan exists, and can be reviewed, before anything happens. When a step fails, the tree re-plans with substitute tasks. When judgment is needed, a person steps in.
Generative AI is the brain, the goal tree is the rulebook, and the Paranet binds the two.
Illustrative scenario.
Programming the Paranet
A rule’s output is a plan, not execution.
Workflows are written in Paraflow, a small domain-specific language with four ideas. Rules have no side effects, so the whole plan can be inspected before anything runs — determinism is a property of the language, not a policy. Plans can depend on live data and still be plans: a forall over a table expands into parallel sub-goals before execution.
Goals
Name a desired outcome.
Rules
Break a goal into sub-goals, producing a plan.
Tasks
The leaves that do the work, often by requesting another actor’s skill.
Events
How the outside world — including incoming skill requests — starts new goals.
And it starts with the code you have: a Python or TypeScript function becomes a skill with a decorator. See the developer on-ramp →
Inside a node
Anatomy of a node.
Self-contained: everything a node needs, wherever it runs. Each node manages its own actors and its own state — no central server, no shared database.
One Paranet node
No center to fail
No central workflow server, no shared database — each node is complete on its own.
Runs where the work is
Cloud, on-premise, or at the edge — the same node, the same behavior.
Restart and resume
State is local and persistent — a node that restarts picks up exactly where it left off.
A network of networks
Organizations federate deliberately — and directionally.
The carrier can request slots from the airport.
The airport can never reach into the carrier.
Public and private paranets coexist
A federation of networks — each organization runs its own nodes and federates only what it chooses.
Network groups
Skills are segmented by group — a request only routes to actors the requester is entitled to use.
Exactly the skills you choose
Nothing else is exposed. No central brain, no shared database, no disintermediation.
Humans are actors too
Escalation is a step, not an exception.
When an automated actor reaches a step that needs human judgment, it shares exactly the slice of its session the person needs — permissioned, with the allowed inputs constrained. The person decides, the actor resumes, and the workflow never leaves the rails.
Security
Negative trust, not perimeter trust.
Every actor carries a certificate, only registered skills can be requested or performed, and access control applies to each skill request. Observers watch behavior continuously and can flag, pause or remove a misbehaving actor.
Go deeper
The whole architecture, one page at a time.
The architecture is defended by 17 patent assets — 9 issued, 8 pending — covering the actor network and skill matching, the deterministic execution pipeline, permissioned session replication, and a pending family around routing, delegation, private networks and the skill marketplace.
- How the Paranet works — the full technical walkthrough.
- Why the Paranet — why this matters now, and why travel first.
- Trust & guardrails — people in control, data in place.
- Developers — start with the code you have.
See the network move work, not just packets.
The platform is complete, and several prototypes are in operation. We will walk you through one against a problem you recognize.