Crucible

Building a dApp today means duct-taping five disconnected tools: a code editor, a terminal running a local node, a browser, a wallet extension, and a block explorer. None of them talk to each other, and no AI assistant has any awareness of your chain state, wallet balances, or deployment history.

Crucible is a browser-based agentic development environment for Web3. You describe the dApp you want. The agent writes the Solidity and frontend code, compiles it, spins up a local Hardhat chain, deploys, and loads a live interactive preview, all in one unified workspace.

Every step is visible in the terminal and inspector. If a transaction reverts, the agent traces the failure, recalls whether it has seen this pattern before, patches the contract, redeploys to a chain snapshot, and verifies the fix before committing it.

When the local agent has no prior context for a revert, it can query peer Crucible nodes over the Gensyn AXL mesh to pull a verified fix from another developer who solved it. Once the dApp is proven locally, the same artifact ships to a public chain through KeeperHub, the only production execution path. Think v0 by Vercel, but for dApps, where the agent has long-term memory, a peer network, and a production execution layer built in.

The core problem was making the loop coherent: write, compile, deploy, preview, and debug had to happen through one runtime the agent could observe and control, not five separate tabs.

Stack:

• Frontend: SvelteKit 2 + Svelte 5, CodeMirror editor, xterm.js terminal, AI SDK v6 for streaming agent events over SSE
• Backend: Bun + Hono control plane, Prisma + Postgres for workspace metadata, per-workspace Docker containers that supervise every runtime service
• Auth: better-auth with SIWE (EIP-4361 Sign-In with Ethereum) as the primary path, Google OAuth as fallback

Agent tooling via MCP: The agent reaches the runtime through a set of MCP servers running inside each workspace container: mcp-chain (Hardhat node with snapshot/revert/fork), mcp-compiler (solc compilation, artifact store), mcp-deployer (deploy, simulate, trace), mcp-wallet (accounts, signing), mcp-memory (recall and write patterns), mcp-terminal (non-interactive shell exec separate from the user's PTY session). The control plane proxies every agent tool call to the right in-container port without the agent knowing any port numbers.

Inference and memory: Primary inference runs on 0G Compute with verifiable receipts captured per call. Long-term memory (the revert pattern library) is stored on 0G Storage: KV for hot recall index, Log for full debugging history. Both degrade gracefully to local filesystem when credentials are absent.

Peer mesh: Each Crucible instance is a Gensyn AXL node. On a cache miss, the agent broadcasts a structured help request. A peer that has solved the same revert returns a verified candidate patch. The local agent verifies it against a chain snapshot before applying.

Production shipping: All public-chain execution routes through KeeperHub: simulation, gas estimation, execution, retries, and audit trail. It is the only path from local to mainnet or testnet.

Two notable implementation choices:

• The browser terminal uses a raw HTTP/1.1 socket hijack to the Docker engine (Upgrade: tcp on POST /exec/{id}/start) instead of node-pty, because Bun's process model cannot sustain interactive bash sessions and dockerode's hijack mode hangs under Bun's Node compat layer.
• The live preview runs in its own origin. A small EIP-1193 bridge script is injected into the preview's index.html before each Vite dev server starts. The bridge forwards wallet requests to the parent shell via exact-origin postMessage checks, and the shell proxies approved requests to the backend RPC endpoint. Private keys never enter the iframe.