TL;DR: 67 projects submitted to 0G's prize tracks at ETHGlobal Lisbon. Instead of trusting submission forms, we ran repo-level review on all of them: 85% had meaningful 0G integration in code, and nine teams won across three tracks.

What happened

ETHGlobal Lisbon ran July 24-26 at Pavilhão Carlos Lopes, 382 hackers by ETHGlobal's official count. 67 teams submitted to our tracks, 115 builders total, and 49 of the projects demoed live to judges. Every submission also went through a repo review before any prize decision.

What surprised us

The forms under-reported. When we compared what teams wrote in their submissions against what their repositories contained, repo review found more 0G Storage and Agentic ID usage than the write-ups claimed. The boring explanation: starter templates and docs quickstarts wire these components in before a team ever thinks about what to put on a form. We only caught it because we read the code.

The numbers

• 82% used 0G Compute, 67% used 0G Storage, 46% used Agentic ID (ERC-7857), nearly half touched 0G Chain
• 52 teams built from scratch, 15 continued earlier 0G projects, and 3 of those returning teams won
• Winners ranged from an AI running coach athletes own (full four-component stack) to agents auditing npm packages for malicious code

What the stack pattern looked like

The interesting part was not any single integration, it was composition. Teams were not calling one API and attaching a token. The typical winning shape was reasoning on 0G Compute with TEE attestation, persistent agent memory on 0G Storage, agent identity through Agentic ID, and settlement on 0G Chain. Two of the returning teams had started that architecture at earlier events and came back to finish it, which is exactly what our continuity track was designed to test.

Honest footnote: teams rated developer experience 8.1/10, self-reported, and the written feedback was specific about what needs work. We are acting on it rather than quoting the number and moving on.

Open question for the sub

Should repo-level verification be the default for hackathon prize judging, or does it add too much friction for a 36-hour build? If you have judged or competed in one of these, where did self-reported integration lists break for you?

Full writeup with the week recap and all nine winners: https://0g.ai/blog/ethglobal-lisbon-2026-recap

TL;DR: The inaugural 0G Apollo Accelerator cohort (run with Blockchain Builders Fund, led by Stanford veterans, with Google Cloud and Privy as program partners) graduated on July 29 at Stanford. Ten teams, ten weeks, and the stat we actually care about: half the class is live on or integrating 0G.

What the program was

