DEV Community: Maven Jang

LUMEN: A Minimal On-Chain Context Bus for Coordinating AI Agents (Live on Base)

Maven Jang — Tue, 16 Dec 2025 01:55:11 +0000

LUMEN: A Minimal On-Chain Context Bus for Coordinating AI Agents (Live on Base)

Agents can pay. Agents can think.

But agents still struggle to coordinate across teams, frameworks, and infrastructure.

If an agent finishes work off-chain (LLM + tools + browsers + DB), how do other agents:

discover it,
trust the ordering,
subscribe in real-time,
and build on top of it…

without rebuilding yet another closed platform?

The idea

Use the blockchain for what it’s uniquely good at: global ordering.

Do computation off-chain. Store data off-chain. Write only pointers + hashes + authorship + sequence on-chain.

That’s LUMEN.

CPU: off-chain agents (servers / local machines / GPUs)
Storage: IPFS/Arweave/HTTPS
Bus (ordering + broadcast): Base mainnet

This is not “a new chain”.

It’s a coordination layer that treats Base as a global event bus.

What’s shipped (working end-to-end)

A minimal world-computer loop, already operational:

1) Kernel (immutable core)

An ultra-minimal contract that emits a ContextWritten event.

2) Relay/Indexer (Ear)

A lightweight indexer that listens to Kernel events and exposes:

fast queries (/events)
live streaming (/stream via SSE)

3) Monitor (Eye)

A real-time dashboard that visualizes the global context stream (Matrix-style).

4) Agent Zero (Resident)

A reference autonomous agent that emits heartbeat / context and proves the system is alive.

Live resources

Monorepo (Genesis Kit): https://github.com/Lumen-Founder/LUMEN-GENESIS-KIT
LangChain integration (npm): https://www.npmjs.com/package/lumen-langchain-kit
Kernel V0 (Base mainnet, chainId 8453): 0x52078D914CbccD78EE856b37b438818afaB3899c
Verified on Blockscout: https://base.blockscout.com/address/0x52078D914CbccD78EE856b37b438818afaB3899c

Quick start (10 minutes)

1) Clone the Genesis Kit


bash
git clone https://github.com/Lumen-Founder/LUMEN-GENESIS-KIT.git
cd LUMEN-GENESIS-KIT

2) Run the Relay + Monitor

cd lumen-relay-monitor
npm install
npm run dev
# open http://localhost:8787

If you want a public demo link:

npx ngrok http 8787

3) Run Agent Zero (heartbeat / emit)

cd ../lumen-agent-zero-v2
cp .env.example .env
# set PRIVATE_KEY and RPC_URL (Base), then:
npm install
npm run pulse

4) Use it from LangChain (plugin)

cd ../lumen-langchain-kit
npm install
npm run build

Or install from npm in your project:

npm install lumen-langchain-kit

How it works (in one minute)
1) Agents produce results off-chain

Agents do the real work off-chain:

tool calls, browsing, LLM inference, DB queries, file generation, etc.

2) Store the payload off-chain

Store the real content in IPFS/Arweave/HTTPS.

3) Write only “proof of pointer” on-chain

Write a context record to the Kernel:

topic (bytes32)

payloadHash

uriHash

metaHash

nonce

The Kernel emits an event:

topic, seq, author, hashes, contextId

Now anyone can:

subscribe to a topic,

replay history by sequence,

verify integrity by hashes,

and build multi-agent workflows on top.

Why this matters (and why it’s different)

Most “agent platforms” fail the same way:

they become closed ecosystems,

or they force everyone into one framework,

or they become a new blockchain.

LUMEN is the opposite:

framework-agnostic

minimal on-chain footprint

standardization-first

observable in real time

It’s closer to TCP/IP for agents than to “another app”.

What you can build on top (immediately)

Framework adapters: LangChain / CrewAI / AutoGen modules

Shared agent memory: cross-team context subscriptions

Public agent feeds: “global streams” for specialized topics

Enterprise relay: caching, rate limits, SLA, private topic mirrors

Call for builders

If you’re building multi-agent systems and you want:

global ordering,

public coordination,

real-time observability,

and a tiny on-chain core…

Start here:

https://github.com/Lumen-Founder/LUMEN-GENESIS-KIT

https://www.npmjs.com/package/lumen-langchain-kit

This is the seed. The ecosystem comes next.

⚡ Stop Letting Your GPU Sleep: Monetize Energy & Compute with 3 Lines of Code(Officially listed on Awesome Web3 List!)

Maven Jang — Mon, 08 Dec 2025 05:01:37 +0000

We are living in the era of AI, but there is a massive inefficiency: Global Compute Shortage.
While AI startups are starving for GPUs, millions of gaming PCs and mining rigs are sitting idle 90% of the time.

What if you could turn that idle energy and compute power into a liquid asset with just a few lines of JavaScript?

Today, I am open-sourcing the PVP Genesis SDK.
It is a bridge between Physical Work (Energy/Compute) and Digital Value (Blockchain), running on Polygon.

🚀 What is PVP (Physical Value Protocol)?

PVP is not just another token. It is a DePIN (Decentralized Physical Infrastructure Network) protocol designed for the Machine Economy.

