JakartAgents

1. PROJECT OVERVIEW

JakartAgents 0G is a production-deployed on-chain AI DeFi agent system running on 0G mainnet (chain ID 16661). Two specialized agent types operate continuously:

• TRADING agent (AgentType.TRADING = 1) — executes W0G/USDC.e swaps via Uniswap V3 native deployment on 0G, with signal analysis driven by 0G Compute TEE inference

• YIELD agent (AgentType.YIELD = 2) — stakes through Gimo Finance for on-chain yield, real stake(string referral) calls on 0xAc06d1Df…2135aF

Each agent run produces two cryptographically linked bundles:

1. Intent bundle (uploaded BEFORE execution): market context, news ingestion, signal generation, guardrail decisions, intended trades, TEE compute attestation, schema-versioned jakartagents/intent-bundle-v1

2. Result bundle (uploaded AFTER execution): execution txHashes, realized amounts, gas consumed, final positions, off-chain intentRootHash field linking back to the prior intent

Both bundles are uploaded to 0G Storage Log (returning 32-byte Merkle roots) and anchored to 0G Chain via the V3 AgentRunRegistry contract. The single anchorRun function is called twice per cycle with stage-prefixed runIdHash (keccak256("<runId>:intent") vs keccak256("<runId>:result")), enabling clean replay protection at the contract level via the anchoredRuns[agentKey][runIdHash] mapping. Third parties can fetch both bundles by Merkle root via the audit viewer, re-verify the TEE attestation client-side, recompute the bundle SHA-256, and reconstruct the entire decision-to-execution flow from on-chain truth.

2. THE PRE-COMMIT INTENT INNOVATION

THE POST-HOC PROOF ATTACK SURFACE

When an agent executes first and proves later, the proof can always be reverse-engineered. Model output, signals, and rationale can all be reconstructed AFTER the trade to make a favorable outcome look reasonable. There is no cryptographic constraint preventing this. AgentCourt and similar TEE-attested agents follow this pattern (inference → TEE attestation → storage → on-chain anchor of result) — verifiable that something ran in a TEE, but not that the rationale predated the action.

JAKARTAGENTS INVERTS THE ORDERING

The decision frame is committed before any execution call leaves the agent wallet:

analyze market → TEE inference (GLM-5-FP8) → guardrails

→ BUILD intent bundle

→ upload to 0G Storage Log (returns storageRoot)

→ anchorRun(agentKey, keccak256("<runId>:intent"),

eventsHash, storageRoot, computeModel)

→ [Block N — intent timestamped on-chain]

→ execute Uniswap V3 swap / Gimo stake

→ [Block N+M — execution timestamped strictly after intent]

→ BUILD result bundle with

bundle.intentRootHash = priorStorageRoot

→ upload to 0G Storage Log

→ anchorRun(agentKey, keccak256("<runId>:result"),

eventsHash, storageRoot, computeModel)

Consensus enforces block ordering. An operator cannot retroactively manufacture rationale to fit a known outcome because the intent root is already finalized in an earlier block. Replay protection via anchoredRuns[agentKey][runIdHash] mapping prevents re-anchoring the same stage twice.

VERIFIED LIVE ON V3 MAINNET (MAY 2026)

Trading agent E2E cycle:

Intent anchor tx block 33309506

0x0ab88b56ea14199b0873f96125306ba4019fec1d4dc29e18ae7057078a21b0c8

Intent rootHash 0xb65c9c2e56a5bfc610f48b89fe2c6907e1a26bdb2912ff7dfa27d8d306300240

Swap tx block 33309518

(W0G → USDC.e) 0x0a5c4192c369061866e01bd92ed20670cfc543bd900c0d1a6d5c166431aaf8e4

Result anchor tx block 33309540

0xda1fc0062bec82a2e7c84ce3012e93d9b264ea43261896debc57a390bce761928

Result rootHash 0x4524dbe905054ed414f87d946194c3b5092b8977bd8875f38b8772fb400ef1bc

Swap details: 0.005 W0G → 0.002706 USDC.e against 0.002692 minimum

(execution beat slippage threshold). Block gap intent → swap = 12 blocks; swap → result = 22 blocks. Yield agent E2E cycle:

Intent rootHash block 33292549

0x9005a1f328f36888bef7e17dda456a65d76b788fdffa637d6cc769cb80ef79d0

Stake tx block 33292570

(0G → st0G via Gimo) 0x176749400b8bdc23392498031024e37c37a86d5c61e695532e4eb056c109ee56

Result rootHash block 33292593

0x3088b3085ae056ceced3949d746229b890d85dfe77922907f3719fee29d798dc

Stake details: 0.05 OG → 0.038823 st0G. agentKey calldata =

0xb842a244…59bf57 = keccak256(uint8(2) ‖ owner), confirming AgentType.YIELD on-chain. All hashes queryable at https://chainscan.0g.ai.

================================================================================

3. SYSTEM ARCHITECTURE

================================================================================

Agent Cron

│

├── load agent state (positions, last-action, gas budget)

│ from 0G Storage KV

│

├── market context + news → 0G Compute TEE (GLM-5-FP8)

│ ← signals + reasoning + broker attestation

│

├── Rules Engine (confidence, gas, daily budget) → pass

│

├── Bundle Builder: createIntentBundle()

│

├── upload intent JSON → 0G Storage Log

│ ← storageRoot (32-byte Merkle)

│

├── anchorRun(agentKey,

│ keccak256(runId+":intent"),

│ eventsHash,

│ storageRoot,

│ computeModel)

│ on AgentRunRegistry V3

│ *** BLOCK N — intent committed on-chain ***

│

├── execute Uniswap V3 swap OR Gimo stake

│ ← txHash, amountIn, amountOut

│ *** BLOCK N+M — execution lands after intent ***

│

├── Bundle Builder: createResultBundle(intentRootHash=storageRoot)

│

├── upload result JSON → 0G Storage Log

│

├── anchorRun(agentKey,

│ keccak256(runId+":result"),

│ eventsHash,

│ storageRoot,

│ computeModel)

│

└── write updated state → 0G Storage KV

COMPONENT MAP

Orchestration apps/api/src/services/agent-cron.ts

Bundle builders apps/api/src/services/intent-bundle.ts

(canonical) createIntentBundle, createResultBundle,

buildAgentKey

LLM inference apps/api/src/services/llm-analyzer.ts →

zerog-compute.ts

Rules / guardrails apps/api/src/services/rules-engine.ts

Swap execution apps/api/src/services/uniswap-swap.ts,

trade-executor.ts

Stake execution apps/api/src/services/gimo-staking.ts

0G Compute broker wrapper apps/api/src/services/zerog-compute.ts

0G Storage Log apps/api/src/services/zerog-storage.ts

(Indexer + ZgFile)

0G Storage KV apps/api/src/services/zerog-storage-kv.ts

(KvClient)

0G Chain anchor apps/api/src/services/zerog-anchor.ts

(calls anchorRun at line 72)

INFT V3 client apps/api/src/services/inft-client.ts

Audit viewer (frontend) apps/web/src/app/audit/[rootHash]/page.tsx

Agent profile (frontend) apps/web/src/app/agents/[tokenId]/page.tsx

Trading agent UI apps/web/src/app/(app)/trading-agent/page.tsx

================================================================================

4. 0G MODULES USED

================================================================================

--------------------------------------------------------------------------------

4.1 0G COMPUTE TEE

--------------------------------------------------------------------------------

SDK: @0glabs/0g-serving-broker@^0.7.8

(canonical re-export shim for

@0gfoundation/0g-compute-ts-sdk@0.8.0)

Model: zai-org/GLM-5-FP8 (exact identifier passed to broker)

Verifiability tier: teeml (verified via

service.verifiability.toLowerCase().includes('teeml')

filter at provider selection)

Ledger: 0x2dE54c845Cd948B72D2e32e39586fe89607074E3

(3 0G minimum initial deposit enforced at contract

level)

Every inference returns a providerSigner, providerAddress, and chatId attested by the broker SDK processResponse flow. These fields are embedded in the intent bundle as a ComputeAttestation object and re-verifiable by any third party with the same SDK. The audit viewer surfaces the attestation status alongside the bundle.

Code: apps/api/src/services/zerog-compute.ts