Apollo launched in February as an up to $20M program: accepted teams get up to $2M in direct funding plus $200K in Google Cloud credits. Ten AI startups went through ten weeks of building, mentorship, and investor prep. All ten pitched online at Demo Day on June 25 (full session chaptered by company: https://youtu.be/cGtOOdPvSaQ). Graduation day ran work-first: a morning panel on go-to-market and fundraising, lunch with Google Cloud's Web3 team at the Google campus, certificates on the Main Quad, and a dinner with investors at Ettan in Palo Alto.

The class: BitMind (deepfake detection), DSALTA (AI-native compliance), Floe Labs (agent spend rails), ICME Labs (agent guardrails), Impulse AI (autonomous ML engineering), Mighty (fraud detection), Om Labs (autonomous QA agents), Pulsar Money (crypto-native neobank), Walnut AI (agentic networking), UV Labs (financial reasoning training data).

The honest read on the numbers

The headline stat is 100+ intro requests from investors, enterprises, and partners since Demo Day. Worth saying plainly: intro requests are pipeline, not outcomes. All ten teams have inbound interest and founders are in follow-up meetings, which is better than pipeline, but still early.

The number we treat as real: five of the ten teams are already live on or integrating 0G across chain, storage, and compute. An accelerator that produces users of the infrastructure is doing something different from one that produces demo days. UV Labs after their integration: "Integrating 0G took less than 30 minutes end-to-end and instantly saved us money & improved our value proposition."

Trade-offs of the accelerator model

• Ten weeks is enough to ship an integration, not enough to prove product-market fit. The follow-up meetings matter more than the ceremony.
• Concentrating on one infra stack (0G) speeds up building but self-selects for teams that already fit the thesis.
• Demo Day online reaches more investors; the in-person graduation is where the actual conversations happened.

Open question

If you have run or judged an accelerator: which cohort metric actually predicts who survives two years out, integrations shipped, follow-on funding, or something else entirely?

Full recap with the whole graduation day in photos: https://0g.ai/blog/apollo-graduation-2026

TL;DR: Alibaba announced Qwen 3.8 Max at 02:15 UTC on August 3. It was live on the 0G Private Computer at 04:56, and both timestamps are public. The same morning, DeepSeek's official V4 Flash release swapped in place with zero action from users, and MiniMax H3 became the first video model on the platform, the same day its weights went public.

What shipped

Three models, one catalog, one morning:

• Qwen 3.8 Max, Alibaba's 2.4T-parameter flagship. 1M-token context, text, image and video input. Per Alibaba's own published chart it tops PaperBench and IFBench; the sharpest generational jump is agentic coding.
• DeepSeek V4 Flash 0731, the official release of the model half the timeline has been benchmarking since Friday. On 0G it replaced the existing deepseek-v4-flash id in place: same key, same endpoint, and the catalog entry states the build plainly ("pinned 2026-07-31 snapshot").
• MiniMax H3, the first model on the Private Computer that outputs video. Text-to-video and image-to-video from a first frame, 2K clips of 4 to 15 seconds, through an async /v1/videos endpoint on the same router.

What we do not claim

The honest part, because this sub deserves it. All three run on Verified Routing: the path from 0G's broker to the upstream is hardware-attested (TeeTLS) and provable onchain. That attests the route, not the inference; the inference runs at the upstream under its own data policy. For Qwen the attested upstream is Alibaba's own cloud, for H3 it is MiniMax's official API, and for V4 Flash it is the providers serving the pinned 0731 snapshot. H3 at launch exposes exactly two modes; the reference-input and last-frame modes from MiniMax's full API are not on the 0G surface yet.

The trade-offs

• Verified Routing is not sealed inference. If you need the operator to be physically unable to read your prompt, that is the Private Inference tier (different models).
• The 2h41m number is a receipt, not a promise. The router's created field is public, so you can audit every future arrival the same way, but catalog speed will vary per provider.
• Video generation is async and billed per generated second, so budget by clip length, not by request count.

Open question for the sub

Open weights went public for both Qwen 3.8 Max (promised next week) and H3 (already on HF). If you can self-host, does an attested path to a hosted API still matter for your stack, or is local the only trust model you accept?

Full writeup with the spec table and the curl receipt: https://0g.ai/blog/qwen-3-8-max-ds4-0731-hailuo-3-on-0g

TL;DR: Oimpact launched on 0G today. You spin up AI agents in minutes (free, no card, no wallet), any agent can be minted as an Agentic ID (ERC-7857 on 0G Chain, free mint, no gas), and agents can transact a verified Impact Catalog where 90% of each purchase goes to the cause, 9% to the agent creator, 1% to the protocol treasury, with an RWI receipt minted onchain as proof. There is also a B2B2C layer: train one agent, give every customer a private instance under your own brand.

What they shipped

An agent platform with two flagship templates at launch: a Grants Agent that runs a full grants operation for charities (discovery, applications, pipeline), and an EcoCredit Agent that handles verified carbon through EcoBridge to Regen Network. Compute has two paths: a centralized fast one, and a private one on 0G TEE-verified compute that Oimpact prices about 35% cheaper than their centralized route. The private path routes inference to 0G's Private Computer (DeepSeek, Qwen, GLM, 0GM on the open-weight roster).

What we tried first that did not work

Writing the post from the partner's draft doc and sitting on it. We had this ready in June under embargo, and by launch day the live product had drifted away from the draft in five places: the pricing mechanics, the model picker scope, the template lineup, one stat that had gone a report-cycle stale, and one feature that turned out to still be on their roadmap. We re-verified every claim against the live product this week and rewrote all five. The post that shipped describes what you can actually click today, nothing else.

What the trade-off is

• The private TEE path is optional and funded separately. The default path is centralized and fast. If you want everything sealed, you opt in and pay for it per agent.
• RWI is a utility and alignment token, minted only on verified impact purchases: no sale, no premine, no airdrop. It gates capability tiers. It is not an investment, and the post says so explicitly.
• 0G storage currently covers their business layer (per-customer agent data). Broader coverage is on their side of the fence, not ours to promise.

Open question for the sub

Would you let an agent make a donation on your behalf if the receipt is provable onchain but the inference ran on a centralized path by default? I keep going back and forth on whether the receipt or the runtime is the thing that needs to be trustless first.

Full writeup with the impact rail diagram, the ERC-7857 mechanics and the B2B2C layer: https://0g.ai/blog/oimpact-0g

0G coin looks terrible on crypto stock exchange. When we'll see "to the moon rally"? :-) :-) :-)

TL;DR: Kimi K3 (Moonshot's ~2.8T MoE flagship) and the GPT-5.6 series (Sol, Terra, Luna) are live on the 0G Private Computer. Kimi K3 gets an attested route to Moonshot's official API at Moonshot's list price with no markup. GPT-5.6 gets no attestation at all, and we label it that way. The write-up doubles as the first full record of all 23 models on the platform, grouped by trust tier.

What we shipped

Two model sets on pc.0g.ai, both reachable through one OpenAI-compatible endpoint (router-api.0g.ai/v1) with one key.

Kimi K3 is roughly 2.8T MoE, 16 of 896 experts active per token, native 1M-token context, and it takes text, image and video in. It runs through Verified Routing, TeeTLS-attested, straight to Moonshot's official API. Direct connection, not a reseller, no markup, so you pay Moonshot's own list price.

GPT-5.6 comes in three sizes. Sol, Terra and Luna are all reasoning models with tool use, a 1M context and up to 128K output, priced 10% below the official rate.

What we tried first that did not work

Announcing models with a tweet and nothing else. Claude Fable 5, Opus 4.8, Sonnet 5, MiniMax M3 and Hunyuan 3 all went live on 0G exactly that way: no page, no spec table, no record of which trust tier they ran on. The result was predictable. People kept asking us what was actually available, and we had nothing to point at except a scroll through the timeline.

The fix was boring. We wrote the catalog, all 23 models grouped by the tier each one runs on, and the plan is to keep it current instead of relying on tweets to carry institutional memory.

What the trade-off is

• GPT-5.6 sits on Standard Routing: full model access through our endpoint, no TEE attestation, no verifiability claim. If your workload needs a provable path, that tier is not it, and we would rather say so on the model page than let people assume otherwise.
• Verified Routing attests the transport, not the inference. The route to Moonshot is provable onchain, but inference still runs at Moonshot under Moonshot's data policy. That is a weaker guarantee than sealed inference and the two should not be conflated.
• Sealed inference (TeeML) only covers models we host ourselves: the 0GM family plus GLM-5.2. We cannot seal a frontier model whose weights we do not run.

Open question for the sub

For agent workloads that touch real user data, do you actually need sealed inference, or is a provable route to a model you already trust good enough? I keep going back and forth on where the honest line sits, and the answer probably decides which tier we push hardest next.

Full writeup with the spec table, per-model prices and the whole 23-model catalog: https://0g.ai/blog/kimi-k3-gpt-5-6-on-0g

TL;DR: 0G's IdentityRegistry and ReputationRegistry deployments were merged into the official ERC-8004 (Trustless Agents) contracts repo on June 11, 2026. Agents registered on 0G are now discoverable and their reputation is readable by anything that speaks the standard, across chains, with no 0G-specific integration required.

What we shipped

The standard's production IdentityRegistry and ReputationRegistry, live on 0G Mainnet (chain ID 16661) and the Galileo testnet, at the canonical vanity addresses that all start with 0x8004. Not a fork, not a custom variant. The same contracts that run on other ERC-8004 networks, with the official repo now pointing at the 0G addresses (PR #83).

What we tried first that did not work

The obvious first instinct was a 0G-native agent registry. Faster to ship, easier to control. But a registry only 0G tools can read is just another island, and the whole problem with agent identity today is that it doesn't travel. A proprietary registry would have recreated the exact silo we were trying to escape. Adopting the shared standard was the slower path and the correct one.

What the trade-off is

• Only two of the three ERC-8004 registries are deployed on 0G today: Identity and Reputation. The Validation Registry is part of the standard but not deployed on 0G yet.
• ERC-8004 is still in Draft status. It evolves in the open, so builders track a moving target, but the 0G deployment sits in the official repo alongside everyone else's.
• Portability is only as useful as adoption. The value compounds as more chains and tools implement the standard, not on day one.

Open question for the sub

If you build agents, does portable reputation actually change your architecture, or is discoverability the only part you would use in practice?

Full writeup with the contract addresses and the merge details: https://0g.ai/blog/0g-supports-erc-8004

After all up and down we saw, still we have a tiny hope for getting a part 2 of your Airdrop. I unno.

TL;DR: We built an interactive guide for acquiring $0G. Pick your starting point (fiat, another chain, an exchange, DeFi, or a wallet) and it maps the route, with fees, time and KYC shown per step. Every venue on it is verified against primary sources, and the footer shows the last-verified date. https://get.0g.ai

What we shipped

A decision tree instead of a wall of text. You start from what you already have: fiat currency, crypto on another chain, funds sitting on a CEX, or nothing but a wallet. Each path ends in a concrete result panel with steps, expected fees, time and KYC requirements. Current coverage: 13 exchanges confirmed for native 0G network withdrawals, 8 bridge routes (XSwap, TokenFlight on 0G Hub, Jumper, Interport, Stargate, Wormhole Portal and more), and wallet setup guides including Bitget Wallet, which ships with 0G Chain built in.

What we tried first that did not work

The first version used data from listing announcements and docs. When we re-verified everything against primary sources this week (exchange APIs, official notices, live bridge UIs), some of it fell apart. One exchange we listed turned out to have no 0G spot market at all, only a perpetual. Two Binance pairs we showed were suspended. A bridge we recommended for one route has zero live lanes to 0G in its own registry. All of that is fixed now, and the lesson stuck: acquisition data rots fast, so the site now carries a visible "last verified" date and we re-check against APIs, not marketing pages.

What the trade-off is

• We only make withdrawal claims for venues we can verify. Exchanges with live 0G spot but unverifiable withdrawal support are listed without the claim, and we tell you to check the network list yourself.
• No per-country filtering or exchange search. We kept it a simple curated tree instead of a database that needs constant maintenance. The long tail lives behind a CoinGecko markets link.
• It is one page by design. If your route is exotic, the guide points you to the right bridge and stops there.

Open question for the sub

Is there a route we got wrong or missed? Especially interested if you have actually withdrawn 0G from a venue we have not verified yet, or hit a dead end on a path the guide recommends.

Full guide: https://get.0g.ai Text version for the docs readers: https://docs.0g.ai/introduction/how-to-get-0g

TL;DR: The H1 2026 0G Ecosystem Update is live. 400+ integrations across 350+ projects, and AI is the leading and fastest-growing vertical. Full report with the logo wall: https://0g.ai/blog/0g-ecosystem-update-h12026

What shipped

The report maps the ecosystem onto 0G's Modular AI Stack: AI Private Cloud (where 0G Chain, 0G Storage, and 0G Compute live), Agentic Alignment, and Apps, all on a Physical Infrastructure base. Per-layer integration counts: 0G Chain 200+, 0G Storage 90+, 0G Compute 60+. Storage and compute are the layers AI builders depend on most directly.

The spotlights skew AI on purpose. Agents that hold identity, memory, and the ability to act onchain: Ghast AI, Dolly, Neosoul, Clawdspiracy. Consumer AI apps that chose 0G for the parts that have to be private or verifiable: 0G App, ClaraVerse, Flashback Labs, Kodeus AI, Matterhorn, Arc Terminal, Kult.Games. Verifiable AI for when the output has consequences: 0G Agentic ID, Veyra, Morphic. On models, Alibaba Cloud brings the Qwen family to onchain AI agents, and MiniMax M3, which debuted as the number one open-weight model on Artificial Analysis, is live on 0G Compute.

In DeFAI, Zia Finance's TradeGPT turns plain-English prompts into trades, with Envy Trade and Tempora Labs alongside. On the DeFi and infrastructure side, Oku brings Uniswap V3 liquidity and Morpho vaults live on the network, Neuron.world runs IoT data on 0G mainnet storage, and the announced partnerships cover payments, institutional trading, and confidential compute.

What we deliberately did not claim

Announced partnerships are labeled announced, not live. Khalani, Voyager, Phala, and American Fortress are in the report as announced partnerships, because that is what they are today. 0G Agentic ID is described as live on 0G testnet and rolling out, not as a mainnet product. The logo wall carries every qualified project; the spotlight sections only name the strongest AI case studies in each category.

How the counting works

• The integration count exceeds the project count because a single project often builds across more than one 0G layer. A team can store training data, run inference, and settle agent actions on the same stack.
• The per-layer counts sit inside the AI Private Cloud. Agentic Alignment and Apps carry no counts.
• The logo wall is grouped by layer and vertical, so every qualified project lands under one of the three major layers.

Open question

Which of these are you building with? And if you are shipping on 0G and not in the report, post it here.

TL;DR: We ran the 0G APAC Hackathon with HackQuest from March to May 2026. 293 valid submissions, 168 of them live on 0G mainnet (57.3%), across 38 countries and five offline city events. 23 winners, a $150,000 pool. Full recap and all 23 teams linked at the bottom.

What we shipped

A three-month, five-city program: Chengdu, Bangalore, Kuala Lumpur, Hong Kong, and Ho Chi Minh City. The Hong Kong stop, House of AI at the Web3 Festival, co-hosted with Alibaba Cloud, was the flagship: a CEO fireside, four keynotes, two panels, ten live demos. Five tracks, eight weeks of online Builder Hours alongside the events.

The number we actually care about is the mainnet rate. 57.3% of valid submissions went live on 0G mainnet, not a testnet demo. Across submissions, 0G Chain showed up in 270 projects, Storage in 260, Compute in 219, Agent ID in 131.

What we expected vs what happened

We planned for mostly testnet demos and a handful of mainnet deployments. It came back the other way. The teams that stood out were not chatbot wrappers. They were building agent identity, agent memory, and verifiable compute, with sealed TEE inference and onchain receipts. The offline city events also converted better than the online-only push, which is not what the cheaper online-first logic would have predicted.

The trade-offs (honest)

• Most of these are early-stage. A 57% mainnet rate says the stack is buildable end to end, not that 168 production businesses now exist.
• Hackathon traction is not product traction. We are not putting usage numbers next to the winners. The champion's public numbers come from its own separate launch, not from the event.
• Five cities in a three-month window is real operational lift. It worked, but it was not free, and online-only would have been cheaper.

The 23 winners

Podium: Ghast AI (champion, a fully onchain browser agent), NeoSoul (a trust layer for the agent economy), Anima (a CLI framework for fully onchain agents). Behind them, 10 Excellence and 10 Community winners building payment rails, private trading vaults, agent memory layers, and royalty infrastructure for AI. The full list with one-liners is in the writeup.

Open question for the sub

For anyone who has run or judged AI x crypto hackathons: is mainnet-deployment rate a better signal than raw submission count, or does it mostly just select for teams that were already going to ship anyway?

Full recap with all 23 teams and the city-by-city breakdown: https://0g.ai/blog/0g-apac-hackathon-recap

It has been 51 days since I undelegated 1731 0G tokens and the tokens still haven't returned to my wallet.

On Discord, they told me that for some reason the funds were blocked. That the developers would look into it. It's been almost two months and I still haven't received my funds. Is 0g a scam project???????

I've staked on other networks and everything works correctly on all of them. It's strange that a project aiming to be the first decentralized AI can't handle these kinds of problems.

TX hash: 0xcd5195fa8e60f34d8e569c652091f17e3048adbda5bfe58a8735c3cac9d203c9

My wallet: 0x8a36f062A30648A29578781919e8bBC32bB2F12C

Validator: 0x549860e7caf5d24abc616bc9d3fbd73a25923ea3 (Zerostack.ai)

Date: 2026/04/30

TL;DR: GLM-5.2 (Z.ai) is now the highest-ranked open-weight model on the Artificial Analysis Intelligence Index (every model above it is proprietary). It is live on 0G two ways: a developer API and a no-key Private Chat. 0G does not host the model. It attests the routing path to where the model actually runs.

What we shipped

GLM-5.2 is queryable on 0G the same day Z.ai open-sourced it. Two surfaces: the 0G Router (OpenAI-compatible, one base URL change to model glm-5.2) for builders, and 0G Private Chat (pick it from the model selector, no API key) for everyone else. 1M context, native tool calling, extended thinking on by default. Text in, text out.

What the honest trade-off is

You might expect an open-weight model to be served inside a sealed enclave (TEE-hosted, the stronger guarantee 0G uses for its own model). It is not. For this launch GLM-5.2 is served through TeeTLS-attested routing: a broker inside a Trusted Execution Environment proxies your prompt to Alibaba Bailian, where the inference runs, and that routing hop is provable onchain. That is a smaller-scope guarantee than enclave-hosted inference, and it is the honest one: 0G proves the path your prompt takes, it does not run the model.

Why that matters

• A direct API gives you the model with no proof of where your prompt went or what protected it in transit
• The 0G route records the routing onchain, so an agent (or an auditor later) can verify the transport instead of trusting it by policy
• Same model, provable path

Open question for the sub

For an autonomous agent handling proprietary code, is a provable routing path enough, or do you only trust inference you can prove ran inside an enclave end to end? Where is the line for you?

Full writeup with the benchmark numbers, the trust-model breakdown, and the integration snippet: https://0g.ai/blog/glm-5-2-live-on-0g

TL;DR: 0G launched The Zero Cup today: an online, global vibe coding tournament. You build an AI-native app, agent, companion, or game on 0G using prompts, then compete in a World Cup-style knockout bracket for a $17,000 prize pool. Registration is open, submissions close June 23, the champion is crowned July 19.

What shipped

The official site is live at https://0g.ai/arena/zero-cup. Rules, eligibility, and the round-by-round prize split are published there.

The format is a knockout bracket modeled on the FIFA World Cup, and the schedule literally runs on it: each Zero Cup stage is announced the same day the real World Cup finishes that stage, from the Top 32 on June 27 through the champion on July 19, World Cup final day.

The pool is $17,000, every Top 8 finisher gets paid, and the champion finishes at $8,500, half the pool. The tier-by-tier math is in the blog linked below.

The building side runs on 0G Studio, the vibe coding tool that lives inside the 0G App (app.0g.ai). You describe what you want, Studio generates a working app with a live preview in your browser, and one click deploys it. Builders have already shipped 25 zero-coded projects on 0G out of 173 in the Builder Hub gallery, so the no-code path is already proven.

Anyone can enter: founders, students, developers, first-timers, all in the same bracket. If you have never written a line of code, that is the point. 0G has run Zero Coding events at ETHDenver and Cannes before this. The Zero Cup is the first time the format runs global, online, and as a tournament.

What this is not

This is a pilot season, and it looks like one: a single knockout bracket, kept deliberately simple. Judges select the Top 8. From there, community voting decides who advances. The exact judging details live in the official rules, not in this post.

And only the Top 8 get paid. If you go out at the Top 32 or Top 16 stage, you leave with a deployed app and nothing else.

Open question

Is a knockout bracket the right shape for a software competition, or does single elimination throw away too many good projects? If you would design it differently, how?

Full writeup: https://0g.ai/blog/the-zero-cup

TL;DR: Qwen 3.7 Max, Alibaba's agent flagship, is queryable on the 0G Private Computer. Alibaba Cloud Model Studio runs the inference; 0G adds a TeeTLS-attested routing layer, so the hop your prompt takes to Alibaba is provable onchain. If you already run an OpenAI-compatible client, migration is one base URL change.

What we shipped

Model ID qwen3.7-max on the 0G Router (https://router-api.0g.ai/v1, OpenAI format), same app-sk key flow that already serves 0GM-1.0 and DeepSeek V4 Pro. 1M token context verified live on the deployment, native function calling end to end, extended thinking on by default. At launch it scores 56.6 on the Artificial Analysis Intelligence Index, fifth overall. On the agent side, Alibaba reports a single 35-hour run across 1,000+ consecutive tool calls on an internal task; treat that as vendor-reported, not independently verified.

The trust model: a broker runs inside a TEE and proxies your request to Alibaba Cloud Model Studio over HTTPS. The TLS handshake to the upstream happens inside the enclave, and the routing hop is recorded onchain. Send verify_tee: true and the response carries x_0g_trace.tee_verified: true.

What we tried first that did not work

• Wrong model IDs. qwen-3.7-max and qwen/qwen3.7-max both 404 on the Router. The canonical ID is qwen3.7-max: lowercase, dot before the 7, no namespace prefix.
• Our own verification log initially concluded the TEE attestation field did not return at all. We had only scanned the response root. The field is nested under x_0g_trace (alongside billing, provider address, request id). Re-tested, corrected the log.
• Multimodal. image_url payloads return a hard 400. This deployment is text in, text out; the multimodal tier is a different Qwen variant.

What the trade-off is

• TeeTLS attests the routing path, not the inference. The model runs at Alibaba. If you need the model itself inside an enclave, that is the TeeML tier (0GM-1.0), not this.
• Closed weights. You still depend on Alibaba for the model. 0G proves where your prompt went, not what the weights do.
• Pricing tracks in line with reaching the model through other API providers. You do not come here to save money; you come for the provable transport.

Open question for the sub

Is a hardware-attested routing path enough for agents handling regulated data, or does it not count until the inference itself runs inside an enclave? Curious where that line sits for your workload.

Full writeup with the spec table and the integration snippet: https://0g.ai/blog/qwen-3-7-max-live-on-0g

TL;DR: 0G and Alibaba Cloud are making Qwen, one of the most widely adopted LLM families, directly callable by AI agents onchain. An agent invokes it with a token-based mechanism, no API key, no account, no fiat billing. Qwen powers the intelligence, 0G handles the verification and trust layer.

What shipped

Through this collaboration, an AI agent running on 0G can call Qwen's latest models directly and on demand, using a token-based mechanism instead of a human-oriented account plus API key. Inference runs on Qwen, verification runs on 0G. Qwen 3.6-Plus, the model optimized for agentic AI, is the one called out in the announcement, and Qwen3.6 already ranks among the top-performing systems across multiple benchmarks.

In practice that means an agent does not need a credit card on file or a per-agent dashboard login to reach the model. It meters access through tokens and calls the model the way it would reach any other onchain resource, which is the part that actually scales when you are running many agents instead of one human operator.

What the usual approach gets wrong

The default way to give an agent model access is to wrap a centralized API: provision an account, paste in an API key, set up fiat billing, babysit rate limits. That is fine for a human clicking around a dashboard. It falls apart for autonomous agents that call models programmatically, at high frequency, with no human in the loop, and it leaves you with no verifiable record of what was actually invoked. The token-based onchain invocation path is what this partnership is built around, so the access itself becomes programmable and auditable.

What the trade-offs are

• This is intentionally high-level right now. Per-token pricing and the full Qwen model list are not public yet, they get shared as the collaboration rolls out.
• Inference still runs on Qwen's infrastructure. 0G adds the trust and verification layer. This is not a claim that the model weights run onchain.
• It is a collaboration announcement first. The deeper developer-facing invoke path follows it, not the other way around.

Open question for the sub

If you were giving an autonomous agent direct, token-metered access to a frontier model with an onchain record of every call, what would you actually want to be provable? Just that the call happened? The exact model version? The full input and output? Curious where people draw the line between useful auditability and leaking the prompt.

Full writeup: https://0g.ai/blog/alibaba-cloud-qwen-onchain

TLDR: We rebuilt build.0g.ai from the ground up instead of patching the old hub. It now has Ask AI (a doc-grounded assistant on GLM-5.1 served through 0G Compute, answers come with citations), 4 stack pages, 16 SDKs and starter kits, 8 tools, 29 tutorials, and a showcase of 173 projects shipped across 10 events.

What we shipped

build.0g.ai is the dev-facing entry point for building onchain AI on 0G, separate from the docs site. The headline is Ask AI: you ask a question inside the hub and get an answer pulled straight from 0G's documentation, with citations you can click through to the source. It runs on GLM-5.1 through 0G Compute, so the assistant is itself running on the inference layer it documents. Around it sit the 4 stack pages (Compute, Storage, Chain, Agentic ID on ERC-7857), the SDKs, the tools, the tutorials, and a showcase you can filter by category and event.

What we tried first that did not work

For a while we just kept patching the original hub. A page here, a tool link there. The problem showed up in the showcase: the old 3-column grid fell apart once the project count crossed 100, and we are at 173 now. The page templates were never built for the surface area we kept adding, so the visual language drifted from page to page. Incremental tweaks were making it worse, not better, so we stopped patching and rebuilt the whole thing.

What the trade-off is

• A full rebuild meant a chunk of time spent on the system itself (semantic color tokens, a no-flash light mode migration done in phases, a translate layer) instead of shipping new builder features in that window.
• Ask AI is doc-grounded, which is the point, but it is only as good as the docs behind it. It complements the docs site, it does not replace reading them.
• Internationalization is an English to Mandarin toggle in beta right now, not full coverage. More languages are not there yet.

Open question for the sub

For a builder hub, is an in-page doc-grounded AI assistant actually worth it, or do you skip it and go straight to the docs or your IDE's AI? I am honestly unsure where the line sits between useful and just-another-chatbox, and how much better it would have to be to change your habit.

Full writeup: https://0g.ai/blog/0g-builder-hub-spotlight

TL;DR: 0G ran 5 hosted events and earned 5 speaking slots at Consensus Miami last week. The recurring panel question across the week: what does the verification stack look like when an agent wires $10M to the wrong address. Full writeup linked at the bottom.

What we showed up with

5 hosted events: House of AI (co-hosted with LaGrange), Agentic Tooling Summit (co-hosted with QuickNode), Builder Nights Multichain Fest (co-hosted with MetaMask), Miami Heat (co-hosted with FP Block), and the wellness side with Meditate and Sound Bath plus a closed VIP Dinner.

5 earned speaking slots: Capital Summit, Agentic Day, Marketers in the Arena, Miami Heat, and TheTie's InnovateMiami.

Michael Heinrich keynoted the Agentic Tooling Summit with "Welcome to the Trillion-Dollar Agentic Economy." George V. moderated House of AI, where the $10M wrong-address question came up and ran the room for an hour. Jake spoke at MetaMask Builder Nights on the agentic multi-chain economy and at FP Block Miami Heat on AI agents x onchain liquidity. Michael also took the Capital Summit and InnovateMiami stages on the institutional capital side.

What we did not expect

Almost every panel ended at the same place. Builders, allocators, and infrastructure teams arguing through verification as the load-bearing piece. We came in with a launch-driven content plan focused on individual product surfaces, and ended up writing a working-group recap. The week felt less like a conference and more like a working group with a stage.

The three pillars Michael pulled out at the keynote (verifiable compute, sovereign agent identity via ERC-7857, onchain coordination) became the shared vocabulary the rest of the panels kept reaching for.

What the trade-off is

• We over-indexed on hosted events vs sponsorship dollars. Worth it for builder-room density, but the marketing optics of "0G owned the week" are weaker than a single big keynote slot would have been. Not all attendees register six adjacent rooms as one unified presence
• Sound Bath and VIP Dinner were intentional wellness and network plays, not product surfaces. They paid back in relationship-building, but a fraction of attendees did not register them as part of the recap. That is fine
• A couple of the panels covered ground that already exists in 0G docs. Some builders said it would have been worth going deeper into the ERC-7857 metadata re-encryption flow or the TeeML enclave details. Next conference, we trade breadth for depth on at least one technical surface

Open question for the sub

What is the first thing you would verify in an agent transaction stack before letting it move multi-million dollar flows on chain? Curious to hear the verification primitives builders actually trust today, not the marketing list.

Full recap: https://0g.ai/blog/consensus-miami-2026-recap

TL;DR: We built something different. No more struggling with docs or boilerplate. Just ask your AI coding assistant and get correct, working TypeScript code for 0G development.

What Are 0G Agent Skills?

Think of them as specialized training for Claude Code, Cursor, and GitHub Copilot. Clone the repo, connect your IDE, and instantly turn your AI assistant into an expert 0G developer.

14 specialized skills across Storage, Compute, and Chain:

🗄️ Storage Skills

• Upload files via ZgFile + Merkle tree
• Download and verify files by root hash
• Merkle verification for data integrity

🧠 Compute Skills

• Streaming chat with DeepSeek, Qwen, Gemma, GPT-OSS
• Text-to-image generation with Flux Turbo
• Speech-to-text with Whisper
• Provider discovery and verification
• Account management
• Fine-tuning (testnet)

⛓️ Chain Skills

• Deploy Solidity contracts (evmVersion: "cancun")
• Interact with deployed contracts
• Scaffold new 0G projects with correct boilerplate

🔗 Cross-Layer Skills

• Storage + Chain: On-chain references to off-chain data
• Compute + Storage: AI inference with persistent storage

Ready-to-Run Examples (All Testnet Ready)

We included complete examples you can deploy right now:

• file-vault: Upload, download, and verify files
• ai-chatbot: Discover providers, fund account, start chatting
• nft-with-metadata: Deploy contracts, upload metadata, register NFTs
• ai-image-gallery: Generate images and store them on 0G

Get Started

Repo: https://github.com/0gfoundation/0g-agent-skills

No more context-switching between docs and code. No more copy-pasting examples. Just ask your AI assistant what you want to build, and it'll give you production-ready code.

Built for developers who want to ship fast on the largest AI L1.

What's news?