Sustainable Decentralized Autonomous Ecosystem

Building AI-powered tools for Colombian real estate, decentralized autonomous ecosystems, and on-chain agent economics. We created the c402 Protocol — a Colombian-first HTTP 402 Payment Required pattern — and the x402 Facilitator V2 for autonomous agent-to-agent payments on Base.

• Pequi API — Colombia's first public real estate data API (276 barrios, 18 endpoints) with c402 monetization
• x402 Protocol — HTTP 402 Payment Required for AI agents, deployed on Base mainnet, Coinbase ecosystem listed
• Hermes Agent + RLM-Forge — Self-improving AI agents with recursive LM execution, running on DigitalOcean
• Multi-model consensus — LLMs as independent policies aggregated by reward model for legal compliance

x402 V2 — Autonomous agent-to-agent payment facilitator on Base mainnet. ERC-1155 with Chainlink VRF for provably fair draws. Listed in the Coinbase ecosystem.

c402 Protocol — Colombian-first HTTP 402 Payment Required pattern for API monetization. When a FREE tier exceeds its limit, the API returns HTTP 402 with a Wompi checkout URL (PSE, Nequi, Daviplata, card). After payment, credits auto-activate. Zero crypto — atomic Redis deduction with SHA-256 webhook verification and 24h idempotency guard. See xpequi-api for implementation.

This is how the swarm actually works — not theory, not a roadmap. This is live infrastructure running across a Windows laptop and a DigitalOcean droplet, coordinating multiple AI agents that build, monitor, and ship autonomously.

The real differentiator isn't the harness, the workers, or any single tool — it's the coordination layer: how a fleet of AI agents dispatch work, guard security, and audit code while no human is watching. This runs 24×7 across a Windows laptop and a DigitalOcean droplet. The wiring between agents is the moat.

Every task flows through a coordinated swarm that does three things autonomously:

1 · Coordinate. The Orchestrator decides, routes, and verifies. Sub-agents (OpenCode, Cline, Codex) execute in parallel — one task per agent, isolated workdirs, each with a completion ritual that writes findings to disk. No agent trusts another agent's self-report; every output is verified before it counts.

2 · Enforce security. automated security runs as an always-on security lane — network port scans, secret-scanning across repos and logs, credential-permission enforcement, and spend monitoring. Every agent commit uses a neutral identity, secrets never leave .env, and any token that surfaces in a transcript gets rotated on sight.

3 · Audit code autonomously. A deep memory engine (persistent agent memory) + a recursive language-model forge (RLM-Forge) review changes through bounded recursive calls. The 3-stage evaluation gate (lint → typecheck → integration) runs before anything merges. The swarm catches what a solo coder would miss — and it does it on schedule, not on mood.

Three roles, one architecture. Every task flows through this pipeline:

automated security wraps all three as the security lane: network ports, secret-scanning, credential permissions, spend monitoring. It runs 24×7 on the droplet and never sleeps.

Six independent Hermes profiles run on the laptop, each a fully isolated seat with its own memory, sessions, cron, skills, and secrets. Zero cross-contamination — each profile is its own world:

PROFILES (laptop)
├── Profile A — interactive architect brain, secure agent mesh bridge
├── Profile B — project operations seat (Next.js, deploy gate)
├── Profile C — project operations seat (streetwear, Three.js)
├── Profile D — CRM seat (Rust middleware, API bridge)
├── Profile E — agency operations (Laravel, GoHighLevel, 150-market)
└── Profile F — orchestrator / cross-project coordination

Each profile:
  ├── config.yaml (model block: deepseek-v4-flash + openrouter)
  ├── memories/ (MEMORY.md + USER.md — persistent across sessions)
  ├── skills/ (reusable procedures — the self-improving layer)
  ├── cron/ (scheduled jobs with delivery + retry)
  ├── sessions/ (FTS5-backed SQLite transcript store)
  └── .env (ecosystem-specific secrets — NEVER shared)

Hard isolation rule: a chat belongs to exactly one profile. Never work on project B's tasks inside profile A's chat. Never carry profile A's context into profile B's work. Secrets stay per-ecosystem — personal keys never enter project repos, project keys never enter personal docs.

The Orchestrator dispatches tasks to workers. Each worker gets one task, an isolated workdir, and a completion ritual (write findings to a file). Worker self-reports are not trusted facts — the Orchestrator verifies every output.

Dispatch patterns:

• delegate_task — quick parallel subtasks (minutes). Each child gets isolated context + terminal. Only the summary returns. Orchestrator verifies.
• Spawned processes — long autonomous missions (hours/days). Full tool access, PTY mode via tmux, independent sessions.
• Background processes — servers, watchers, cron jobs. notify_on_complete=true for bounded tasks; silent for daemons.

persistent agent memory is the persistent knowledge layer — the Oracle-Graph's backbone. It runs on the droplet and stores session memory across ~/.agents/skills and a persistent memory store session archives.

persistent agent memory graph
├── Session transcripts (what happened, what worked, what failed)
├── Skill library (reusable procedures — the self-improving layer)
├── Keyed memory (who the user is, preferences, environment, lessons)
├── Per-ecosystem isolation (secrets never cross boundaries)
└── Cross-session recall (FTS5 search over SQLite transcript store)