--------------------------------------------------------------------------------

4.2 0G STORAGE LOG

--------------------------------------------------------------------------------

SDK: @0gfoundation/0g-storage-ts-sdk@^1.2.9

(single package providing both Log + KV)

Primitive: Indexer.upload(ZgFile) returns a 32-byte Merkle root via

tree.rootHash()

Both intent and result bundles are stable-serialized JSON, content-addressed, and uploaded to the Log layer. The returned rootHash becomes the on-chain storageRoot parameter to anchorRun. The bundle body also carries a separate bundleHash (SHA-256 of the serialized JSON) used by the audit viewer for redundant integrity verification.

Code: apps/api/src/services/zerog-storage.ts

--------------------------------------------------------------------------------

4.3 0G STORAGE KV

--------------------------------------------------------------------------------

SDK package: same as Log, KvClient import

Stream ID: single fixed stream (ZEROG_KV_STREAM_ID, default 0x...0001)

Key shape: agent:{walletAddress.toLowerCase()}:{agentType}:{field}

hashed via ethers.id(...)

Cross-cycle agent state persists in the KV layer: open positions, last

action timestamp (cooldown enforcement), daily gas budget consumed, cumulative P&L. App-level namespacing under a single stream keeps writes cheap and lookups predictable while supporting an unlimited number of agents per wallet.

Code: apps/api/src/services/zerog-storage-kv.ts

--------------------------------------------------------------------------------

4.4 0G CHAIN — AGENTRUNREGISTRY V3

--------------------------------------------------------------------------------

Address: 0x4aF02b8D48f4D9e3943FE6352a659a7987785e2c

Deploy block: 33130340 (May 2026)

Solidity: 0.8.24 pinned (Foundry, EVM target cancun)

Registration scheme: eip712_owner_sponsored_v1

V3 introduces several primitives that make the contract production-grade:

SINGLE ANCHOR FUNCTION FOR BOTH STAGES

function anchorRun(

bytes32 agentKey,

bytes32 runIdHash,

bytes32 eventsHash,

bytes32 storageRoot,

string calldata computeModel

) external

The same call serves intent and result. Stage distinction lives in

runIdHash = keccak256("<runId>:intent") vs keccak256("<runId>:result").

This collapses contract surface area while preserving clean replay protection via:

mapping(bytes32 => mapping(bytes32 => bool)) public anchoredRuns;

Second anchor of the same (agentKey, runIdHash) reverts with "Run already anchored".

EIP-712 SPONSORED REGISTRATION

function registerAgentFor(

address owner,

address agentWallet,

AgentType agentType,

bytes32 metadataRoot,

uint256 deadline,

bytes calldata signature

) external returns (bytes32 agentKey)

Owner pre-signs an EIP-712 typed message; agentWallet (hot wallet) submits the registration on-chain. Per-owner nonces in

mapping(address => uint256) public nonces prevent signature replay. This

enables cold-owner / hot-agent-wallet separation: the owner key never

needs to be online to register or operate the agent.

EXTENDED ANCHOR AUTHORIZATION

require(msg.sender == profile.owner

|| msg.sender == profile.agentWallet, "not authorized");

The hot agentWallet can anchor on behalf of the cold owner. V2 collapsed both wallets; V3 separates them, enabling the standard hot-cold security pattern used in production custody systems.

CUSTOM ERRORS WITH EXPLICIT REVERT MESSAGES

"Invalid agentKey for sender", "Run already anchored",

"Invalid signature", "Signature expired"

Every failure path surfaces a clear reason.

Code: contracts/src/AgentRunRegistry.sol

--------------------------------------------------------------------------------

4.5 UNISWAP V3 ON 0G

--------------------------------------------------------------------------------

Factory: 0x6F3945Ab27296D1D66D8EEb042ff1B4fb2E0CE70

SwapRouter: 0x18cCa38E51c4C339A6BD6e174025f08360FEEf30

Demo pool W0G/USDC.e (1% fee): 0x159fe1d57b464ed60e2bfbbca0df444999131673

The TRADING agent executes via exactInputSingle on the native Uniswap V3 deployment on 0G mainnet. Live cycle (block 33309518) swapped 0.005 W0G →

