PNP Compute ← Back to slides
● Open source · pre-alpha

Programmable
Intelligence.

PNP Compute is the IDE + runtime for NeuroLang — a Python framework where every capability is a typed, composable neuro. From a single skill to a full agency, on one substrate.

PNP Compute · Pitch Deck
/// Status quo

Agent frameworks today, three pathologies.

No compositional reasoning

A flow's behaviour cannot be derived from the behaviour of its parts. Glue code is opaque.

Untracked side-effects

Agents write to mailboxes, billing, prod code without surfacing the capability boundary.

Opaque planning

The "decision" lives inside an LLM context window — irretrievable, irreproducible, unverifiable.

These are not accidents. They are inevitable when you build agents on substrates that erase compositional structure.

PNP Compute · Pitch · 2 / 12
/// The Trinity

Three names. One system.

NeuroLang

The Python library. Typed primitives, composition operators, plans as values.

NeuroNet

The program. A composed network of neuros — authored in NeuroLang, runnable, shareable, installable. The apps are NeuroNets.

PNP Compute

The IDE + runtime fused — like a Lisp Machine. Authoring, execution, and visualisation in one continuous environment.

NeuroLang is the language. NeuroNet is the program. PNP Compute is the environment.
PNP Compute · Pitch · 3 / 12
/// The unit

A neuro is the universal unit.

A typed, composable runtime unit. Identity, behaviour, optional language surface. The same shape covers thinking, planning, tool use, memory, model invocation, and behaviour policy.

Drop a folder in; the runtime sees it. No restart. Hot-loadable. Validated. Versionable.

neuros/extract_book/
├── conf.json    # contract
├── code.py      # behaviour
└── prompt.txt   # optional
PNP Compute · Pitch · 4 / 12
/// Authoring feel

A flow reads like a sentence.

from neurolang import neuro, Flow, Memory
from neurolang.stdlib import web, reason

@neuro(effect="tool")
def extract_book(url: str) -> dict:
    """Scrape title, author, summary."""
    ...

research: Flow = (
    web.search
    | extract_book
    | reason.summarize
    | memory.store
)

plan = research.plan(query="category theory")
plan.cost_estimate()    # budget rolled up
plan.run(memory=Memory.discrete())
plan.serialize()        # inspect, replay
PNP Compute · Pitch · 5 / 12
/// Hierarchy

Agency. Project. Agent. Neuro.

Agency

Workspace + team. Color, emoji, agents.

Project

Unit of work inside an agency.

Agent

Role orchestrator with router + planner + replier + profile.

Neuro

Atomic capability. Hot-loadable.

Four layers. Each groups the next. Scale from one capability to a full agency without changing the model.

PNP Compute · Pitch · 6 / 12
/// Capabilities

A complete substrate.

Voice

STT/TTS over LiveKit. Sub-second round trip.

3D IDE

Graph-native authoring with R3F.

Meeting Rooms

Multi-agent transcripts with mediation.

Scheduler

Cron triggers persisted in SQLite + APScheduler.

agent.talk

Direct typed agent-to-agent messages with depth guard.

Mobile

Android remote with WebRTC desktop streaming.

PNP Compute · Pitch · 7 / 12
/// Multi-Agent

Agents that work together.

Meeting Rooms. Multiple agents share a transcript with a mediator picking the next speaker round-robin.

agent.talk. Direct typed messages between agents. Depth-guarded (MAX=4) — the substrate beneath rooms.

Schedules. Cron-style triggers. "Every morning at 8 send me the summary" — handled by the runtime.

┌──────────────────────────────────┐ │ ROOM (room_id) │ │ ┌──────┐ ┌──────┐ ┌────────┐ │ │ │ NL │ │ Open │ │ neuro │ │ │ │ Dev │ │ Code │ │ │ │ │ └──┬───┘ └──┬───┘ └───┬────┘ │ │ └────────┼─────────┘ │ │ ▼ │ │ room_mediator │ │ • routes msgs │ │ • picks next │ └──────────────────────────────────┘
PNP Compute · Pitch · 8 / 12
/// Why different

Architecture, not features.

CapabilityLangChainDSPyPydantic AINeuroLang
Plans as first-class values———✓
Effects in types——partial✓
Budget annotations———✓
Recovery as primitivelibrarylibrarylibrarylanguage-level
Bidirectional NL ↔ code—partial—cached adjunction
Categorical / 3D viz———✓
PNP Compute · Pitch · 9 / 12
/// Vision

The pathway to AGI.

1. Software — Hardcoded logic and rigid rules.
2. Statistical ML — Probabilistic pattern recognition.
3. Generative Models — Transformers predicting tokens (LLMs).
4. Reasoning Models — Chain-of-Thought, plan, execute.
5. Agentic Systems — Autonomous observe-reason-act loops.
6. Agency AI (the Neuro Vision) — Hierarchical, modular agencies. Abstract, modifiable, infinitely scalable.
PNP Compute · Pitch · 10 / 12
/// Status

Where we are.

295+
Built-in neuros
5
Specialised agents
172
NeuroLang tests passing
∞
Compositions

Shipping

  • NeuroLang Phase 1.9 — library + 17 stdlib neuros + agent.delegate
  • Multi-agent: rooms, talk, schedules
  • 3D Neuro IDE backend wired
  • Voice agent over LiveKit

Next

  • Phase 2: NL compiler with cached bidirectional adjunction
  • JAX backend for differentiable flows
  • Hyperdimensional substrate
  • Web 3D IDE (Phase 3)
PNP Compute · Pitch · 11 / 12
/// Open source

Build something composable.

Pre-alpha. APIs unstable. Bones in place. Trinity taking shape. The right Python library + the right authoring surface for agentic coding.

GitHub · coming soon pnpcompute.com
PNP Compute · Pitch · 12 / 12