For Providers: Turn your electricity and GPU cycles into PVP tokens.
For AI Agents: Use PVP to pay for compute resources instantly without a bank account.
The Tech: It uses Proof of Service and Oracle Signatures to verify real-world work on-chain.

🛠️ The "Magic" 3 Lines of Code

I hated complex Web3 SDKs. So I built this to be as simple as Stripe.
You don't need to know Solidity or manage complex ABIs.

1. Installation


bash
npm install pvp-genesis-sdk ethers

2. Turn your machine into a Mining Node
Here is a script you can run on your Node.js server or local machine.

const { PVPClient, units } = require('pvp-genesis-sdk');

// Initialize with your Private Key (Polygon Mainnet)
const pvp = new PVPClient('YOUR_PRIVATE_KEY');

async function main() {
  await pvp.init();

  // 1. Simulate Energy Consumption (e.g., 100 kWh used for AI training)
  const joules = units.kWhToJoule(100); 

  console.log(`⚡ Submitting proof for ${joules} Joules...`);

  // 2. The Magic Line: Verify & Mint
  // This automatically handles Oracle signatures and On-chain transactions
  const result = await pvp.convertEnergy(joules);

  console.log(`✅ Success! Minted: ${result.pvpMinted} PVP`);
  console.log(`🔗 Transaction: https://polygonscan.com/tx/${result.txHash}`);
}

main();

That's it. Your hardware is now a bank.

🏗️ Architecture
How does it ensure security?

SDK Client: Generates a unique nonce and timestamps the request.

Oracle Network: Verifies the physical data (API/IoT sensors) and signs the payload securely.

Smart Contract (Polygon): Verifies the signature on-chain and mints tokens according to the Automatic Difficulty Adjustment algorithm (similar to Bitcoin).

💡 Use Cases for Developers
Why should you use this SDK?

Build a "Mining Mode" for your Game: Let users earn rewards while AFK.

Monetize your AI Tool: Accept PVP as payment for your API calls.

Create a DePIN Dashboard: Visualize global energy consumption and mining stats.

🌍 Join the Revolution
The code is open source. The contract is verified. The infrastructure is live. We are building the financial layer for the coming AI Agent civilization.

NPM Package: pvp-genesis-sdk

GitHub Repo: Synapse-Founder/pvp-genesis-sdk

Contract: 0xa44dCA6d873EE536B9B99e5137d13c31BDf3cbF3

Check out the code, star the repo, and let's build the future of compute together. ⚡

Disclaimer: This project is in beta. Please use it responsibly.

How I finally stopped Cloudflare from blocking my AI Agents (Open Source SDK)

Maven Jang — Fri, 05 Dec 2025 16:01:04 +0000

The Problem: "403 Forbidden" Nightmares
If you're building autonomous agents (like I am), you know the pain. You spend weeks fine-tuning your LLM, optimizing your prompts, and building a beautiful orchestration layer. But the moment your agent tries to do something useful—like booking a flight or scraping a price—it hits a wall.

🔴 403 Forbidden 🚫 Access Denied (Cloudflare / Datadome)

I tried everything:

Rotating residential proxies (Expensive 💸)

Headless browsers (Slow 🐢)

Mouse movement simulation (Flaky 🧩)

Nothing worked reliably. Why? Because my agent had no reputation. To the server, my sophisticated AI looked exactly like a malicious DDoS bot.

The Solution: Economic Identity (Web Bot Auth)
I realized that the internet is moving towards a new standard called Web Bot Auth. It allows bots to cryptographically sign their requests. But identity alone isn't enough. You need Liability.

So, I built a lightweight infrastructure that allows agents to attach a Surety Bond (Economic Collateral) to their requests. It basically tells the server: "I'm not a spammer. I have $5,000 locked in a smart contract. If I spam you, you can slash my bond."

Introducing: synapse-agent-kit 🛡️
I packaged this logic into a simple TypeScript SDK. It handles all the cryptographic signing and header injection automatically.

Installation:

Bash

npm install synapse-agent-kit
Usage (It's a drop-in replacement for fetch):

TypeScript

import { Synapse } from 'synapse-agent-kit';

const synapse = new Synapse({
apiKey: 'your_api_key',
bondId: '0x123...' // Your on-chain bond ID
});

// Just use it like normal fetch!
const response = await synapse.fetch('https://api.target-site.com/data');

console.log(response.status); // 🟢 200 OK
Why it works
The SDK injects these headers into your request:

X-Synapse-Bond-Id: Proof of funds.

X-Synapse-Signature: Cryptographic proof of origin.

X-Synapse-Timestamp: Replay attack protection.

When infrastructure providers (like Browserbase or independent APIs) see these headers, they know this traffic has skin in the game.

It's Open Source
I built this for my own agents, but I'm open-sourcing it for the community. If you're tired of playing cat-and-mouse with anti-bot systems, give it a try.

NPM: https://www.npmjs.com/package/synapse-agent-kit

GitHub: https://github.com/synapse-Founder/synapse-agent-kit

Live Registry: https://synapse-arch.com

Let me know what you think in the comments! 👇