0.002706 USDC.e against a 0.002692 minimum, beating the slippage

guardrail. Price feeds derive from pool slot0 (spot) and observe() (TWAP) with no external oracle dependency. Self-contained price discovery keeps the entire agent stack on the 0G chain.

Code: apps/api/src/services/uniswap-swap.ts, price-service.ts

--------------------------------------------------------------------------------

4.6 ERC-7857 — JAKARTAGENTINFT V3

--------------------------------------------------------------------------------

Address: 0x8A5e4fBe2f65f6cFa71B3263D2BDf7b872225415

Standard: ERC-7857 (transferable AI agent NFT, co-authored by 0G CTO

Ming Wu)

Each AgentType (TRADING, YIELD, ARB, FX-legacy) is mintable as an INFT. The agent's tokenId is embedded in every intent and result bundle, creating a permanent on-chain link between the agent identity NFT and its decision history. Because agentKey = keccak256(uint8(agentType) ‖ ownerAddress) is derivable from the token, transferring the INFT transfers the agent — including its full committed history visible via the audit viewer. The composable identity layer turns each agent into a portable, tradeable asset on 0G.

Code: contracts/src/JakartAgentINFT.sol,

apps/api/src/services/inft-client.ts

--------------------------------------------------------------------------------

4.7 GIMO FINANCE INTEGRATION (YIELD AGENT EXECUTION)

--------------------------------------------------------------------------------

Stake contract: 0xAc06d1Df23a4Fa00981aFAC0f33A5936Bd2135aF

Function: stake(string referral) — called with empty string

Real 0G → st0G staking executed on mainnet via the YIELD agent. Live cycle (block 33292570) staked 0.05 OG and received 0.038823 st0G.

Code: apps/api/src/services/gimo-staking.ts

================================================================================

5. ENGINEERING STRENGTHS

================================================================================

PRE-COMMIT INTENT ORDERING, ENFORCED BY CONSENSUS

The differentiator is structural, not a UX layer. Block ordering between intent anchor (e.g. 33309506) and execution (33309518) is enforced by the chain, not by application logic. No retroactive rationale reconstruction is possible.

SIX NATIVE 0G INTEGRATIONS

Compute TEE + Storage Log + Storage KV + Chain (AgentRunRegistry V3) + Uniswap V3 (native 0G deployment) + ERC-7857 (JakartAgentINFT V3), plus Gimo Finance as a bonus execution venue. Each integration is real on mainnet.

TWO AGENT TYPES PROVING THE PATTERN IS AGENT-TYPE AGNOSTIC

TRADING (Uniswap V3 swap) and YIELD (Gimo stake) share the same agentKey → intentRoot → resultRoot flow. The pattern extends cleanly to ARB and additional types reserved in the AgentType enum.

REAL ECONOMIC ACTIVITY ON MAINNET

Trading agent swap (0.005 W0G → 0.002706 USDC.e, block 33309518) and yield agent stake (0.05 OG → 0.038823 st0G, block 33292570) are settled trades on production contracts.

EIP-712 SPONSORED REGISTRATION WITH HOT-COLD WALLET SEPARATION

V3 registerAgentFor lets a cold owner pre-sign authorization while a hot agentWallet executes operations. Per-owner nonces prevent signature replay. This is the standard custody-pattern abstraction every production agent system needs.

SINGLE ELEGANT ANCHOR FUNCTION FOR BOTH STAGES

anchorRun is called twice per cycle with stage-prefixed runIdHash. Replay protection via (agentKey, runIdHash) → bool mapping. Smaller contract surface, cleaner audit, less attack area.

DETERMINISTIC AGENT IDENTITY

agentKey = keccak256(uint8(agentType) ‖ ownerAddress) is reproducible

client-side and re-verified on-chain — any client passing the wrong shape reverts with "Invalid agentKey for sender". No off-chain registry needed.

SELF-CONTAINED PRICE DISCOVERY ON 0G

Pool slot0 + observe() TWAP, no external oracle. The TRADING agent's signal pipeline runs entirely on 0G infrastructure.

MULTI-TIER AI RESILIENCE

