.me

.me

Own your knowledge graph.

Agents, notes, relationships, wallets, groups, and secrets — unified in one reactive tree.

Getting Started

Clone the Github Repository: run the following command in your terminal.

git clone https://github.com/neurons-me/.me.git

Once cloned, select your preferred language and run the corresponding setup command:

Command<br>Status<br>Documentation

Typescript<br>cd .me/Typescript && npm install

node.js Docs ⟡

Python<br>cd .me/Python/<br>Not Available<br>Pip Docs 𓆚

Rust<br>cd .me/Rust/<br>Not Available<br>Rust Docs

Demos 𓂃𓂃𓂃𓂃𓂃𓂃𓂃𓂃𓂃𓂃𓂃𓂃𓂃𓂃𓂃𓂃

🤖⟐🤖 Robots that Understand Context 🤖⟐🤖 ⇄ ⇆ Same object, different meaning. →

🏙️📡 Smart City 🏙️📡 ⌬◉⌬ ⟶ ∴ — A full city reacting in real time as interconnected nodes. →

🌐🌐🌐 Hemisphere Scale 🌐🌐🌐 — 1 million nodes with cross-domain reactive updates. →

⚡⚡⚡ Extreme Fan-Out ⚡⚡⚡ — One write instantly updates 100k dependents. ⌬◉⌬ →

⌬ ⊚ View all demos →

Syntax

.me uses an infinite proxy — any path you write becomes a node in the graph.<br>No schema. No migrations. No declarations upfront.

me.city.population = 700_000<br>me.city.name = "Veracruz"

// derived — recomputes automatically<br>me.city.density = () => me.city.population / me.city.area

// context-aware<br>me.robot.canProceed = () => me.robot.canLift && !me.robot.needsHumanReview

// stealth — structurally invisible to outside observers<br>me.wallet["_"].balance = 1000

// explain any value<br>me.explain("city.density")<br>// → { value: 3500, expression: "population / area", dependsOn: [...] }

// query across the graph<br>me.robots[r => r.canProceed === true].name

Write anything. Chain anything. The kernel figures out the dependencies.<br>If it changes, everything that depends on it updates — automatically.

▵ Why .me?

Structural Privacy — Private data is structurally invisible (not just hidden by rules).

Full Explainability — Every derived value can explain exactly how it was computed.

Subjective Reality — Same graph, different views per agent.

Local compute makes memory an OS primitive.

Cloud makes it a service.

Even with 100,000 nodes needing a simultaneous recompute, you’re looking at about 62 microseconds per node (6252ms / 100k) for the full propagation. That’s incredibly consistent.

The same object can mean completely different things depending on context — and everything updates automatically when something changes.

Real Performance

.me uses true O(K) reactivity — when a value changes, only its actual dependents update. Not the whole graph.

1 million nodes in memory

1 sensor changed → exactly 6 dependent nodes recomputed

Time to propagate: 0.256ms

K=6 out of 1,000,000 — the rest of the graph is untouched

Scale the graph to 10 million nodes — if your change has 6 dependents, it still takes the same time.<br>Data that thinks. Logic that explains itself.

𓅓 Own your intelligence.

suiGn<br>MIT License © 2025 · neurons.me