Developers
Start with the code you have.
Nobody rewrites their stack to join the Paranet. A decorator turns an existing Python or TypeScript function into a skill; Paraflow orchestrates the work above it; a node runs it all, on your laptop or in your cloud.
The on-ramp
One decorator, and a function becomes a skill.
Wrap the code you already run. The decorator registers what it can do — a subject, an action and a typed contract — and any actor entitled to that skill can now request it. The wrapped code does not change.
- Keep your language, your package managers and your repositories.
- Actors declare what they can do, not where they live, so providers can be swapped, upgraded or scaled without rewiring anyone.
- The same actor code runs against a simulation and against the real system.
@actor.actor
class Ticketing(BaseActor):
@actor.skill(subject="ticketing", response=TaskStatus)
def create_ticket(self, cell: int, conv: Conversation):
# your existing code, unchanged
...Paraflow · goal trees
A rule’s output is a plan, not execution.
Orchestration is written in Paraflow, a small declarative language with four ideas. Rules have no side effects, so the full plan exists — and can be inspected — before anything runs. Generative artificial intelligence (AI) can help build and validate a workflow up front; at runtime the compiled plan executes deterministically, and re-plans with substitute tasks when a step fails.
Goals
Name a desired outcome.
Rules
Break a goal into sub-goals. A forall over live data expands into parallel sub-goals before execution.
Tasks
The leaves that do the work, often by issuing a skill request to another actor.
Events
How the outside world, including incoming skill requests, starts new goals.
Run a node
Local while you build. Anywhere when you ship.
A node is a self-contained deployment — broker, skill matcher, Paraflow interpreter, certificate manager and ledger. Run one locally in Docker while you develop, then deploy the same node to Kubernetes in your cloud, on-premise or at the edge.
- Written in Rust with a small footprint, so it fits on edge hardware as well as in a cluster.
- Resumes where it left off after a restart: state is persisted, not rebuilt.
- No central server, no shared database. Each node owns its own actors and state, and federates only the skills you choose.
- Every conversation in the ledger — who asked, who answered, what happened — for debugging and audit.
- Works with what you already run. Message Queuing Telemetry Transport (MQTT), Robot Operating System 2 (ROS 2), Kafka or Redis stay in place; an actor sits in front of them.
Security
Negative trust, built into the platform.
You do not bolt security on afterwards. Identity, permissions and monitoring are properties of every actor and every request.
- Certificates. Every actor carries one; identity is verified, not assumed.
- Registered skills only. Nothing can be requested or performed unless it has been declared.
- Skill-level access control. Permissions apply to each skill request, and skills can be segmented by network group.
- Observers. Invisible to the actors they watch, they can flag, pause or remove a misbehaving actor.
- Taint tracking in the language, so untrusted input is followed through a workflow.
From the archive
The 2025 alpha developer release.
Our first developer release, recorded in September 2025. The architecture is the same; some of the tooling shown has moved on since.
For the full architecture — actors, skill matching, conversations, nodes and federation — read the full technical walkthrough or What is the Paranet.
Otonoma Alpha Developer Release
The 2025 alpha release of the developer tools, recorded 25 September 2025.
Frequently asked questions
What is the Paranet, for a developer?
Do I have to learn a new language?
How is this different from calling an Application Programming Interface (API)?
Where do nodes run?
How do I get started?
Request developer access
Building for a business rather than a side project?
We will walk your team through a working prototype against a problem you recognize.