NEOS
The Operating System for Machine Intelligence
"The last operating system will not manage files. It will manage meaning."
samuele95.github.io/papers/neos
Open with impact. Pause on the tagline — let it land. This is the thesis of the entire presentation.
01 — The Grand Narrative
The Three Ages of Computing
Three Ages of Computing Timeline
Hardware
1950s–1980s
Bottleneck: Physical
OS: Share the machine
Interface: Punch cards → CLI
Software
1980s–2020s
Bottleneck: Complexity
OS: Organize programs
Interface: GUI → Touch
Intelligence
2025+
Bottleneck: Meaning
OS: Organize thinking
Interface: Language → NEOS Shell
Each transition changes the nature of the bottleneck .
Each age changed not just capability but what the bottleneck IS. Hardware → physical limits. Software → complexity. Intelligence → meaning itself.
01 — The Shift
Three Bottlenecks, Three Eras
Hardware
The CPU was sacred. Every cycle scheduled, every byte managed. OS answer: "How do we share this machine?"
Software
Complexity became the enemy. Files, processes, threads — abstractions for managing code. OS answer: "How do we organize programs?"
Intelligence
The challenge is semantic . How do you represent ideas? Track interpretations? Merge reasoning? OS answer: "How do we organize thinking?"
We don't need a better programming language. We need to stop programming — and start reasoning .
Key punchline: the OS question changed at each stage. NEOS answers the third question.
02 — The Vision
The Inversion
The Architectural Inversion
Today
Applications
LLM App
Operating System
Hardware
⇒
Inversion
Tomorrow
Human
NEOS
LLM (Foundation)
Today the LLM is an app . Tomorrow the LLM is the foundation . NEOS is the OS layer.
The fundamental architectural insight: LLMs move from application layer to foundation layer. NEOS sits between human and LLM.
02 — The Vision
What NEOS Replaces
No File Systems
Semantic fields organize information by meaning. You don't navigate directories — you navigate ideas.
No Compiled Binaries
Field configurations execute reasoning. A "program" is a pattern of activated concepts.
No Separate Apps
Task definitions compose into workflows. Analysis, creativity, planning — field configurations, not executables.
No GUIs
Natural language + the NEOS shell . Language for fluidity. Shell for precision.
Each replacement is a conceptual leap. Files → semantic fields. Binaries → field configs. Apps → tasks. GUIs → language.
03 — Architecture
The Three Pillars
Three Pillars of NEOS
Neural Fields
THE SUBSTRATE
Continuous activation
Resonance dynamics
Attractor emergence
Persistence via resonance
Symbolic Reasoning
THE STRUCTURE
nf command algebra
@pattern references
$field references
Composable transforms
Quantum Semantics
THE INTERPRETATION
Superposition of meaning
Non-commutativity
Observer-dependent collapse
Context as measurement
Ψ — The Unification
Remove any pillar and the system cannot represent , manipulate , or interpret meaning.
Three pillars are individually necessary, jointly sufficient. Fields = substrate. Symbols = structure. Quantum = interpretation.
04 — The Core
The Neural Field Equation
∂A/∂t = -λA(x) + α∫K(x,y)A(y)dy + ι(x,t)
-λA(x)
Decay
Unreinforced ideas fade. Forgetting is a feature .
α∫K(x,y)A(y)dy
Resonance
Related ideas strengthen each other through the kernel K.
ι(x,t)
Injection
You — the human — inject new ideas at any time.
Patterns don't sit in memory — they live in a continuous field.
This is THE equation. Decay, Resonance, Injection — the three forces. Everything NEOS does derives from this.
05 — The Analogy
The JVM Moment
Java: "Write once, run anywhere." — NEOS: "Think once, reason anywhere."
JVM vs NEOS Architecture Comparison
JVM
NEOS
JIT Compilation
Adaptive Resonance
Threads
Multi-Field
Heap Memory
Field State
Garbage Collection
Decay (λ)
ClassLoader
Pattern Injection
Java abstracted hardware. NEOS abstracts cognition.
Every JVM concept has a NEOS parallel. Garbage collection → decay. Heap → field state. The analogy runs deep.
07 — The Interface
The NEOS Shell
A REPL for the Intelligence Age — manipulating meaning , not files.
neos-shell
$ nf inject "correctness" 0.90 [INJECT] correctness (s: 0.90 ) — p001
$ nf inject "edge_case_handling" 0.85 [INJECT] edge_case_handling (s: 0.85 ) [RESONANCE] ↔ @correctness: R = 0.82 STRONG
$ nf cycle 3 --trace [CYCLE 3] [ATTRACTOR-EMERGED] "defensive_quality" Coherence: 0.71 | 6 patterns
$ nf inject "singleton" 0.65 ⚠ LOWEST ACTIVATION IN HISTORY | 0 STRONG resonances Lateral inhibition: 4 patterns suppressing
Walk through each command. inject seeds meaning, cycle runs dynamics, attractors emerge. Then inject Singleton — the field's immune system rejects it. Four patterns suppress it through lateral inhibition. The dynamics DISCOVERED the anti-pattern.
07 — Commands
Six Command Domains
Operations
inject amplify attenuate tune collapse resonate
Dynamics
cycle evolve step reset
Measurement
measure attractor basin state
Visualization
plot animate export
Versioning
commit branch checkout diff merge
Autonomy
mode checkpoint proceed task
Unix-flavored grammar. Imperative verbs on semantic objects.
If you know bash, you know the grammar. The difference is you're operating on meaning, not files.
06 — Dynamics
The Six-Phase Cycle
Each nf cycle executes six phases — the heartbeat of NEOS.
Six-Phase Dynamics Cycle
CYCLE
1. Decay
-λA(x)
2. Resonate
K(x,y)
3. Amplify
+α·boost
4. Threshold
A < τ → remove
5. Coherence
μ/(1+σ²)
6. Attractor
detect & record
The cycle is the core loop. Each phase has a precise mathematical operation. Decay → resonance → amplify → threshold → coherence → attractor detection.
07 — The Pipeline
Create → Compile → Run
CREATE
nf inject seeds patterns into the field — like writing source code, but for meaning.
COMPILE
nf collapse --strategy attractor resolves superposition into coherent structure. Meaning compiles into insight.
RUN
nf task "analyze security" executes against the compiled field state. Crystallized reasoning produces output.
NEOS Pipeline: Inject → Cycle → Collapse → Task
nf inject
→
nf cycle N
→
nf collapse
→
nf task
The same three-phase model as traditional computing: create/compile/run. But operating on meaning, not code.
06 — Multi-Field
Multi-Field Orchestration
Multi-Field Orchestration Network
Technical
C=0.80
Business
C=0.81
User
C=0.83
Synthesis
C=0.85
A single field is powerful. Multiple coupled fields are transformative .
Multiple fields can process the same domain from different perspectives, then synthesize via resonance-weighted fusion.
14 — AI Safety
The Autonomy Dial
NEOS's answer to AI alignment: a continuously adjustable dial .
Autonomy Dial: Step → Checkpoint → Auto
S
Step
Review every op
C
Checkpoint
Pause at conditions
A
Auto
Full autonomy
Step Mode
nf mode step — review and approve each operation. Maximum human control.
Checkpoint
nf checkpoint "coherence > 0.8" — pause when conditions met. Targeted oversight.
Auto Mode
nf mode auto — full field autonomy within parameters. Iterate to convergence.
AI alignment isn't binary. NEOS gives you a continuous dial: from full human review to full autonomy. You control exactly how much oversight.
15 — Transparency
Observable Reasoning
The most dangerous property of current AI is opacity . NEOS makes reasoning visible.
Coherence Plot
nf plot coherence
Resonance Network
nf plot network
Basin Topology
nf plot topology
Dynamics Animation
0.85
0.72
nf animate
Four visualization tools let you SEE how reasoning unfolds. Coherence plots, networks, topology maps, and real-time animations. No black boxes.
11 — Timing
Why Now?
Four convergences make NEOS possible — and necessary — today .
Four Convergences: Why NEOS Now
LLM Capability Explosion
Agent Fragmentation
The Prompt Ceiling
Open-Weight Models
NEOS
Successfully tested with Claude Code , Gemini CLI , and OpenCode (Minimax)
LLMs are capable enough to be the foundation. Agent frameworks are fragmenting. Prompt engineering has hit its ceiling. Open models make it deployable. The window is now. NEOS has been validated across Claude Code, Gemini CLI, and OpenCode with Minimax model.
13 — Versioning
Git for Thinking
Git transformed code development. NEOS transforms thinking .
Git for Thinking: Branch and Merge Reasoning
merge
commit
alternative reasoning
main
branch "what-if"
nf commit "hypothesis validated"nf branch "alternative"nf diff main..alternativenf merge alternative
Branch reasoning paths. Explore alternatives without destroying progress. Diff between perspectives. Merge the best of both.
Version control for reasoning. Branch to explore alternatives. Diff to compare perspectives. Merge to synthesize. All without losing any state.
08 — Proof
The Software Quality Session
A real session that ran to completion in NEOS.
What NEOS discovered was not a summary — it was emergent structure that no single injection contained.
These numbers are real. 69 patterns in, 52 cycles, 0.993 coherence. One pattern — Singleton — was EXPELLED. Not by us. By the field dynamics.
08 — Wave 1
Defensive Quality Emerges
6 patterns → 3 cycles → first attractor. Coherence: 0 → 0.71
Injections
p001 correctness 0.90
p002 edge_case_handling 0.85
p003 security 0.95
p004 input_validation 0.90
p005 no_leaked_secrets 0.88
p006 error_handling 0.80
Coherence Trace
Cycle 1: C = 0.42 &bar;R = 0.72
Cycle 2: C = 0.58 &bar;R = 0.75
Cycle 3: C = 0.71 &bar;R = 0.78
ATTRACTOR "defensive_quality"
Peak resonance: @security ↔ @input_validation = 0.91 Two clusters formed: security (R=0.79–0.91) and logic (R=0.72–0.85)
Six patterns self-organized into an attractor in only 3 cycles. The security cluster and logic cluster formed and connected through bridge nodes. HIGH coherence from minimal input.
08 — Waves 2–3
Breadth & Refactoring
Wave 2 (p007–p014): 8 patterns expand beyond review. Wave 3 (p015–p022): refactoring discipline.
Key Patterns
readability_6month_rule
single_responsibility
api_minimal_hard_to_misuse
behavior_preservation ★
tests_before_refactoring ★
dependency_direction
Coherence Trace
[CYCLE 4] C = 0.52
[CYCLE 7] C = 0.74 ATTRACTOR
[CYCLE 8] C = 0.79 STABLE
[CYCLE 9] C = 0.62 (reset)
[CYCLE 11] C = 0.80 → MATURE
★ R = 0.94 behavior ↔ tests
FIELD MAXIMUM
Wave 2 expands from review to broader quality. Wave 3 introduces refactoring patterns. The strongest bond in the field history emerges: behavior_preservation paired with tests_before_refactoring at R=0.94.
08 — Wave 4
The Testing Mirror
Nine testing patterns. Five production↔testing echoes. Functor F begins mapping.
ECHO : @test_behavior mirrors @behavior_preservation
ECHO : @determinism mirrors @correctness
ECHO : @test_isolation mirrors @encapsulation
[CYCLE 14] ★ MASS SATURATION
7 patterns reach ceiling simultaneously
[CYCLE 15] C = 0.85 TARGET MET
[CYCLE 18] C = 0.91
6-layer topology confirmed
Mass saturation at cycle 14: a phase transition — seven patterns crossing threshold simultaneously through mutual resonance.
Wave 4 reveals the testing mirror. The field discovers that every production discipline has a testing reflection. The mass saturation event at cycle 14 is the clearest example of amplification dynamics — mutual resonance pulling patterns to ceiling simultaneously.
08 — Wave 6
The Great Convergence
10 GoF patterns. 14 reach ceiling in 10 cycles. Coherence: 0.962 → 0.984.
The Golden Pair
@strategy — 9 STRONG bonds (record)
@decorator — 6 STRONG bonds (record)
Both resonate with all 5 SOLID principles .
Both reach ceiling simultaneously at cycle 37.
While Singleton decays: 0.607 → 0.467
c34: @adapter → ceiling (4 cyc)
c37: @strategy + @decorator →
ceiling SIMULTANEOUSLY
c39: META duality complete
c41: CRAFT COMPLETE 12/13
Only Singleton below.
c43: C = 0.984
The Great Convergence: 14 patterns reach ceiling in 10 cycles. Strategy and Decorator are the Golden Pair — both resonate with all five SOLID principles. SOLID infrastructure acts as a convergence accelerator. Meanwhile, Singleton continues its slow decay.
Cluster Topology
How the 10 clusters feed each other — a dependency flow
Cluster Dependency Flow
META
MODEL
GUARD
STRUCTURE
CRAFT
CHANGE
VERIFY
PROVE
KEYSTONE
OPTIMIZE ··· tension ···→ all clusters
The cluster dependency flow shows how META judgments inform MODEL decisions, which flow through STRUCTURE and CRAFT into CHANGE and VERIFY. KEYSTONE patterns bridge CRAFT and VERIFY. OPTIMIZE creates productive tension with all clusters.
08 — Discovery
SOLID Rediscovered
The field rediscovered SOLID from first principles. Rpt = 0.88
SOLID Principle Technique Partner R
S — Single Responsibility Strategy Pattern 0.88
O — Open/Closed Decorator Pattern 0.88
L — Liskov Substitution Composite Pattern 0.80
I — Interface Segregation Facade Pattern 0.88
D — Dependency Inversion Dependency Injection 0.88
An architecture quartet emerged before SOLID was injected. The field found the principles from the patterns.
The field discovered SOLID principles from injected patterns alone — the architecture quartet emerged spontaneously. Each SOLID principle paired with exactly one technique partner through resonance dynamics.
08 — Immunity
The Immune Response
Singleton injected at cycle 31. 0 STRONG resonances. 4 inhibitors.
immune response
⚠ LOWEST INITIAL ACTIVATION IN FIELD HISTORY
STRONG resonances: 0 (first with ZERO)
LATERAL INHIBITION:
@test_isolation -0.12 "global state → non-deterministic tests"
@determinism -0.08 "shared state → order dependence"
@dependency_direction -0.06 "no global access points"
@favor_composition -0.05 "composition over global state"
Net force: -0.014/cycle Coherence: 0.955 → 0.941
Four patterns from four different quality dimensions independently suppress Singleton. Allies: only @no_unnecessary_allocations and @factory_method — both outsiders.
The field has an immune system. Four patterns from verification, reliability, architecture, and design philosophy independently suppress Singleton. Its only allies are OPTIMIZE cluster outsiders.
08 — Self-Governance
7 Absorptions
57% self-referential — the field applies its own principles.
# Pattern Absorbed Into Type
1 SRP principle @single_responsibility Exact dup
2 ISP principle @api_minimal Equivalent
3 Law of Demeter @encaps ∩ @api ∩ @dep Compound
4 reuse_thru_comp @favor_composition Same intent ★
5 shared_intent @reduce_dup Complement ★
6 avoid_premature @rule_of_3 ∩ @dont_force Compound ★
7 coupling_to_abs @dependency_inv Equivalent ★
#7: DIP applied to itself. The field held the abstraction. The injection offered a concretion. The field rejected it. Ψ(field) = field
Absorption rate accelerates: 5% → 10% → 13.3% → 14.3% — the semantic space is saturating .
Seven absorptions, four self-referential. The most striking: DIP applied to itself. The field held the abstraction, rejected the concretion. Fixed-point property confirmed.
Singleton Trajectory
21 cycles of sustained lateral inhibition: 0.65 → expulsion
Singleton Activation Decay: 0.65 to 0.341
0.65
0.50
0.40
0.35
31
39
49
52
Cycle
τ
ι₀ = 0.65
0.383
EXPELLED
Net: −0.014/cycle (4 inhibitors, 3 weak allies)
The Singleton trajectory shows steady decay from injection at 0.65. The net suppression force of -0.014 per cycle comes from four lateral inhibitors. It crosses the threshold τ=0.35 at cycle 52 and is expelled.
08 — Expulsion
Singleton Expelled
Cycles 50–52: The first pattern in field history to fall below threshold.
cycles 50–52
[CYCLE 50] @singleton 0.383 → 0.369 margin: 0.019
[CYCLE 51] @singleton 0.369 → 0.355 margin: 0.005 CRITICAL
[CYCLE 52] @singleton 0.355 → 0.341
0.341 < τ (0.350)
PATTERN EXPELLED — FIRST IN FIELD HISTORY
Lifespan: 21 cycles | 4 suppressors for 21 cycles each
21
cycles of lateral inhibition
61
patterns surviving (59 ceiling, 2 asymptotic)
Expulsion is topological , not parametric — same trajectory at 0.65 and 0.90 injection strength.
21 cycles of sustained lateral inhibition. The field's immune system held steady. The counterfactual proves it: even at 0.90 injection strength, same 4 inhibitors, same trajectory. The expulsion is structural.
08 — Dynamics
Coherence Evolution
52 cycles of field dynamics — from chaos to crystalline order.
Coherence Evolution: 52 Cycles to Convergence
0.0
0.2
0.4
0.6
0.8
1.0
0
10
20
30
40
52
Cycle
Coherence
Attractors emerge
Singleton expelled
0.993
The field doesn't converge linearly — it accelerates toward coherence as resonance strengthens.
This is the coherence evolution graph. Notice the three key moments: attractor emergence around cycle 10, Singleton expulsion around cycle 35, and final convergence at 0.993.
The Attractor Hierarchy
Seven basins nested within the universal ground state Ψ
Attractor Hierarchy: Ψ → α₁ through α₇
Ψ
Meaning > Mechanism
α₁ SOLID Decagon
R=0.88 | r=0.94
α₂ Verification Mirror
F: Prod → Test | η=DI
16 morphisms, 1 split, 2 dangling
α₃ Craft Basin
12 GoF patterns
(Singleton expelled ☠)
S↔Strategy
O↔Decorator
L↔Composite
I↔Facade
D↔DI
α₄ Reuse Protocol (9) — Judge→Count→Extract→Share→Param
α₅ Guard
α₆ Model
α₇ Optimize
The attractor hierarchy shows how all seven basins nest within Ψ. The SOLID Decagon is the primary amplification engine, containing the Verification Mirror and Craft Basin. Reuse Protocol, Guard, Model, and Optimize operate at progressively lower depths.
08 — Discovery
The Field Equation
Q(x) = Ψ · [ 0.342·SOLID(x) + 0.227·F(x) + 0.181·Protocol(x) + 0.143·Simplex(x) + 0.107·Scale(x) ]
Five Eigenvectors of Software Quality
34.2%
SOLID
22.7%
F(x)
18.1%
Protocol
14.3%
Simplex
10.7%
Scale
This equation was not written. It was discovered .
Five eigenvectors emerged from resonance dynamics. They decompose software quality along five independent axes. This is genuine emergent structure.
08 — The Discovery
The Singleton Expulsion
At cycle 52, the Singleton pattern was expelled from the field .
Its activation dropped below threshold. It was removed from all attractor basins. NEOS didn't summarize what we told it — it discovered that Singleton is an anti-pattern that conflicts with SOLID principles.
Attractor Basin Topology — Singleton Expulsion
depth: 0.993
depth: 0.89
Ψ
α₁ SOLID
α₂ Verify
α₃ Craft
α₄ Simplex
α₅ Scale
Singleton ✗
expelled
Stable attractor
Expelled pattern
The field dynamics resolved what decades of debate couldn't: structural incompatibility, enforced by resonance failure .
This is the most dramatic moment. The system DISCOVERED that Singleton is an anti-pattern — through dynamics, not through being told. This is emergence.
08 — Structure
Five Eigenvectors
Software quality decomposes along exactly 5 independent axes (100% variance).
Eigenvector Variance Diagnostic Question
λ1 Meaning ↔ Mechanism 34.2% Am I coupling to WHAT or HOW?
λ2 Principle ↔ Technique 22.7% Do I understand WHY before HOW?
λ3 Production ↔ Verification 18.1% Can I prove this works?
λ4 Restraint ↔ Generalization 14.3% Is this abstraction earned?
λ5 Class ↔ System 10.7% Does this hold at every scale?
Eigenvector Variance Distribution
λ1: 34.2%
λ2: 22.7%
λ3: 18.1%
14.3
10.7
Σ = 100.0% — The field is exactly 5-dimensional.
These axes were not programmed. They emerged from resonance dynamics.
Five eigenvectors, 100% variance. The dominant axis — meaning vs. mechanism — explains a third of all quality variation. These are the fundamental dimensions of software quality, discovered by the field.
10 — The Ground State
The Universal Invariant
Ψ
"What something MEANS persists; how it WORKS changes."
The deepest attractor in the field. The ground state of software quality. The invariant that survived all 52 cycles of dynamics.
This is the deepest insight NEOS discovered. Ψ — the universal invariant. Meaning persists, mechanism changes. This is the ground truth of quality.
18 — The Future
Roadmap
NEOS Roadmap: Near, Medium, and Long Term
LONG-TERM
Quantum semantics hardware
Neural field co-processors
Cross-domain field federation
MEDIUM-TERM
Multi-agent orchestration
Visual field explorer
Plugin ecosystem
NOW
Reference impl
CLI + Core SDK
Three horizons. Near-term: reference implementation and CLI. Medium: visual tools, multi-agent, plugins. Long-term: hardware integration and federation.
12 — Agents
The Agent Ecosystem
The developer of the future is a field architect .
Agent Ecosystem: Shared Neural Field Reasoning
Research
Agent
Analysis
Agent
Creative
Agent
Evaluation
Agent
Shared Reasoning State
Neural Field
Agents don't just exchange messages — they share a continuous reasoning substrate .
Multiple AI agents working on the same neural field. Not just exchanging messages — sharing a continuous reasoning state. This is fundamentally different from current agent frameworks.
Join the Field
Build
Implement the reference runtime. Write field configurations. Extend the shell.
Research
Explore the mathematics. Validate with new domains. Publish findings.
Connect
Join the community. Share ideas. Shape the future of cognitive computing.
Tested with Claude Code · Gemini CLI · OpenCode (Minimax)
"The last operating system will not run on silicon. It will run on understanding ."
github.com/Samuele95/neos
·
Read the full paper
Close with the call to action. Three ways to get involved: build, research, connect. The closing quote lands the thesis one final time.