Build on Core Node
Register your application once and reach a network of Apple silicon Macs for language models, embeddings, rendering and transcription. Every request is sealed to the machine that runs it, every result comes back with a signed receipt, and settlement is computed from those receipts.
From idea to live on the network
1 · Your identity
Create a RosaTrust identity for yourself and, if you like, your company. It is generated on your own device, verifiable by anyone, and needs no paperwork.
2 · Register your application
Sign a manifest with that identity: the workloads you need, the models you use (named by content hash), the class of machine they require, where your work may run, and whether your application is listed publicly.
3 · Build in the sandbox
Your keys reach a staging network of real nodes. Requests, receipts and cancellation behave exactly as they will in production; nothing is charged.
4 · Review, then go live
After review you receive a signed application credential. Every node verifies it on every request, offline, before any work starts — and it can be revoked network-wide at any time.
Every application passes the same five checks
Operators trust the network because nothing reaches their machines unexamined. Each check produces a signed record attached to your registration, and a new version, model or workload is reviewed again.
Compatibility
Every model you declare resolves by hash, every workload runs on the class of machine you named, quotes are deterministic, receipts verify, and cancellation works.
Stability
A sustained soak on the staging network: error rates, timeouts, memory pressure, and whether your client backs off gracefully when a node is busy.
Security
Adversarial and malformed inputs against the workloads you use, replay and nonce handling, and how your application keeps its keys.
Conduct
Your declared purpose matches your traffic, generative content respects the content policy, and capacity is not resold outside the published terms.
Contribution
Your application pays published rates, accepts the receipts it receives, and brings real use to the network.
Requests, never code
Your application does not install anything on anyone’s Mac. It sends requests — prompts, render graphs, audio — which Core Node’s own executors run against models identified by content hash. A node either holds the exact file a request names or declines and says which one it is missing.
Requests are sealed to the key of the one node that will run them and signed with your application’s key. The relay that carries them sees only ciphertext.
| Building block | Detail |
|---|---|
| Node card | The node’s key-agreement key and build, signed by its device key. Pin the device key; verify the card. |
| Sealing | X25519 key agreement, HKDF-SHA256, AES-256-GCM. A fresh ephemeral key per job. |
| Request signature | Ed25519 over the tenant, the target node, the time, a single-use nonce and the SHA-256 of your request bytes. |
| Receipt | Signed by the node: model, tokens read (cached and new) and written, completed or cancelled, the build that ran, and the key the answer was sealed to. |
| Cancel | Stop your own running job, for example the slower of two hedged requests. Partial work comes back with its receipt. |
The network places the work; receipts settle it
Placement
Each job goes to a node able to run it, where capacity is available at that moment. Your work can be kept to machines you own, or allowed across the network.
A price before it runs
Render work is quoted from the job itself before it starts. Language-model work is metered in tokens read and written, as the receipt records.
Paid from receipts
You pay the published rate for work you accepted. Of every payment, 80% goes to the owner of the Mac that did the work, 10% to the platform, and 10% to building out the network.
Applications are unlisted by default: operators see the kind of work their Mac does, not the product it serves, until you choose to be named.
The local API
Core Node speaks the Ollama HTTP API on http://127.0.0.1:3000, so existing clients and libraries work by changing one address. It answers only processes on the same Mac.
curl http://127.0.0.1:3000/api/chat -d '{
"model": "rosalind-v3",
"stream": false,
"messages": [
{"role": "system", "content": "Answer in one sentence."},
{"role": "user", "content": "What is a CpG island?"}
]
}'
| Endpoint | What it does |
|---|---|
POST /api/chat | A conversation. Streams by default, as Ollama does. |
POST /api/generate | A single prompt, with an optional system prompt. |
POST /api/embed | Normalised embeddings for one input or many. |
POST /api/embeddings | One raw embedding, the older form. |
GET /api/tags, GET /api/ps | Installed models, and the models resident in memory. |
Each model is prompted in the format it was trained on, read from the model file itself. Several models stay resident at once, and Core Node manages their memory for you. Options you already use are honoured: temperature, top_p, num_predict, seed, stop and format: "json".
Apply to the program
The program is opening to a small number of applications first. Tell us what you are building and what it needs, and we will send sandbox access, the full wire format and the reference client.
Your details are used only to respond to your application; see the privacy policy.