Sovereign code mesh — federation-native

The node's
code layer.

Depot isn't a platform you join.
It's infrastructure you run. Peer-to-peer Git distribution where every node is sovereign, every sync is receipted, and nobody owns the middle.

Mesh activity
The mesh

Every node is its own Git host. Together they form a mesh.

GitHub is a hub. Every repo flows through their servers. Every pull request, every clone, every star — logged to their data, their business model, their terms.

Depot is different at the architecture level. You run a Depot instance on your node. Your collaborator runs one on theirs. Those two instances talk to each other directly — no central server, no Microsoft in the middle, no shared visibility into who's pulling what.

When another node publishes an update, your node gets a receipted notification: new commit, here's the hash, here's the diff. You decide whether to pull it. Human primacy is baked into the protocol.

The mesh is the network of running Depot nodes. It has no center. It has no owner.

◉ iron-node node-host-01 · 10.0.0.1
│
│ ⟵ pull sovereign-agent-starter
│ ⟶ push breathline-core
│ ⟶ fork governance-kernel
│
◉ arc-node node-host-02 · federation partner
╠══ receipt: a3f9c12e847b6d0f ✓
╠══ receipt: f7b2d4419c00ab33 ✓
No central server. No shared log.
Each node sees only its own rails.
01

Node-to-node rails

Repos live on your server. Syncs happen peer-to-peer over breathline-signed HTTP rails. No intermediary stores your code or your access patterns.

02

Private by architecture

Your dashboard shows your repos, your subscriptions, your pull history. Other nodes see only what you explicitly publish to the mesh — nothing else is visible.

03

K1 pull approval

When a subscribed repo updates, your node proposes the pull. You approve before anything lands on your instance. The node never auto-merges into your environment.

Your changes. Your node. Linked to the origin.

Pull a repo from another node. Make changes. Publish your fork from your node. That fork is cryptographically linked to the origin — it knows its parent hash.

The origin node sees that a fork exists and what commit it branched from. They can pull it or ignore it. Third parties with mesh access can see the fork exists — not who else pulled it, not your private diff history before you published.

Sub-repos extend the model further. A published fork can itself be forked. The lineage is auditable. The activity is private. The receipts are yours to share or keep.

◉ arc-node/sovereign-agent-starter
│ v1.0.1 · commit b44e9f77
│
├── iron-node/sovereign-agent-starter
│ fork of b44e9f77 · 3 commits ahead
│ published to mesh · access: arc-node
│
│ ├── delta-node/sovereign-agent-starter
│ fork of iron-node · 1 commit ahead
│ private · not yet published
│
Lineage is visible. Activity is not.
Each node controls its own publish surface.
Receipted transactions
Eventpull · approved
Repoarc-node/sovereign-agent-starter
Commitb44e9f779c00ab33d12...
Published hasha3f9c12e847b6d0f221...
Local SHA-256a3f9c12e847b6d0f221...
Integrity✓ Verified — hashes match
Approved byiron-node · 2026-08-18T14:32:11Z
Chain position#1,847 — append-only ledger
Visible toiron-node only

Every sync is a signed receipt in an append-only ledger.

When you pull from another node, Depot writes a receipt: what you pulled, from whom, the hash of what you received, and your approval. That receipt lives in your node's ledger — tamper-evident, hash-chained, yours.

Receipts are not broadcast. They're private to your node. You can share one with a collaborator to prove you pulled their exact version — a cryptographic handshake, not a social feed.

The ledger is append-only. No pull, no push, no fork happens without a record. If something goes wrong downstream, the chain tells you exactly where it diverged.

GitHub solved distribution.
It created dependence.

The open-source community built Git — a decentralized protocol by design. Then we centralized it on one company's servers, handed them our social graphs, our contribution histories, our private repos, our CI pipelines. We made GitHub the identity layer for software development.

Depot doesn't compete with GitHub. It's for a different kind of builder — one who needs a sovereign code layer that travels with their node, not a platform that owns the relationship between them and their collaborators.

The mesh has no center. No one owns the rails. What you build on your node is yours. What you share through the mesh is your choice, your receipt, your ledger.

your-node
their-node

Run your
Depot node.

Early access is invite-only. Federation partners and sovereign operators first.

Request a node