parellax

Parellax is a verifiable orchestration layer for agentic banking built on the 0G ecosystem. It solves a problem every autonomous finance tool quietly ignores: how do you prove the AI had authorization to act, and that it actually did what it claimed? Existing agentic finance tools are black boxes — the model decides, money moves, you get a receipt. There is no cryptographic proof of the reasoning, no on-chain enforcement of user-defined rules, and no tamper-proof record of what happened. Parellax eliminates all three gaps simultaneously.

The system takes a natural-language intent — "pay the nanny 0.1 OG" — and executes it through a four-stage verifiable pipeline.

Stage one: intent validation. The user's spending limit is read directly from 0G KV Storage, keyed to their wallet address. This is not a database the operator controls — it lives on the 0G network. If the amount exceeds the limit, the request is rejected before the AI is consulted at all.

Stage two: TEE evaluation. The intent is submitted to 0G Compute running Qwen 2.5 7B inside a Trusted Execution Environment with verify_tee enabled. The model evaluates the request against the user's financial context and returns a structured approval decision with a unique verification ID — cryptographic proof the inference ran inside a sealed enclave the host cannot inspect or tamper with.

Stage three: on-chain settlement. On approval, the server signs the release payload and submits it to ParellaxVault — a minimal ECDSA-gated Solidity contract deployed on the 0G Galileo testnet. The contract independently verifies the signature against the registered verifiedBrain address, checks the vault balance, enforces replay protection using the TEE verification ID as a one-time-use nonce, and only then releases funds. There is no admin bypass. No code path releases funds without a valid signature from a TEE-approved decision.

Stage four: audit. Every decision — approved or rejected — is appended to an immutable audit log on 0G KV Storage. The log is keyed to the user's wallet address. No operator, including Parellax itself, can edit or delete entries after they are written. Any party can reconstruct the full decision history from the 0G network independently.

The storage and compute layers are also published as two standalone open-source npm packages — @daiwikdomain/parellax-storage and @daiwikdomain/parellax-compute — making the 0G KV and TEE primitives available to any Node.js or Next.js application without requiring the full Parellax stack.

The infrastructure runs entirely on 0G: KV Storage via the turbo indexer and flow contract on Galileo, TEE inference via the 0G Compute router, and settlement on the 0G EVM chain. All three primitives are load-bearing — removing any one of them breaks the verifiability guarantees of the system.

The stack is Next.js 16 with React 19, wagmi v3, and viem for the frontend. MetaMask connects via @metamask/connect-evm.

The 0G integration uses three primitives directly. For storage, we use the @0gfoundation/0g-ts-sdk KvClient and Batcher to read spending limits and write audit log entries to a single KV stream identified by ethers.id('parellax.v1'), keyed by wallet address. For compute, we use the 0G Compute router at router-api-testnet.integratenetwork.work — it's OpenAI-API-compatible, so we use the openai SDK pointed at the custom base URL. We pass verify_tee: true in every inference request, which triggers on-chain signature verification by the provider and returns a tee_verified flag in the x_0g_trace response field. For chain settlement, we use viem's WalletClient and PublicClient to sign and submit vault release transactions.

The /api/transact route streams server-sent events to the dashboard so every pipeline stage — KV limit check, TEE eval, on-chain settlement, block confirmation — is visible in real time in the Thinking Terminal.

The storage and compute layers are published as standalone npm packages: @daiwikdomain/parellax-storage and @daiwikdomain/parellax-compute, usable in any Node.js project that needs 0G KV or TEE inference.