Skip to content

# monad.ai, Cleaker, and Public Roots ​

This page fixes a common confusion in the stack:

- `.me` is the semantic kernel
- `monad.ai` runs monads: active execution agents
- `cleaker` is the binder that projects a `.me` into a namespace
- `cleaker.me` is the canonical public root.

Current implementation note: monad.ai now includes the NRP mesh layer: monads declare claimed namespaces, selectors constrain execution candidates, the scoring engine chooses the best claimant, and the bridge records outcomes for learning and analysis.

## Core Roles ​

### `.me` ​

`.me` is the kernel.

It owns:

- identity derivation from seed
- keys and secret scopes
- semantic tree and memory log
- snapshots, hydration, replay
- cryptographic proof of identity

Examples:

- `me://self:read/profile`
- `me://self:write/profile.name`
- `me://self:explain/profile.netWorth`

### `monad.ai` ​

`monad.ai` runs monads: active agents that serve, resolve, and execute inside a namespace. It owns:

- serving namespace requests over HTTP
- resolving namespaces from the `Host` header
- persisting the kernel state via DiskStore
- handling claim/open lifecycle
- Monad process lifecycle, logs, status, and local execution
- mesh discovery via `/.mesh/monads` and `/.mesh/resolve`
- adaptive route selection via scoring and decision logs

A monad can run only for you on localhost, or it can be exposed publicly on a domain. The kernel is the storage. There is no separate database. A monad is not the namespace, not the host, and not the port. It is a semantic execution route chosen by the resolver:

txt

    jabellae.cleaker.me/profile                 semantic path / meaning
    jabellae.cleaker.me/photos/iphone           semantic path / meaning
    jabellae.cleaker.me/.mesh/monads            internal Monad registry
    jabellae.cleaker.me[monadlisa]/profile      technical execution override
    monadlisa@127.0.0.1:8161                    Monad instance + endpoint

The normal user-facing address has no monad selector:

txt

    me://jabellae.cleaker.me/profile

A monad selector is only a technical override. These still target the same semantic node:

txt

    me://jabellae.cleaker.me[monadlisa]/profile
    me://jabellae.cleaker.me[monadluis]/profile
    me://jabellae.cleaker.me[device:macbook]/profile

Named selectors force or identify execution. Device/tag/host selectors constrain the mesh candidates while leaving the semantic path unchanged.

### `cleaker` ​

`cleaker` is the binder. It takes a `.me` instance and projects it into a namespace context. It handles the full bind lifecycle automatically:

1. Ask `.me` to prove identity
2. Attempt to open the namespace
3. If the namespace does not exist yet, claim it
4. Reopen and hydrate the kernel with the returned memories

ts

    const node = cleaker(me, {
      secret,
      namespace: 'username.cleaker.me',
      space: 'cleaker.me',
    })

    await node.ready

`cleaker` does not store anything. It does not own the identity. It connects `.me` to a namespace and hands control back.

Cleaker does not decide where a Monad runs. That belongs to NetGet.

### `https://cleaker.me` ​

`cleaker.me` is not a different protocol. It is a public domain with Monads that act as a canonical public root — a common agreement where identities can be anchored publicly.

###### That means: ​

- infrastructure-wise, it is a public namespace served by Monads
- semantically, it is a well-known root for public namespaces like `jabellae.cleaker.me` Any domain running compatible Monads can play this role. `cleaker.me` is the default, not the only option.

# Deployment Roles ​

### Local-only Monad ​

A local-only Monad runs only for you — on your laptop, your home server, your LAN. It does not need to be publicly accessible.

    http://suis-macbook-air.local:8161/

You get the full kernel, the full memory log, the full identity — just not exposed to the internet.

### Application domain ​

An application domain — like `otherNamespace.com` — can run its own `monad.ai` and use it as the namespace root for its users. Users anchor their identity there:

    username.othernamespace.com

The app does not need to use `cleaker.me`. It is its own notary.

### Public root ​

A public root is a domain that exposes namespace behavior publicly and lets anyone anchor an identity under it. Examples:

- `cleaker.me` — the canonical public root
- any other domain running a public `monad.ai`

## Canonical Address vs Web Projection ​

`me://` is the canonical semantic address. `https://` is one possible public projection of that address.

    me://username.cleaker.me:read/profile
    https://username.cleaker.me/profile

    me://username.othernamespace.com:read/profile
    https://username.othernamespace.com/profile

The semantic target is primary. The web URL is a projection chosen by the host.

## Key Spaces and Privacy ​

Topology does not imply publicity. A space can be replicated to multiple Monads — laptop, iPhone, home server, VM — and still remain completely private. The distinction is:

- topology decides where the ciphertext exists
- audience decides who can open it So a key space may live on many Monads and still remain private if its audience is cryptographically closed.

    T = {monadlisa, worker-a, phone-agent}  ← Monads where it lives
    A = {jabellae}                         ← who can read it

## NetGet ​

NetGet is the physical placement and endpoint layer. It can place a Monad on a laptop, iPhone, Raspberry Pi, VM, relay, or localhost and resolve that placement into a current endpoint.

txt

    me.monad[monad_id].endpoint("netget://iphone/monadlisa")
    NetGet resolves that to http://10.0.0.12:8161

The user asks for meaning. The resolver chooses a Monad route. NetGet handles the body that route runs in.

## One-line Model ​

- `.me` holds the identity and the tree
- `cleaker` binds `.me` to a namespace
- `monad.ai` runs Monads that serve and execute inside that namespace
- `NetGet` places those Monads and resolves endpoints
- `cleaker.me` is one public root among many possible ones

## Rule ​

- Every app can use `.me`
- Not every app needs `cleaker`
- Every public root can run `monad.ai`
- `cleaker.me` is the canonical default, not the only option