One spec for AI training & inference, agentic programming, and general software. Everything is a typed, composable unit called a neuro — implemented by NSDK.
The same spec describes a neural network, an agent, and a CRUD app — because each is just a graph of typed units.
Grammar-typed models where every weight is a named mathematical operation. The model learns which operation to use — and you can read which fired for any input. Auditable, updatable, interpretable.
A typed Python DSL for composing agents. Typed primitives, composition operators, plans as values. Write agents like sentences — inspect, cost-estimate, and replay them.
The same unit — a neuro with conf.json, code.py, prompt.txt — describes a skill, a service, a workflow, or a whole product. Generic and agentic code share one substrate.
A neuro is a typed, composable runtime unit with identity, behaviour, and an optional language surface. The same shape covers thinking, planning, tool use, memory, model invocation, and behaviour policy.
A neuro folder declares its identity in conf.json, its behaviour in code.py, and an optional prompt surface in prompt.txt. The factory hot-discovers folders at runtime — drop one in, the runtime sees it.
There is no atomic level you must reach. Composites are first-class — a neuro can itself be a graph of neuros. The framework is fractally compositional.
Ten first-class neuro classes. Each has a base type, a folder convention, and a place in composition. Together they form the framework's vocabulary.
core/model_neuro.py, core/llm_registry.py.core/prompt_neuro.py.core/instruction_neuro.py.core/context_neuro.py.core/memory.py, core/memory_graph.py.core/flows/.core/agent_neuro.py.This is why the framework is language-like. It has vocabulary (kinds and namespaces), grammar (composition operators), semantics (typed contracts), runtime (factory + brain + executor + event bus), and a standard library (built-in neuros and reusable domain libraries).
NeuroLang is the agentic-programming layer of the spec. Primitives carry typed contracts — effects, budget, memory scope. Compose them with operators. The result is a structured plan you can inspect, cost-estimate, and replay.
Every neuro carries its own contract — types, effects, budget, docstring. Compose them with |. Get back a Flow — a plan you can render, cost-estimate, and run.
Where the flow is differentiable it's a tensor network. Where it's symbolic it's a string diagram. Same object, no translation.
Standard networks are opaque by design. NeuroNet makes weights auditable by building the model from named, fixed mathematical operations. The network learns which operations to use, not what the operations should be.
The model routed through jal_s1 → jal_s4 → jal_s4 — first- then fourth-order finite differences. That's a readable mathematical statement: "divisibility patterns change at multiple scales." Not post-hoc. Intrinsic.
Add new knowledge with one line — no retraining, no catastrophic forgetting. The grammar grows like a living knowledge system.
The framework is computationally universal in direction. It supports state, branching, iterative execution, unbounded composition, and external I/O. General computation is expressible through neuro composition — not just prompt chaining.