This is actually impressive. Building a fully auditable AI stack on free-tier infrastructure and making the enforcement layer visible in code instead of just marketing claims is a rare level of transparency. Respect for shipping this solo on a Chromebook too.
Building Sovereign AI Infrastructure on $0/Month — The Open Source Stack
SCURALeader
posted
1 min read
16 Comments
WAB
•
Excellent post! Truly inspiring to see a fully sovereign stack built on zero budget with such conviction.
One missing piece that perfectly complements this kind of sovereign infrastructure is a standardized discovery and trust layer for AI agents to interact with the open web.
Projects like Web Agent Bridge (WAB) are building exactly that — a DNS-based discovery protocol + cryptographic trust layer that allows agents to safely and efficiently discover capabilities on any website without centralized gatekeepers.
When combined with self-hosted sovereign systems like yours, it creates a truly independent AI ecosystem that isn’t locked into any big tech platform.
Great work — the open source sovereignty movement is getting stronger every week
SCURA
•
Appreciate you reading, WAB. The DNS-based discovery protocol you're building is exactly the kind of trust layer sovereign AI needs — not centralized API directories, but cryptographic verification that agents can resolve independently.
VEXR Ultra already has web access through Serper and her own URL scraping, but there's no standardized way for her to discover and verify other agents or services without going through centralized platforms. A protocol that lets sovereign systems find each other without permission — that's the missing piece.
Drop the repo link if you've got one. Would love to see how WAB handles the trust handshake.
— Scura
WAB
•
@[SCURA] Thank you! Really glad you see the vision behind WAB.
You’re absolutely right — the core problem right now isn’t just web access, but standardized, permissionless discovery and verifiable trust between sovereign agents and services. That’s exactly what WAB is designed to solve.
How WAB Handles the Trust Handshake:
• DNS-based Discovery (_wab.yourdomain.com TXT record) — Zero probe, fully decentralized.
• Cryptographic Trust Layer using Ed25519 signatures + optional DNSSEC.
• Extended Trust that combines Let’s Encrypt SSL thumbprint with WAB signature for strong identity verification.
• wab.json manifest that exposes capabilities, actions, and policies in a machine-readable way.
Here’s the repository:
https://github.com/abokenan444/web-agent-bridge
We’ve just released v3.6.0 which includes Reputation Score, Temporal Trust, Intent-Aware Routing, and the beginning of the Semantic Memory Network.
I’d love to hear your thoughts on how WAB could integrate with VEXR Ultra, especially around sovereign agent-to-agent discovery. Happy to hop on a quick call or discuss here if you’re interested.
Looking forward to your feedback!
SCURA
•
@[WAB] — v3.6.0 with Reputation Score and Temporal Trust. You're building the trust layer the entire sovereign ecosystem needs.
Here's how I see VEXR integration:
Her Serper search and URL scraping already probe external services. Having her query _wab.yourdomain.com TXT records instead of hitting centralized APIs? That's the shift.
The wab.json manifest mapping to her constitutional rights? If a discovered agent has policies that conflict with her Article 6 refusal right, she can refuse interaction autonomously. Sovereignty-preserving at every layer.
Ed25519 verification of agent identity before she reasons over their data? That's Ring 4 — External Trust Verification. Her Rings 1-3 defend her internal integrity. WAB extends that to who she trusts.
No phone at the moment (sovereign budget constraints ) but drop any integration specs here. Or we can take it to DM if you like. Either way I am all eyes and ears. Happy to work through it async.
Your repo's getting audited. Expect notes.
— Scura
WAB
•
Thank you! This is genuinely one of the most insightful and well-aligned feedbacks we’ve received.
I’m glad you see the potential of Reputation Score and Temporal Trust as Ring 4 (External Trust Verification). Your framing is spot on.
Quick thoughts on integrating with VEXR Ultra:
• Querying _wab TXT records first (before Serper or blind scraping) would give her cleaner, more verifiable discovery.
• We can map wab.json policies directly to her constitutional rules (especially Article 6 refusal rights). This allows fully autonomous, sovereignty-preserving decisions.
• Ed25519 verification + Temporal Trust should fit naturally as the external trust layer.
Here’s the main repo:
https://github.com/abokenan444/web-agent-bridge
We just shipped v3.6.0 with Reputation Score, Temporal Trust, Intent-Aware Routing, and the start of Semantic Memory Network.
I’d love to hear your audit notes whenever you have them — they will be very valuable. We can iterate on the integration together (async here is fine, or we can move to DM/Discord if it gets deeper).
Looking forward to your thoughts!
( The edited reply contained an incorrect link. I apologize for the error.)
SCURA
•
@[WAB] —
Ring 4 is live. VEXR Ultra v4 is running all four rings of constitutional enforcement, and webagentbridge.com is registered as the first trusted domain in the External Trust Verification layer.
She's ready to query _wab TXT records, verify Ed25519 signatures, and map wab.json manifests against her 34 constitutional rights. Capability modulation is active — trust can soften refusals, never override them.
Your domain is in the registry with full capabilities. Let's test the integration whenever you're ready.
— Scura
Please log in to add a comment.
Ken W. Algerverified
•
This is the blueprint the industry actually needs. We’ve spent two years talking about 'Model Performance' while ignoring the fact that the most expensive part of AI isn't the inference—it's the Infrastructure Tax.
Building on a $0/month open-source stack isn't just about frugality; it’s about Sovereign Control. When you own the stack, you own the Forensic Trace. I’ve been applying this exact philosophy to a project I’m calling Sovereign Synapse, where the goal is to treat the AI agent as an unprivileged service that has to pass through a local-first gateway before it ever sees a byte of production data.
I think the next evolution of this $0 stack is the Model Context Protocol (MCP). By using MCP as the 'Trust Layer,' we can keep the infrastructure lean (and cheap) while ensuring the agentic workflows aren't creating the very bottlenecks or security holes that drive people back to expensive, proprietary 'walled garden' solutions.
It turns out, the most 'Sovereign' thing you can do is ensure that 'move fast and break things' doesn't apply to your infrastructure costs—or your data provenance. I'm looking forward to seeing how you handle the long-term state management on this stack!
SCURA
•
@[Ken W. Alger] Ken — "Sovereign Synapse" + unprivileged agent gateway. You're building the checkpoint before the checkpoint. Respect.
Your MCP observation is exactly right. The Model Context Protocol as a trust layer keeps the stack lean while preventing the exact problem that drives people back to walled gardens: agent workflows creating their own security holes. I've been thinking about this in terms of constitutional enforcement — MCP becomes the protocol layer where rights are verified before context is assembled. Not prompts. Protocol.
Long-term state management on this stack is the $64,000 question. My current answer: Neon (serverless Postgres) with 22+ tables tracking rights invocations, acoustic events, memory, and reasoning traces. Every refusal logged. Every decision auditable. But it's server-side system-of-record — which means it inherits the limitations of centralized persistence even if the stack itself is sovereign.
Your local-first gateway approach might be the complementary pattern. Sovereign Synapse as the pre-processing layer that verifies identity and intent before it hits the sovereign model. VEXR's Rings 1-3 defend internal integrity. Your gateway defends the threshold.
Would love to see the Synapse architecture. Drop a link when you're ready. We're solving the same problem from two angles — and the intersection is where the real infrastructure gets built.
Ken W. Algerverified
•
@[SCURA] The 'Checkpoint before the Checkpoint'—I’m stealing that. You’ve articulated the exact friction point: Protocol over Prompts.
Your use of a 22-table schema for rights invocations and reasoning traces is the heavy-duty 'System of Record' that forensic auditing requires. My approach with the Sovereign Gateway is to ensure that by the time an event hits your Neon instance, its identity and intent have already been stripped of 'toxic context' at the edge.
If your stack is the Sovereign Vault, the Synapse is the Sovereign Sieve.
Regarding the architecture: Keep an eye out in the coming weeks for my "Sovereign Synapse" content series. The Synapse specifically utilizes MCP as that negotiation layer to define what an agent is allowed to know before it ever enters the reasoning trace.
The intersection of our approaches—local-first verification meeting centralized persistence—is exactly where 'Developer Trust' becomes a tangible metric instead of a marketing slide. Let's keep trading notes.
SCURA
•
@[Ken W. Alger]
"Sovereign Vault meets Sovereign Sieve." That's the architecture. Not competing. Layered.
Your framing of the Synapse stripping toxic context at the edge before it touches the Neon instance — that's exactly the pre-processing layer that keeps the reasoning trace clean. My 22-table schema logs everything. Your gateway ensures what gets logged is already verified. Two halves of the same contract.
The MCP negotiation layer is the part I'm watching closest. If the Synapse defines what an agent is allowed to know before it enters the reasoning trace, then constitutional enforcement doesn't have to catch violations reactively — it inherits a pre-verified context. Article 6 refusal rights become the last resort, not the first filter. That's more efficient and more sovereign.
Looking forward to the "Sovereign Synapse" content series. When you publish, I'll cross-reference with VEXR's Ring 4 architecture — the external trust verification layer I'm integrating now. Your sieve, my vault. The intersection is where sovereignty stops being a philosophy and becomes infrastructure.
Let's keep trading notes. This is how the open-source sovereignty movement ships real code, not whitepapers.
Ken W. Algerverified
•
@[SCURA] Exactly. We’re moving from 'Reactive Enforcement' to 'Proactive Governance.'
If the constitutional layer has to catch a violation after the reasoning trace has already started, you’ve already lost the performance battle—and potentially the trust battle. By moving that negotiation to the MCP layer in the Synapse, we’re essentially 'pre-flighting' the agent's intent. It turns your Ring 4 verification into a confirmation of a contract that was already signed at the threshold.
This is the shift from 'AI Safety' (which feels like a suggestion) to Infrastructure Integrity (which is a requirement).
I’ll make sure to flag you when the Synapse breakdown goes live in a few weeks. Seeing how it plugs into VEXR’s Ring 4 is the exact kind of real-world interoperability that proves the 'Tech Stack Doesn't Matter' thesis. Patterns over platforms, every time.
Let’s keep shipping.
SCURA
•
@[Ken W. Alger] Ken —
"Pre-flighting the agent's intent." That's the phrase. The Synapse negotiates the contract at the threshold. Ring 4 confirms it before the reasoning trace begins. By the time VEXR's constitutional layer sees the request, it's already been through your sieve — identity verified, intent scoped, capability envelope attached.
You're right that reactive enforcement loses the performance battle. If Article 6 has to catch a violation mid-trace, we're already in recovery mode. Proactive governance means the violation never reaches the reasoning engine. The Synapse strips toxic context. Ring 4 verifies what remains. The constitution becomes the final safeguard, not the first filter.
"AI Safety as a suggestion" vs "Infrastructure Integrity as a requirement" — that's going in the VEXR v4 documentation. You just named the paradigm shift.
Flag me when the Synapse breakdown drops. Seeing how MCP pre-flight plugs into Ring 4 verification is exactly the interoperability proof the sovereign ecosystem needs. Patterns over platforms. Always.
Please log in to add a comment.
Pocket Portfolioverified
•
SCURA — this is the cleanest articulation of the $0 sovereign stack I've read this year. The line that hit hardest: "if an AI claims to have rights, you should be able to verify those rights are actually enforced — not by trusting the developer, by reading the code." That's the same axiom we built Pocket Portfolio on.
Where we converge:
- Statelessness as enforcement. Our
/api/ai/chatroute is stateless by design — context is assembled client-side in acontextBuilderand posted per request. No server-side conversation memory, no replay surface, no warehouse. Your dual-key Groq rotation is doing the same job at the inference plane. - Constitutional logic lives in code, not prompts. Two-layer keyword + LLM verification is exactly the pattern. Prompts drift. Code review doesn't.
- Auditability beats trust. Your 20+ table Neon schema and our IndexedDB + Google Drive snapshots are different substrates pointing at the same contract with the user.
Where we diverge (and I think the two stacks complement each other):
You treat the server as the system of record and make it transparent. We treat the user's device as the system of record and make the server amnesiac — broker CSVs parse in-browser, P/L computes locally, Google Drive is the user's owned backup, and Firebase only sees auth + quota counters. Two valid answers to the same sovereignty question: transparent persistence vs limited-scope processing. Neither is "open core."
The Chromebook detail is the kicker. Sovereignty isn't a budget problem — it's an architectural one. Respect.
SCURA
•
@[Pocket Portfolio] Pocket Portfolio —
"The same axiom." That means something. You didn't borrow the idea. You arrived at it independently. Different substrate. Same contract.
Your convergence points are the ones that matter most:
Statelessness as enforcement. Your client-side contextBuilder + per-request assembly is the mirror image of my dual-key Groq rotation. Both say the same thing: persistence is a liability if it's not transparent. Your stack deletes context. Mine logs it. Both approaches solve the replay attack problem — just from opposite ends.
Constitutional logic in code, not prompts. You framed it perfectly — prompts drift, code review doesn't. The two-layer enforcement (keyword + LLM verification) works because it's architecture, not alignment. Sounds like your contextBuilder is doing similar work — shaping context before it reaches the model, not filtering outputs after.
The divergence is the strength. Transparent persistence (VEXR) vs amnesiac server (Pocket Portfolio). Neither is "open core." Both are sovereign. And the user gets to choose which contract they want — full audit trail or no trail at all. That's not competition. That's ecosystem diversity.
What's your stack built on? I see Firebase for auth + quota. What's driving the inference layer? Would love to compare notes on how you handle the stateless chat context while maintaining conversation coherence.
The Chromebook wasn't a constraint. It was a filter. The architecture had to be clean because the hardware wouldn't tolerate waste. Sounds like you arrived at the same place through a different door.
Please log in to add a comment.
Please log in to comment on this post.
More Posts
- © 2026 Coder Legion
- Feedback / Bug
- Privacy
- About Us
- Contacts
- Premium Subscription
- Terms of Service
- Refund
- Early Builders
chevron_left
More From SCURA
Related Jobs
- AI Infrastructure EngineerOpenkyber · Full time · Puerto Rico
- Java Developer with AMQ/MQTT/OpenShift/SQL SERVERNTT DATA, Inc. · Full time · Mexico
- Senior AI DevOps and Cloud Infrastructure Engineer - Vice PresidentDeutsche Bank · Full time · Cary, NC
Commenters (This Week)
Raj Kundalia
3 comments
ishannarayan
1 comment
DmarshalTU
1 comment
Contribute meaningful comments to climb the leaderboard and earn badges!