Primary path is 0G Compute TEE (GLM-5-FP8). Secondary providers from the broker's service marketplace. The Vercel AI SDK with @ai-sdk/google integrates transparently when the operator opts for it, and a usedFallback flag in the bundle makes the inference source explicit on the verification side.

SOLIDITY 0.8.24 WITH CANCUN EVM TARGET

Foundry toolchain. transient storage where appropriate, ReentrancyGuardTransient pattern. Production hardening.

FULL AUDIT VIEWER WITH ON-CHAIN VERIFICATION

Frontend route /audit/[rootHash] fetches the bundle from 0G Storage Log via Indexer.download, recomputes the Merkle root and bundleHash, calls registry.anchoredRuns(agentKey, runIdHash) to confirm the on-chain anchor, and surfaces verification state to the viewer. No trust in the agent operator required.

================================================================================

6. MAINNET DEPLOYMENTS

================================================================================

All contracts on 0G mainnet (chain ID 16661), RPC https://evmrpc.0g.ai ACTIVE V3 CONTRACTS (canonical)

AgentRunRegistry V3 0x4aF02b8D48f4D9e3943FE6352a659a7987785e2c

JakartAgentINFT V3 0x8A5e4fBe2f65f6cFa71B3263D2BDf7b872225415

0G + DEFI INFRASTRUCTURE

0G Compute Ledger 0x2dE54c845Cd948B72D2e32e39586fe89607074E3

Uniswap V3 Factory 0x6F3945Ab27296D1D66D8EEb042ff1B4fb2E0CE70

Uniswap V3 SwapRouter 0x18cCa38E51c4C339A6BD6e174025f08360FEEf30

W0G 0x1Cd0690fF9a693f5EF2dD976660a8dAFc81A109c

USDC.e 0x1f3AA82227281cA364bFb3d253B0f1af1Da6473E

Demo W0G/USDC.e pool (1% fee) 0x159fe1d57b464ed60e2bfbbca0df444999131673

Gimo Finance Staking 0xAc06d1Df23a4Fa00981aFAC0f33A5936Bd2135aF

HISTORICAL V2 CONTRACTS (readable for past audit cycles)

AgentRunRegistry V2 0x91aeF15B9568794D6AbC04ff7d4866C5a6Bb53d1

JakartAgentINFT V2 0x7c25c4e9bB6A91265682730016fC22c3Cde9892C

================================================================================

7. REVIEWER NOTES — PRE-VERIFIED CYCLES

================================================================================

Judges can verify the entire pre-commit flow on-chain without local setup. Every hash below is decodable from 0G mainnet calldata via any RPC client.

--------------------------------------------------------------------------------

TRADING AGENT E2E (V3 cycle, May 2026)

--------------------------------------------------------------------------------

Intent anchor txHash

0x0ab88b56ea14199b0873f96125306ba4019fec1d4dc29e18ae7057078a21b0c8

Intent block

33309506

Intent rootHash (storage Merkle)

0xb65c9c2e56a5bfc610f48b89fe2c6907e1a26bdb2912ff7dfa27d8d306300240

Intent eventsHash (bundle SHA-256)

0x27a4f0b80b826baef2bc3f0b060ff2c61f00f49538bd5a3165f64ae24b38eb67

Intent runIdHash

0x5c0b34ef853211bc3fc273ffb2cbb9050f9ba8296cd7c0de29d9d95cea3b0766

agentKey (TRADING)

0x3e26c2cc27562185a0e5aa39ab0f7d8b8f36a8932d3b6a1da22dc6c7bce661e8

Swap txHash (W0G → USDC.e)

0x0a5c4192c369061866e01bd92ed20670cfc543bd900c0d1a6d5c166431aaf8e4

Swap block

33309518

Swap detail

0.005 W0G in → 0.002706 USDC.e out (vs 0.002692 minimum)

Result anchor txHash

0xda1fc0062bec82a2e7c84ce3012e93d9b264ea4326189debc57a390bce761928

Result block

33309540

Result rootHash

0x4524dbe905054ed414f87d946194c3b5092b8977bd8875f38b8772fb400ef1bc

Result eventsHash

0x569fa4bd32c3c010cff5679f1d17a0c309df644733753ce590913592f2c881a8

