The model proposes. The core decides.

Sidged is your personal intelligence, built as an operating system. Models suggest. A small core decides what may run, and what may leave your device.

Watch it work
Three stacked layers: the generated interface on top, the Sidged runtime with its security core in the middle, the Linux kernel at the bottom.

Watch one request

Two steps where a model suggests, four where the core decides.

You

Send Ben a message, but fix the photo first.

  1. Understandmodel
  2. Planmodel
  3. Verifycore
  4. Approveyou
  5. Executecore
  6. Recordcore

Sent, signed and logged.

What that means for you

Not another harness

Most agents are a prompt and a set of rules wrapped around a model that holds the keys.

Sidged takes the keys away from the model. It may suggest anything. Only the core can act.

A technocratic swarm

Your devices work together, and none is trusted just for being a member. An edge that misbehaves or drifts from its measured image is cut off and replaced by a fresh one.

Edge 1 in the centre sends work to four edges. One edge drifts, turns red and is revoked; a fresh edge with a new key replaces it. edge 1, your state edge 2 edge 3 edge 4 drifted, revoked new did:key
How the swarm stays honest
  • Enrolled by you

    An edge joins only with your approval, bound to its image digest and its own did:key. Pair with a signed QR invite, a passkey or a Swiss E‑ID.

  • Checked on every hop

    Edges authenticate each other. Every message is a signed envelope carrying its grant, checked against your Cedar policy, default deny.

  • Audited before the effect

    Each edge logs the decision before it acts. If the log fails, the message is refused.

  • Silent when you say so

    In local mode the mesh is off: no listening, no connection to any peer.

Local first. The cloud only on your terms.

You allow it

The first call to a cloud model for a kind of task waits for your OK.

Private stays private

Data you mark local-only and every secret are refused at the gate, always.

A receipt for every call

Each request is anonymised, checked for where it may go, and signed in a privacy report.

Under the hood

For the people who will read the code.

Three layers
  1. Layer 3 SDG-L4

    Generated interface

    A declarative view per task, composed from a vetted component catalogue instead of model-written code. Approvals and the kill switch stay with the core, behind a Unix socket checked with SO_PEERCRED.

  2. Layer 2 SDG-L0..L7

    Sidged runtime

    Rust security core with plan verifier, grants, Cedar information-flow control and the privacy gateway; an on-device model ensemble that proposes; WebAssembly modules; signed records.

  3. Layer 1 SDG-L8

    Linux kernel

    Drivers, scheduler, namespaces, isolation. The classic userland goes away; the stack boots on bare metal, in a VM, as a host service or an OCI container.

Seven primitives instead of a userland
PrimitiveReplacesIn Sidged
IdentityUser accounts and ambient UIDsEd25519 did:key identities for owner, devices, agents and services
CapabilityApps, syscalls, raw IPCA typed descriptor declaring inputs, outputs, effects, data classes, residency, cost and whether it is consequential
GrantAmbient permissionsAttenuable, holder-bound capability tokens with budgets, use limits and expiry, evaluated with Cedar
PlanScripts, small apps, agent loopsA declarative graph with bounded map and CEL, guaranteed to terminate and verified before it runs
ViewWindows and UI toolkitsA declarative interface per task with no foreign code, plus trusted UI only the core draws
RecordFile system and app databasesContent-addressed, signed dCBOR objects with data class, provenance, residency and retention
ModulePackages, drivers, librariesSigned WASI 0.3 components with a manifest and no ambient authority
Nine invariants no layer may break
  1. The model is never the boundary

    Models propose intents, views and plans. The deterministic core decides.

  2. No effect without a grant

    Every call needs a verified, unexpired, holder-bound token and a permit from your policy.

  3. Outside input is data

    Model, tool, web and peer output stays data until the verifier has checked it.

  4. You approve what matters

    Consequential steps wait for your approval in trusted UI.

  5. One way out

    All egress passes the privacy gateway and leaves a signed privacy report.

  6. Sandboxed execution

    Generated code runs in the WebAssembly sandbox with at most the rights of its task.

  7. Fully offline

    Local mode opens no listening socket and sends nothing to the internet.

  8. A core you can audit

    The Rust core stays small. Everything else is an isolated module.

  9. Everything is on the record

    Every effect lands in a signed, hash-chained audit log.

Cloud models through the privacy gateway
  • Local model calls need no approval; the first remote call per provider and task type needs yours in trusted UI.
  • Data classes marked local-only are refused for every remote destination; secrets.* never reach egress, even with an owner permit.
  • Fail-closed residency (CH, EU, CH-EU, unrestricted); a destination the gateway cannot place is a refusal.
  • Core-checked anonymisation with the versioned detector set sdg.pii/1, no model or network involved.
  • One signed privacy report per egress, bound to the payload digest. Provider profiles P0 to P3.
  • Hybrid planning: a cloud planner may draft unrestricted blueprints while sensitive steps stay on your own edges. Local mode is a one-way latch.
Mapped to ISO/IEC 27090
ThreatMechanism
Prompt injectionInputs stay data until the static verifier and Cedar information-flow policy have checked the plan
Faulty actuationA worker that hallucinates a capability or breaks the flow policy is culled and replaced
Supply chainDeterministic training data, pinned base models, SHA-256 provenance manifests
ExfiltrationFail-closed residency, core-checked anonymisation, secrets never on an egress path
Spoofed approvalApprovals only over a kernel-verified socket from a separate approver identity
TamperingAn Ed25519-signed SHA-256 hash chain written before every allow or deny

A mapping and a self-assessment, not a certification.

Try it from a terminal
# build and test the workspace
cargo test --manifest-path runtime/Cargo.toml --workspace --locked

# keys, policy, catalogue and a signed root grant
sidged init --workspace ~/sidged

# model -1, planner, verifier, swarm queue, signed result
sidged task "Write a polite project status email to Alex" --workspace ~/sidged

# check the hash chain and every signature
sidged log verify audit.log --public <key>

Specifications are drafts under CC BY 4.0; runtime, schemas and code under Apache 2.0. No certification programme exists.