WEB6 — Live Agent Platform Demo

WEB6 Agent Chat — Live

A real server-side agent loop (POST /v1/agent/run) under one metered WEB4 reservation: 98 providers with cost routing, Holonic Memory that curates itself, self-drafting SkillOpt skills, a metered code sandbox and any remote MCP server as tools. Every step is billed to this avatar.

Ask anything. Try "What is 2^61 - 1, and is it prime?" with the code sandbox on, or tell it about yourself with memory on, then ask what it remembers.

Holonic Memory (recall + auto-curate) Code sandbox tool (metered)

Agent (SkillOpt skill)

Task category

Remote MCP server (optional)

Model

Turns

Model calls

Session cost

👍 / 👎 score a run for the chosen agent. If the agent had no skill for this category, the run drafted one — a 👍 makes it the agent's skill, and later SkillOpt epochs refine it.

Messaging Channels — Telegram · WhatsApp · Slack · Discord · Signal · Email

Clients link their chat to their avatar with a one-time code. Every reply runs the agent under that client's own revocable, budget-capped WEB4 grant — with conversation memory, voice notes and per-client billing.

1 — Create a WEB4 delegated grant for chat replies

USD / month

2 — Channel

Scheduled Agent Runs

Cron-timed agent tasks that run unattended under a WEB4 grant, exactly once across servers, delivering to a webhook or straight into a linked chat. Revoking the grant disables the schedule.

Name

Cron (5 fields) · time zone

Prompt

Grant

Deliver to linked chat (binding id, optional)

WEB6 vs a Model Router vs Hermes Agent

A router only fixes model access. An agent app only gives one person an agent. WEB6 is the whole platform — multi-user, metered and privacy-first.

Capability	Model router (e.g. OpenRouter)	Hermes Agent	WEB6
One OpenAI-compatible API, any model	Yes	As a client	98 providers, cost / latency / quality routing, failover
Cost reduction	Platform fee on top	Full price + extra calls	Semantic cache, BRAID reuse, FAHRN cheap-model routing
Server-side agent loop	No	Yes	/v1/agent/run, metered per step
Long-term memory	No	One agent's local notes	Holonic Memory, auto-curated, per avatar
Self-improving skills	No	Writes skills	Drafts skills + SkillOpt validates and evolves them
Code execution	No	Local shell	Isolated metered sandboxes (E2B, Judge0, Daytona)
Any MCP server as tools	No	Yes	Yes, public-HTTPS guarded — and 500+ MCP tools served
Chat channels	No	6 channels	Telegram, WhatsApp, Slack, Discord, Signal, Email + voice notes
Scheduled runs	No	Cron, single user, unbilled	Exactly-once cron under budget-capped grants
Multi-user isolation & billing	No	No	WEB4 avatars, plans, limits, delegated grants
Document corpus / RAG storage	No	No	Holonic Memory ingestion + semantic search
Data sovereignty	Their servers	Your box	Hosted or self-hosted ONODE
CLI chat	No	hermes	star chat

WEB6 Development Platform Readiness

Checks the deployed API, approved model catalogue, provider registry, OpenServ catalogue, FAHRN agents, and this avatar's usage ledger in one live pass.

Holonic BRAID — Generator / Solver Split

Generator builds a Mermaid reasoning graph once per task type. Solver executes it for every subsequent query at a fraction of the cost. Plans persist to MongoDB + Solana + IPFS via COSMIC ORM.

Generator

High-tier model. Builds reasoning plan once.

claude-sonnet-5 / gpt-4o

→

Solver

Low-cost model. Executes cached plan per query.

gpt-4o-mini / gemini-flash

Task Type

FAHRN Agent Registry

Load the OpenServ SERV model catalogue, then inspect the authenticated avatar's FAHRN agent registry.

FAHRN Dispatch via web6.fahrn.solve()

Hero endpoint: classifies task, picks best agents, dispatches in chosen mode, returns answer + reasoning trace.

Problem

Dispatch Mode

Task Type

Fractal Holonic Memory Hierarchy

Intelligence compounds up the fractal — Session → Agent → User → Group → City → Earth. Membrane rules control propagation.

Store & Search Memory

Write a memory item to a holon, then semantic-search across it. Propagate upward through the hierarchy.

Holon ID (from tree above)

Field Name

Retention

Memory Value

Cost Comparison — Direct vs BRAID

Based on arXiv:2512.15959. Live data from your last FAHRN solve updates automatically.

Monthly queries

Avg tokens / query

Direct provider ($/M tokens)

BRAID solver ($/M tokens)

Live Data — Last FAHRN Solve

Populated automatically when you run Solve on the FAHRN tab.

—

Tokens

—

Cost USD

—

Agents

—

Mode

—

BRAID Reused

—

Provider

Using @oasisomniverse/web6-api

This demo loads the npm package via esm.sh. The same code runs in Node.js or any bundler.

Install

npm install @oasisomniverse/web6-api

AI Completion with BRAID

import { Web6Client } from '@oasisomniverse/web6-api'; const web6 = new Web6Client({ baseUrl: 'https://dev.api.web6.oasisomniverse.one' }); web6.setToken('<your-oasis-avatar-key>'); const { result } = await web6.completion.complete({ Provider: 'auto', Model: 'auto', Messages: [{ Role: 'user', Content: 'Your prompt here' }], UseHolonicBraid: true, // Generator/Solver split — 74× cost reduction UseFAHRN: true, FahrnTaskType: 'general', Routing: { Priority: 'cost', Fallback: true }, }); console.log(result.content); console.log(`$${result.estimatedCostUSD} via ${result.provider}/${result.model}`);

FAHRN Multi-Agent Dispatch

const { result } = await web6.fahrn.solve({ problem: 'Design a zero-downtime Postgres migration for a 50M-row table', taskType: 'architecture', mode: 'Parallel', // Serial | Parallel | Debate | Voting | Decomposed maxTotalTokens: 8000, maxCostUsd: 0.50, }); console.log(result.answer); console.log('Agents used:', result.agentsUsed); console.log('BRAID graph reused:', result.braidGraphWasReused);

OpenServ Provider — one SERV key, all models

// Read OpenServ's live model catalogue (authenticated) const response = await fetch('https://dev.api.web6.oasisomniverse.one/v1/openserv/models', { headers: { Authorization: 'Bearer <your-oasis-jwt>' } } ); const models = await response.json(); // Route a completion through OpenServ const { result } = await web6.completion.complete({ Provider: 'openserv', // GPT-5, Claude, Gemini, Grok, DeepSeek via SERV gateway Model: 'auto', Messages: [{ Role: 'user', Content: 'Hello via OpenServ' }], });

Streaming SSE

const stream = await web6.completion.stream({ Provider: 'auto', Messages: [{ Role: 'user', Content: 'Write a long technical document...' }], }); for await (const chunk of stream) { process.stdout.write(chunk.delta); }

One platform. Every agent capability.