# Developers

Start with the code you have: a Python or TypeScript decorator turns a function into a skill, Paraflow goal trees orchestrate the work, and a node runs it — locally or in your cloud.

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

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

Example (Python):

```python
@actor.actor
class Ticketing(BaseActor):

    @actor.skill(subject="ticketing", response=TaskStatus)
    def create_ticket(self, cell: int, conv: Conversation):
        # your existing code, unchanged
        ...
```

## Paraflow and 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** are the leaves that do the work, often by issuing a skill request to another actor.
- **Events** are 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

Identity, permissions and monitoring are properties of every actor and every request. See [Trust & guardrails](https://www.otonoma.com/trust).

- **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 25 September 2025. The architecture is the same; some of the tooling shown has moved on since. Video: [Otonoma Alpha Developer Release](https://youtu.be/8riZs0YFKWI).

## Go deeper

For the full architecture, read [the full technical walkthrough](https://www.otonoma.com/events/how-the-paranet-works) or [What is the Paranet](https://www.otonoma.com/what-is-the-paranet).

## Frequently asked questions

**What is the Paranet, for a developer?**
A network of actors — software, hardware, AI models and people — that declare skills and request them from each other. You expose existing code as skills with a decorator, orchestrate them with Paraflow goal trees, and run them on a node. Work is matched to a qualified actor at the moment it is needed rather than wired to a fixed address.

**Do I have to learn a new language?**
Only for the orchestration. The code that does the work stays in Python or TypeScript, with the packages you already use. Paraflow is small by design: goals, rules, tasks and events.

**How is this different from calling an Application Programming Interface (API)?**
An API call goes to an address. A skill request goes to the network, which matches it to a qualified actor, at that moment, weighing availability and load. Requests, responses and status updates are grouped into persistent conversations and recorded in the ledger, so long-running work survives failures and every step can be audited.

**Where do nodes run?**
Anywhere the work is. Docker for local development, Kubernetes for production, in a cloud, on-premise or at the edge. Each organization runs its own nodes and chooses exactly which skills to share with other networks.

**How do I get started?**
Request access with the form at [otonoma.com/developers](https://www.otonoma.com/developers#early-access). We are working with a small number of developer teams and will be in touch as we expand access.

## Building for a business?

We will walk your team through a working prototype. [Request a demo](https://www.otonoma.com/demo-request) or [talk to us](https://www.otonoma.com/contact).