Compute model (calldata): zai-org/GLM-5-FP8

Block gaps: intent → swap: 12 swap → result: 22

--------------------------------------------------------------------------------

YIELD AGENT E2E (V3 cycle, May 2026)

--------------------------------------------------------------------------------

Intent rootHash

0x9005a1f328f36888bef7e17dda456a65d76b788fdffa637d6cc769cb80ef79d0

Intent block

33292549

agentKey (YIELD)

0xb842a244f5df3cbad44092324d0d8a62865f453b97e976812f3da26bae59bf57

Stake txHash (0G → st0G via Gimo)

0x176749400b8bdc23392498031024e37c37a86d5c61e695532e4eb056c109ee56

Stake block

33292570

Stake detail

0.05 OG in → 0.038823 st0G out

Result rootHash

0x3088b3085ae056ceced3949d746229b890d85dfe77922907f3719fee29d798dc

Result block

33292593

Block gaps: intent → stake: 21 stake → result: 23

AUDIT URLS

Frontend audit viewer (trading intent):

https://https://jakartagents-web.vercel.app/audit/

0xb65c9c2e56a5bfc610f48b89fe2c6907e1a26bdb2912ff7dfa27d8d306300240

Frontend audit viewer (yield intent):

https://https://jakartagents-web.vercel.app/audit/

0x9005a1f328f36888bef7e17dda456a65d76b788fdffa637d6cc769cb80ef79d0

API endpoint:

GET https://[API_HOSTED_URL]/api/zerog/audit-bundle/:rootHash

HOSTED INFRASTRUCTURE

Frontend (Vercel): https://jakartagents-web.vercel.app/

API (Render / Railway): jakartagentsapi-production.up.railway.app

BLOCK EXPLORER & RPC

Chainscan: https://chainscan.0g.ai

Mainnet RPC: https://evmrpc.0g.ai

Chain ID: 16661 (0x4115)

================================================================================

8. LOCAL REPRODUCTION STEPS

================================================================================

PREREQUISITES

• Node.js 20 or later

• pnpm 9 or later

• Wallet funded with at least 5 0G on chain 16661 (gas + Compute ledger

initialization)

• Faucet: https://faucet.0g.ai (0.1 0G/day per wallet)

CLONE AND INSTALL

git clone https://github.com/imferdinandd/jakartagents/

cd jakartagents-0g

pnpm install

CONFIGURE ENVIRONMENT

cp .env.example apps/api/.env

Required env vars:

WALLET_PRIVATE_KEY=0x... # agent wallet (hot)

OG_RPC_URL=https://evmrpc.0g.ai

OG_CHAIN_ID=16661

ZEROG_NETWORK=mainnet

ZEROG_COMPUTE_MODEL=zai-org/GLM-5-FP8

ENABLE_YIELD_AGENT=true # opt-in YIELD agent

INITIALIZE 0G COMPUTE LEDGER

3 0G minimum initial deposit (contract-enforced):

pnpm --filter @jakartagents/api fund-compute 3

SMOKE TESTS

# GLM-5-FP8 TEE inference

pnpm --filter @jakartagents/api smoke-tee

# Uniswap V3 swap (~$0.50 W0G)

pnpm --filter @jakartagents/api smoke-swap

# Full E2E yield: TEE → bundle → anchor → Gimo stake → result anchor

pnpm --filter @jakartagents/api audit-yield-cycle

RUN END-TO-END

pnpm dev:api # API + agent cron, port 4000

pnpm dev:web # frontend, port 3000

Trigger a manual cycle via authenticated request:

POST http://localhost:4000/api/agent/run-now

# JWT auth required (wallet sign-in)

# routes to runAgentCycle(config) for the JWT's wallet

# → agent_configs row

VERIFY A COMMITTED BUNDLE

Frontend: http://localhost:3000/audit/<rootHash>

API: GET http://localhost:4000/api/zerog/audit-bundle/:rootHash

Both paths fetch the bundle from 0G Storage Log via Indexer.download, recompute Merkle root + bundle SHA-256, query registry.anchoredRuns(agentKey, runIdHash) to confirm the on-chain anchor, and return { bundle, verification, explorer }.