# What is the Paranet

The Paranet is a new layer over the existing internet that moves work, not just packets: actors instead of apps, skills instead of APIs, conversations instead of calls, and compiled plans instead of runtime guessing.

## 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

1. **Actor** — a system, a device, a robot, an artificial intelligence (AI) model or a person, wrapped in software that gives it skills, goals and memory. The thing itself is untouched.
2. **Node** — actors belong to nodes. Every node carries the same five services: a broker, a skill matcher, a Paraflow interpreter, a certificate manager and a ledger.
3. **Network** — nodes form a network with no central workflow server and no shared database. Each node owns its own actors and its own state.
4. **Federation** — networks connect deliberately and directionally: one party can request a skill without the other being able to reach back.

## A new layer, not another app: Layer 8

The Paranet sits above the seven layers of the Open Systems Interconnection (OSI) model — a "Layer 8" that overlays what you already run. Nothing below it is replaced. Your networks, applications and data stay where they are; what changes is how work moves between them.

The contrast is 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.

## 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, and more than one actor can offer the same skill.

## 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 and 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 example: a carrier's goal is for a flight to land in its window. Rules expand the plan (slot, gate, ground crew) before anything runs; a skill request for `book_slot_for_window` is matched to a qualified airport actor; the requested window is unavailable, so a substitute task re-plans; a dispatcher approves the later window in one tap; the slot is booked, the crew re-timed, and every step is in the ledger.

## 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** are the leaves that do the work, often by requesting another actor's skill.
- **Events** are how the outside world — including incoming skill requests — starts new goals.

It starts with the code you have: a Python or TypeScript function becomes a skill with a decorator. See [Developers](https://www.otonoma.com/developers).

## 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 carries five services:

- **Broker** — routes every skill request; observes the node's actors.
- **Skill matcher** — finds the qualified, live provider for each request.
- **Paraflow interpreter** — runs the compiled goal trees; persists their state.
- **Certificate manager** — identity for every actor on the node.
- **Ledger** — the durable record of every conversation on the 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 (one way); status flows both ways, by agreement. 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. See [Trust & guardrails](https://www.otonoma.com/trust).

## Go deeper

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](https://www.otonoma.com/events/how-the-paranet-works) — the full technical walkthrough.
- [Why the Paranet](https://www.otonoma.com/why-the-paranet) — why this matters now, and why travel first.
- [Trust & guardrails](https://www.otonoma.com/trust) — people in control, data in place.
- [Developers](https://www.otonoma.com/developers) — start with the code you have.

The platform is complete, and several prototypes are in operation. [Request a demo](https://www.otonoma.com/demo-request) or [talk to us](https://www.otonoma.com/contact).