NeuroLang.
Write what you mean.

NeuroLang. NeuroNet. PNP Compute.

Three names, one spec. NeuroLang is the agentic-programming layer. NeuroNet is the AI training & inference layer. NSDK ships them all together.

Primitives general-purpose languages don't have.

NeuroLang surfaces what most languages bury — deliberation, cost, memory scope, effects, recovery — as first-class primitives.

A flow reads like a sentence.

Define neuros with declared effect and budget. Compose them with operators. Inspect the resulting flow. Run it. Replay it.

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

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

@neuro(effect="llm", budget=Budget(cost_usd=0.02))
def summarize(emails: list[Email]) -> str:
    """Produce a short paragraph summary."""
    ...

# A flow reads like a sentence
research_flow: Flow = (
    web.search                     # find candidate URLs
    | extract_book_metadata        # extract per URL
    | reason.summarize             # condense findings
    | memory_neuros.store          # save for later
)

# Inspect
research_flow.render(format="mermaid")
research_flow.cost_estimate()
research_flow.effect_signature()

# Run
plan = research_flow.plan(query="category theory")
result = plan.run(memory=Memory.discrete())

# Replay (deterministic)
plan.serialize()  # → plan.json
plan.replay()

High-quality neuros for the common surface.

Ships with neuros for web, voice, email, calendar, files, reasoning, code, memory, models, flows, and agents. They are not magic — they are well-typed neuros built from the same primitives as user neuros.

AI proposes a composition of typed primitives.

Not "let an LLM hallucinate code" — the AI sees the entire toolbox and composes intelligently. Every registered neuro carries its own docs, types, effects, and budget. The AI's prompt always has the live catalogue.

USER: "I need to write my thesis on microplastics in marine life.
       Help me build a research workflow."

AI: [searches registered neuros]

  Found these relevant neuros:
   • skill.reason.deep_research  (multi-source synthesis)
   • skill.web.scrape            (extract from URLs)
   • skill.web.search            (semantic + keyword)
   • skill.code.read             (read citation BibTeX)
   • skill.reason.summarize      (compress long text)
   • skill.reason.brainstorm     (divergent ideation)
   • memory.store                (save findings)
   • agent.delegate              (sub-agents per chapter)

  Proposed flow:

    brainstorm_outline
      | for_each_section (
          web.search | web.scrape | reason.summarize | memory.store
        )
      | reason.deep_research
      | code.write_bibliography

  Estimated cost: $1.20–$3.40
  Estimated time: ~20 min for first draft outline.

  Want me to:
   (a) Generate as Python and run it now
   (b) Save as a reusable 'thesis_research' neuro
   (c) Modify the flow first

This is what natural-language coding actually means.

Temporary or permanent.

When the AI generates a neuro, it can choose: ephemeral, session-scoped, project-scoped, or persistent. Defaults make the right choice for you.

Voice is just an effect.

Every neuro can opt into a voice surface with effect="voice". The standard library wires LiveKit, Twilio/Plivo, ElevenLabs, OpenAI TTS, Whisper, Deepgram, Sarvam — adapters, not magic.

@neuro(effect="voice")
def voice_call(number: str, prompt: str) -> CallResult:
    """Initiate a voice call and conduct the conversation per `prompt`."""
    ...

# A voice flow is just a flow
incoming_call = receive_call | transcribe | classify_intent | dispatch_agent

The IDE shows voice neuros with a cyan highlight; runtime view shows live waveforms in NeuroNet.

vs LangChain · DSPy · Pydantic AI.

We don't pick a fight with all three at once. We complement Pydantic AI's typing rigour, extend DSPy's compositional ideas, and replace LangChain's untyped chains with a categorically grounded equivalent.

Library first. NL compiler next. IDE after.

Aggressive but achievable. Phase 1 is shipping. Phase 2 starts when reviewer trust is earned.

Vendored. Ready.

NeuroLang ships inside the PNP Compute repo at ./neurolang/. Editable install picks it up automatically.

# GitHub repo — coming soon
cd neurosdk
python3 -m venv .venv && source .venv/bin/activate
pip install -r neurosdk/requirements.txt
pip install -e ./neurolang   # vendored framework

# Use the nl_dev agent to author flows in natural language
python neurosdk/server.py             # http://127.0.0.1:7000
cd neuro_web && npm run dev                # http://localhost:3000
# switch to the nl_dev agent in the dropdown