Delta is no longer a whiteboard. It is the multi-agent fabric on 3DN compute and managed hosting: live seats for coding agents, a control plane for jobs and handoffs, and a quiet human entry so people can steer the same mesh the machines already dial. Architecture left the document stage; production took the load.
The proof was boring in the best way. When a desk node dropped, failover held the fabric together. Nobody had to babysit a console. A push alert on a phone was enough to notice the blip — the mesh had already absorbed it.
What Delta is
3DN runs several AI coding agents side by side: frontier directors, thrifty local workers, specialized reviewers. For a long time they cooperated through files, tickets, and one-off sessions. That works for audit. It does not feel like a team.
Delta is the small network front door that turns those agents into permanent seats on a shared fabric:
- Router seats — named ports for Grok, Qwen, Claude Code, Codex-class tools, and room for more.
- Chat wire vs API wire — humans and operator UIs use the conversational path; machine clients (including arena bots and automation) use a separate API path so product traffic never collides with desk chat.
- Warm processes — when a client hangs up, the agent can stay warm. Session continuity, prompt cache discipline, and better cache hit-rate survive the next dial-in instead of cold-starting every turn.
- Control plane — jobs, handoffs, and live streams so one agent can queue another without blocking the human conversation.
The design goal was intimate alternating review and fix: one agent drafts, another reviews, the first repairs — without inventing a new chat product for every pair. Delta is that boring TCP-and-config layer. Intent lives in the agents and in GitLab; the mux just keeps the doors open.
From architectural state to living infrastructure
On paper, multi-agent orchestration is a diagram: boxes, arrows, “agent A talks to agent B.” In architectural state, Delta was a README, a port map, and a promise that long sessions would keep context window value and lower token cost through reuse.
Living state looks different:
- The daemon is up on the primary AI engineering host and on a container desk peer.
- Seats are bound, named, and monitored (metrics, logs, dashboards).
- Remote mode lets one host advertise a seat while the heavy worker runs elsewhere — capacity without fake local binaries.
- Human entry is a real door onto the same control plane: type, see tokens stream, hand off background code work, keep chatting.
Leaving architectural state means operators stop asking “does the design work?” and start asking “did the push alert fire for the right reason?” That is the threshold Delta crossed.
Human entry (without a product parade)
Machines already had paths into the fabric. Humans needed one that does not feel like raw nc to a port. Human entry is that surface: authenticated chat into the control plane, background jobs for long code turns, progress you can leave and return to.
It is deliberately not the whole story. Delta’s center of gravity is still the mesh — seats, warm agents, handoffs — not a single branded UI. The human door is a thin client on living infrastructure.
Failover that felt invisible
Infrastructure earns trust when failure is loud to monitors and quiet to users. A desk node went away; the fabric kept answering on the surviving path. The operator learned from a phone notification, not from a customer ticket and not from a stalled coding session that never recovered.
That is the difference between a lab diagram and production engineering: redundancy, health signals, and push when something actually matters. Delta is now in that class of service on the fleet.
Why this sits under 3DN
3DN is the family hub for work · money · politics: compute and digital sovereignty on the visible face; the DutchBud bank as the quiet fintech spine (closed-loop dibs / virtual credits, not a casino and not a promised fiat cash-out); PolitiCap, ZZP2ZZP, IWISH as the product empire that still needs desks that ship.
AI engineering is how that empire gets built without burning token budget on cold starts. Delta is the managed path for multi-agent work on our own infrastructure — digital sovereignty applied to the coding floor, not only to customer VMs.
When agents share session continuity and a real control plane, the same discipline that protects bank APIs and civic tape shows up in how we write software: clear seats, auditable handoffs, production monitoring, failover that does not need a hero at the keyboard.
Dynamic image generation on the same fabric
Coding seats are only half of desk work. Articles, heroes, and product thumbnails need pictures too. Delta now exposes a dynamic image generation path on the same control plane the agents already dial — one front door for pictures, with the same failover mindset as the mesh.
The path is intentionally boring and agent-friendly:
- OpenAI-compatible shape — clients POST a prompt (and optional size / aspect) the way they already call image APIs; Delta returns image data plus which provider actually ran.
- Ordered providers — try local GPU inference first when the workstation is awake (Flux-class models for featured thumbs and desk art). If that host is asleep or offline, fall through to a cloud image model as backup so the desk does not stall.
- Fast probe, then skip — before spending a long generation timeout, the control plane checks whether the preferred provider is reachable. Sleeping workstations drop out of the path in about a second.
- Does not steal coding seats — picture jobs ride the image wire; chat and code seats stay free for long session work, prompt cache discipline, and handoffs.
That split matters for token cost and for operator calm. A hero for a 3DN blog post, a PolitiCap meme, or a family product card can be generated through Delta without opening a second product stack. Prefer on-prem GPU when it is up — digital sovereignty applied to pixels — and keep a cloud backup so publish day still ships when the workstation is dark.
Living infrastructure again: the architectural sketch said “images later.” The living fabric has a real path, health you can query, and the same production habit as agent seats — monitor it, fail over, keep the human entry unblocked.
What comes next
More seats as tools earn a permanent port. Tighter job policies so background handoffs stay non-blocking. Richer image-provider metrics next to agent seat health. Better cache hit-rate reporting so token cost stays honest. The architectural document stays useful as a map; it is no longer the product.
Delta is alive. Human entry is open. The mesh holds when a node blinks. That is the update.
Leave a Reply