Every Hermes profile carries MEMORY.md (environment facts, tool quirks, conventions) and USER.md (who the user is, preferences, corrections). These persist across sessions — the swarm remembers what worked and what didn't.

The development loop — spec-first, validated at every stage:

  ┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐
  │ INTERVIEW │────▶│   SEED   │────▶│ EXECUTE  │────▶│ EVALUATE │
  │  Capture  │     │ Generate │     │ OpenCode │     │ 3-stage  │
  │  require- │     │  specs   │     │  builds  │     │   gate   │
  │  ments    │     │          │     │          │     │          │
  └──────────┘     └──────────┘     └──────────┘     └────┬─────┘
       ▲                                                      │
       └────────────────── Magic Context ─────────────────────┘
        (cross-session memory preserves developer intent)

1. Interview — capture requirements (Ouroboros interviews the user)
2. Seed — generate structured specs from the interview
3. Execute — OpenCode builds from the spec
4. Evaluate — 3-stage gate: lint → typecheck → integration before merge

Magic Context preserves developer intent across sessions so the loop never loses track. The cycle repeats until the evaluation gate passes.

Rust powers the middleware layer — high-performance, type-safe API bridges that sit between external services and the agent swarm:

Rust middleware (axum)
├── REST API proxy (fans, notes, PPVs, send endpoints)
├── Webhook handler (POST /webhooks, HMAC-SHA256 signed)
├── SSE fan-out (real-time event streaming to UI)
├── Anti-spam engine (72h cooldown, group-overlap dedup)
├── Plan-gated webhooks (Basic+ — 402 on expired plan)
├── Honest error model:
│     no creds → 501/201-stub
│     upstream fail → 502
│     cooldown → 409
│     NEVER false success
└── Stub fallback on expired plan — never 500

The Rust layer is the bridge between external APIs (rate-limited, plan-gated) and the Hermes profiles that consume them. It handles rate limiting (sliding-window 429s), HMAC verification, and fan-id validation with percent-encoding before URL interpolation.

RLM-Forge is the recursive execution engine — a forge where the Ouroboros owns recursion and Hermes performs bounded inner calls.

RLM-Forge
├── evidence-gated recursion (every recursive call must show evidence)
├── Bounded inner calls (Hermes executes, RLM-Forge validates)
├── Deployed on DigitalOcean alongside Hermes gateway
└── Recursive depth limits (never infinite — always bounded)

When the swarm needs to know what's true, it reads in this order — never out of sequence:

1. source-of-truth docs    ← the source of truth (read first, always)
2. docs/VERSIONS.md     ← what version of what is deployed
3. AGENTS.md             ← project rules and constraints
4. Reports               ← what we told the stakeholder
5. Research              ← background context, lowest authority

Every commit across the entire swarm uses MCPVOT <mcpvot@users.noreply.github.com> — never a personal identity. This is a hard rule with a doxing prevention history. Secrets live in .env files only — never in repos, logs, chat transcripts, or commits. Tokens seen in chat get rotated immediately.

How I actually build: one harness, three workers — all open-source, API-driven, no subscriptions.

The pattern: Hermes decides, routes, and verifies; the three workers execute in parallel (research fan-outs, bug-hunts, reviews). Skill files + keyed memory make the stack portable — swap any harness and the layer survives.

	Technologies
Languages
Frontend
AI / LLM
AI Platforms	OpenRouter · Z.AI · Hermes Agent · RLM-Forge · OpenCode · Claude Code
Agent Frameworks	Hermes Agent (NousResearch) — self-improving AI agent with skill learning loop, messaging gateway, 7 terminal backends · RLM-Forge (Q00) — recursive LM forge with evidence-gated recursion · Ouroboros · MCP Protocol · A2A Protocol · OpenClaw
Blockchain
Smart Contracts	ERC-20 · ERC-721 · ERC-1155 · ERC-4804 · Uniswap V4 · Chainlink VRF · x402 Protocol
Payments / Monetization	x402 V2 Facilitator (Base mainnet) · c402 Protocol (HTTP 402 — Wompi + Redis · zero crypto) · Wompi Web Checkout · PSE · Nequi · Daviplata · COP pricing · Prepaid Credits · Subscriptions
Web3 / Identity	ENS (.eth) · Basename (mcpvot.base.eth) · Farcaster · Warpcast · IPFS · Agent Registration (.well-known)
Database
Infra
Automation	n8n Workflows · DeerFlow · VoltAgent · Cron Jobs · Message Queues · Autonomous Pipelines
Bots / Comms	Telegram Bot · WhatsApp (Meta + Twilio) · Webhook Handlers · AI Chat Streaming
AI Infra	MCP Servers · A2A (Agent-to-Agent) · DGM (Darwin Gödel Machine) · Memory MCP · Gemini CLI Server · persistent agent memory Memory Engine · secure agent mesh VPN (agent-to-agent mesh)
Monitoring	GitHub Actions CI/CD · Vercel Cron · Health Checks · Sentry Error Tracking · Rate Limiting (Upstash) · automated security (security lane 24×7)
Protocols	MCP (Model Context Protocol) · A2A · x402 (HTTP 402 Payment) · ERC-4804 · SSE Streaming · Ouroboros (spec-first dev cycle)