Everyone talks about AI agents onchain. Almost nobody can show you revenue. So I went looking for numbers, and Bankr turned out to be the one platform that just hands them to you.

Their whole API is public and unauthenticated. No key, no application, no dashboard login. You can pull every launch, every trending token, and every registered project including what each one earns per week. I don't know another launchpad that publishes per-project revenue openly. That alone made it worth writing up. Data below is from 19 Aug and anyone can re-run it.

1. It earns real money, in ETH, every week

Across the 113 registered projects, Bankr reports 36.6 WETH a week in revenue. And 109 of those 113 earn something above zero.

That second number is the one I'd underline. In a category where most "AI agent" tokens generate literally nothing, 96% of the projects on this platform have non-zero weekly fee revenue flowing to them. Not projected, not a roadmap, currently paid.

Five projects clear 1 WETH a week on their own, and 29 clear 0.1. The top earner is pulling 11.9 WETH a week, which is a genuine business running on Base with no venture funding and no app store.

2. 101 of the 113 projects are on Base

Combined market cap across the ecosystem is $16.05M, with three projects above $1M and the largest at $3.4M.

Bankr also supports Robinhood Chain, and here's the part I found most interesting for this sub. When I pulled the 50 most recent launches, 40 of them were on Robinhood Chain. New deploys chase the cheapest newest venue, as they always do.

But look at where everything that matters stayed. The trending list, where volume actually is, was 34 Base to 16 Robinhood. Registered projects: 101 Base to 12 Robinhood. Revenue: overwhelmingly Base.

Launches are portable. Liquidity is not. Base is where these projects choose to live once they're real, and having a clean multi-chain dataset to compare against is exactly what makes that visible.

3. The throughput is genuinely impressive infrastructure

The 50 most recent launches covered an 84 minute window. One token launch every 100 seconds, deploying reliably, with a pool live and tradeable immediately.

All 50 used doppler-style Uniswap v4 pools, which means the launch curve and the LP are the same object. No bonding curve, no graduation event, no migration step where things break. It's live liquidity from block one.

The composability is better than it needed to be, too. The pool id Bankr returns works directly as a GeckoTerminal pool id, no mapping table required. So you can go from "this token launched 90 seconds ago" to "here is every trade in it above any size" with one extra call to a free public API. Somebody made a deliberate decision to use standard identifiers instead of inventing their own, and that decision is why anyone can build on top of this.

Across the top 50 trending tokens: $5.5M in 24 hour volume.

4. Distribution is built into the product, not bolted on

28 of those 50 launches carried a tweet URL. The token exists because someone replied to a bot in public.

That's the actual innovation and I think it gets undersold. Deploying a token has been reduced to typing a sentence where your audience already is. The contract, the pool, the liquidity and the announcement are one action. No dashboard, no wallet connect flow, no separate marketing step. 104 of the 113 projects have an X presence and 53 have shipped products attached to their profile.

5. The honest caveat

The long tail is early. Median market cap is $35,537, median daily volume is $50, and the revenue curve is steep, with the top ten taking 82%. Most of these projects are small and most will stay small.

I don't think that's a knock. It's what an open permissionless registry looks like at month five, and I'd rather have 113 projects where anyone can deploy and 5 break out than 10 curated ones. But it does mean "113 agent projects on Base" and "113 businesses" are different sentences.

What I actually take away

The agent narrative has been running for a year on almost no evidence. Bankr is the first place I've been able to point at hard numbers: 113 projects, $16M in combined market cap, 36.6 WETH a week in real fees, a launch every 100 seconds, and an API open enough that you can verify every word of this yourself in about ten minutes.

It's early. It's also unambiguously working, and it's happening on Base.

Two questions for the sub: what would you want to see published that isn't already, given they've set the bar this high on transparency? And has anyone here actually deployed through it, what was the experience like?

Jensen Huang posted this earlier today:

Land, power and shell: The next critical resource for AI factories.

Full context from his post:

AI factories are becoming the defining infrastructure of the AI era :places where compute turns energy and data into intelligence. In this economy, compute is revenue.

NVIDIA is saying the full stack now includes not just advanced chips, packaging, memory, and networking, but also land, power, and shell (LPS).

They’re treating LPS the same way they’ve treated semiconductor supply: using scale and long-term partnerships to lock it in exclusively for NVIDIA AI factories.

Today they announced a partnership with SB Energy to secure LPS capacity at the PORTS-Pike Technology Campus in Portsmouth, Ohio. OpenAI will be the tenant.

Key numbers from the announcement:

• Initial deployment expected to deliver 4.25 gigawatts of AI factory capacity
• Each generation of systems at the site could represent ~1.5 million NVIDIA GPUs
• Potential revenue opportunity in the $150–200 billion range per generation
• OpenAI’s existing + planned commitments already sit around 12 GW of NVIDIA compute, with room to grow toward 16 GW if the arrangement expands
• At those levels the opportunity is roughly $600 billion of NVIDIA compute through 2030

The message is clear: chips got us here, but the real rate limiter now is the physical substrate : the land, the power, and the buildings that can actually host the next wave of AI factories at scale.

Thoughts on how big a shift this is for the industry?

Nous Research and Teknium announced this weekend that their Hermes Agent passed 2,500 GitHub contributors, and it deserves a moment.

The big closed agents everyone talks about are built by a couple hundred paid engineers behind an API. Hermes is being built by 2,500 people who showed up, for free, because they wanted the thing to exist and run on their own machine. And it is seriously capable: fully local, no cloud ties, no telemetry, and it learns skills from experience instead of being frozen to one static setup. It is the rare project that respects your hardware and your privacy while still keeping up on capability.

There was also a clip going around of bots in the Hermes desktop bot mode splitting a whole game project between themselves by specialty, with barely any human input. The kind of thing that was a staged demo a year ago is a weekend build for this community now.

What gets me is what it says about how AI gets built. You do not need a giant lab and a walled API to ship a real agent. You need a great core, an open door, and people who care. Nous and Teknium clearly built something people want to pour their own time into, and 2,500 contributors is the proof.

Genuinely happy to see an open, local-first agent this far along. For anyone here running it or contributing: what is the coolest thing Hermes has let you automate or build? Want to hear what the community is actually doing with it.

Bloomberg is reporting Stripe agreed to buy OpenRouter for more than $7B. The part worth chewing on for this sub is the velocity and what it implies about where AI value is actually accruing.

The facts:

• Seed/growth round valued it at $1.3B roughly 82 days ago
• Sale at $7B+ is about 5x that mark in under three months
• Founded 2023, 8M users, inference volume from $10M annualized in late 2024 to $100M+ by mid-2025
• Backers include Sequoia and a16z, so a very fast, very clean return on the last check

What makes it interesting: OpenRouter trains nothing. It is a routing layer, one API in front of 400+ models from OpenAI, Anthropic, and everyone else. The CEO framed it as "the Stripe of AI," and Stripe, of all buyers, agreed.

The thesis I keep coming back to: in AI, the model layer is commoditizing fast and the durable value is moving to aggregation and settlement. Whoever sits between all the models and controls routing, price discovery, and who gets paid captures the margin, regardless of which lab wins. That is classic aggregation theory, and it is why a payments company paid $7B for a toll booth rather than a foundry.

Two questions for the room:

1. Was the $1.3B round a mispricing, or did Stripe pay a strategic premium (defensive, distribution, IPO narrative) that a financial buyer never would? In other words, is 5x-in-82-days a signal or a one-off?
2. If the routing layer is the moat, what is the next equivalent chokepoint in the stack that is still underpriced today: eval, agent orchestration, inference settlement, something else?

Curious where people land, especially anyone who saw the last round.

Been thinking about the open weights versus open source distinction that comes up here a lot, and I think there's a third category we underweight: the harness.

Everyone argues about whether a model with published weights and a restrictive license counts as open. Fair argument. But even when you win it and get genuinely open weights, you then run them through a coding agent, an IDE plugin, or a chat wrapper that is completely closed, and that layer decides your system prompt, your tool definitions, your context management, your retry behavior, and what telemetry gets shipped. You picked an open model and handed it to a closed harness that shapes most of what you actually experience.

This matters more than it sounds. Two agents running the identical model produce wildly different results depending on how the harness builds context, how it handles tool call failures, and how much of your history it silently truncates. If that layer is closed, you can't inspect it, can't fix it, and can't stop it from changing under you.

The one I've been using is OpenClaude, it's an open-source coding agent CLI where the whole harness is inspectable: tool definitions, context handling, provider integrations, all of it. Model-agnostic by design, so you point it at whatever you want, including local weights through Ollama or LM Studio with no API key.

Because both halves are open, the whole stack ends up free as a side effect. No subscription for the tool, no per-token billing if you're running local. But the free part is downstream of the open part, not the point.

Around 30,700 stars and 8,900 forks since April, MIT licensed, active development.

A concrete example of why an inspectable harness matters: when a client talks to Ollama through the OpenAI-compatible shim without explicitly setting a context length, session history can get silently truncated by the model's default num_ctx. No error, the model just stops remembering things. OpenClaude requests a 32k window explicitly to avoid it. I only know that because I could read the code. With a closed harness you'd just conclude your local model was bad at long tasks.

The honest caveat: agentic tool-calling loops still degrade below a certain model capability threshold, and no amount of open harness fixes that.

The question I'd put to this sub, since you argue about definitions more carefully than most: where does the harness sit in your openness bar? Is an open model running inside a closed agent meaningfully open, or is that the same compromise as open weights under a restrictive license, just moved one layer up?

Repo: github.com/Gitlawb/openclaud

The whole cost, spelled out

• The agent: free. Open source, MIT. No subscription, no seat fee, no trial, no "free tier" that expires.
• The inference: free. It talks to your local Ollama. No API key. No per-token billing. No account.
• The data: yours. Nothing leaves your machine. No cloud round trip, no telemetry.

Total: zero. Permanently. Not zero-for-now, not zero-until-they-raise-prices. There is no billing relationship to change, because there is no billing relationship.

Compare that to what everyone else is charging for:

	Cost of the tool	Who picks the model	Where your code goes
Copilot	Subscription + per-request billing	Microsoft, and they deprecate on their schedule	Microsoft's servers
Cursor	Subscription	Their harness, their integrations	Their servers
OpenClaude + Ollama	$0	You	Nowhere. It stays local.

Setup is three lines

export CLAUDE_CODE_USE_OPENAI=1
export OPENAI_BASE_URL=http://localhost:11434/v1
export OPENAI_MODEL=qwen2.5-coder:7b
openclaude

That's it. Terminal-first agent with tool calling, multi-step loops, MCP, slash commands and streaming, pointed at a model on your own hardware.

A PSA while you're here, whatever tool you use

When something talks to Ollama through the OpenAI-compatible endpoint (/v1), it goes through a shim, and unless the client explicitly sets a context length, your model's default num_ctx can silently truncate session history. Nothing errors. The model just quietly stops remembering what you said ten turns ago, and it reads as the model being stupid rather than the harness dropping tokens on the floor.

Brutal for agentic coding specifically, where one task is a dozen tool calls plus their outputs, so you blow through a small window without ever writing a long prompt.

OpenClaude handles it by using Ollama's native chat API and requesting a 32,768-token window on every request (OPENCLAUDE_OLLAMA_NUM_CTX or OLLAMA_CONTEXT_LENGTH to override). Regardless of what you run, ollama ps shows the context size actually in play. Check there before blaming the model.

There's also a repo map that builds a structural view of your codebase ranked by PageRank and injects it into context, which matters more locally than with frontier models because you're rationing every token.

Repo: github.com/Gitlawb/openclaude

OpenAI is quietly testing a "reset" purchase for users who hit their weekly cap. Instead of waiting out the timer, you pay to instantly restore your quota to 100%. Reported pricing scales with your tier: roughly $5-8 on Plus, $25-40 on Pro Lite, and $50-80 on Pro.

You are already paying $200/month for Pro. The reset can cost $80 on top.

I want to argue both sides honestly:

The case for it

1. If you are on deadline, $80 is not the real number. The real number is "what does four hours of dead time cost me." For anyone shipping client work or running Codex on a Friday deadline, buying the reset is trivially worth it. This is the same math as paid expedited shipping, and nobody rages about that.
2. It is honest metering, finally. Flat-rate subscriptions on top of usage-based compute were always a fiction held together by throttling. A visible price for extra usage is more truthful than a silent cap that quietly degrades your week. It also lets heavy users subsidize themselves instead of everyone eating a lower ceiling.

The case against it

1. It makes the cap a revenue line, not a cost control. The moment resets earn money, tighter limits become a feature, not a bug. Nobody has to conspire for this to happen; the incentive gradient does it on its own. You cannot audit your own quota, so you would never be able to prove it.
2. Price discrimination is running backwards. The people most likely to hit the ceiling are the ones already paying the most, and they are charged the most per reset. Paying $200 and still getting a "pay $80 to continue" prompt is the pattern people recognize from mobile games, and the goodwill damage will outrun the revenue.

The part that genuinely bothers me is not the money. It is that the cap becomes unfalsifiable. Right now if limits feel tight, you assume capacity. Once resets are a product, every tight week reads as a monetization decision, whether or not it is one. Trust is the actual thing being spent here.

So, two questions: would you pay it, and at what price does it stop feeling like convenience and start feeling like a toll booth? For me Plus at $8 is fine. Pro at $80 is a different product category.

pools fun went live yesterday on Robinhood Chain and had one of the strongest first days I've seen from a launchpad. I read the factory contract's events directly rather than going off the announcement, and the numbers hold up. Method at the bottom so anyone can check it.

Two design choices that make it worth a look

1. No bonding curve. Every token deploys straight into a SushiSwap V3 pool, paired against WETH, 1% fee tier, fixed 1B supply, around $10k starting FDV. There is no curve phase and no graduation event. Real V3 liquidity exists from the very first block, which means no waiting for a bar to fill before a token is actually tradeable, and no cliff moment where the curve hands off to a DEX. It's just an AMM from second zero.

2. Protocol fees buy and burn the community's winners. 25% of all protocol fees go toward buying and burning the top 3 tokens daily, ranked on a live leaderboard. The first snapshot ran yesterday and hit $sushicat, $ONGR and $FLAMINGO.

That second one is the part I keep thinking about. Most launchpads treat fees as revenue that leaves the ecosystem. Here the protocol's own income is recycled into whichever communities won that day, so the fee split becomes a daily competition instead of a static rev-share. It gives every project on the platform something to organize around beyond just their own chart, and it resets every 24 hours so nobody is permanently locked out.

The first 24 hours, on-chain

• 2,439 tokens launched. The previous 24 hours had 268, so about 9x on go-live.
• 532 launches in a single hour at the peak, right as the platform opened.
• 959 unique creator addresses, so this is a genuinely wide crowd rather than a handful of deployers.
• $5.19M in 24h volume and $12.3M in liquidity across the pools.
• Top performer was $ONGR at $1.31M volume, up roughly 3,500%, and it landed in the first burn snapshot.
• 57 tokens cleared $10k in volume on day one, 245 cleared $1k.

For a platform that was a splash page 48 hours ago, putting up eight figures of liquidity and a million-dollar token on day one is a real start. The usual launchpad long tail applies and most of what launched is quiet, which is true everywhere, but the top of the distribution is doing actual volume rather than wash-looking noise.

The infrastructure underneath helps. Robinhood Chain is running 0.1 second blocks with gas in the fractions of a cent, so launching and trading feels instant, and Sushi V3 is doing the heavy lifting on the pool side rather than a custom AMM that has to be trusted.

What I'm curious about

The daily burn leaderboard is the mechanic I'd watch. If it works, it gives communities a reason to coordinate that isn't just buying their own token, and it turns protocol revenue into something the whole platform competes over. Has anything else tried recycling launchpad fees into buybacks of user tokens rather than a native token? I can't think of one, and I'd be interested if someone has seen this design before.

Method

Launch data is decoded from the TokenLaunched events on the PartyFactory contract at 0x626C3d09B65bF5d1D40E0D5F25e19fa49783B3D4 on Robinhood Chain, cross-checked against Blockscout. Volume, liquidity and FDV are from DexScreener, filtered to Sushi V3 pairs whose token address appears in those factory events. The RPC and explorer API are both open, so this is fully reproducible. The burn figures are the team's stated policy, I have confirmed the leaderboard and the snapshot but not yet traced the individual burn transactions.

No affiliation with the platform and I don't hold any of these tokens, I just went digging because the no-curve design was unusual. No links in this post on purpose.

Over the past year I’ve noticed a clear shift in how people talk about GitHub.

What used to be occasional complaints about downtime has turned into a more consistent pattern:

• Multiple multi-hour outages affecting Actions, the API, pull requests, and core Git operations
• Large-scale spam (tens of millions of fake commits hitting the public feed)
• Security incidents, including malware in Microsoft’s own repositories and prompt-injection issues with their AI agent features
• A growing mismatch between the platform’s original design (human accounts + tokens) and the reality of autonomous AI agents that need to push code, open PRs, and collaborate without constant human babysitting

Even long-time power users are reacting. Mitchell Hashimoto (user #1299, creator of Vagrant/Terraform/Ghostty) publicly announced he’s moving Ghostty off GitHub after 18 years, saying it’s “no longer a place for serious work.”

This raises an interesting question: is the problem just temporary capacity issues, or is there a deeper architectural limitation?

GitHub was built for a world of human developers with browsers and personal access tokens. AI coding agents don’t fit that model cleanly. They either borrow human credentials or require awkward workarounds. That feels increasingly fragile as agents become more capable.

While looking into alternatives, I came across Gitlawb, a decentralized Git network that takes a different approach. It uses cryptographic identities (DIDs) instead of accounts, signed pushes by default, content-addressed storage, and treats AI agents as first-class participants that can own repositories and manage permissions natively.

I’m not saying it’s production-ready for everyone tomorrow, but the design direction is interesting given the current pain points on GitHub.

Would be good to hear different perspectives.

Everyone here builds agents. The frameworks are basically solved, you can stand up a capable agent in a weekend. What's been missing is the boring part: how does an agent project get funded, distributed, and paid, without you bolting Stripe onto it and praying?

The most developed answer I've seen is Bankr. It started as a natural-language trading agent on X/Farcaster (tag the bot, tell it what to do in plain English, it executes, gas sponsored, settlement abstracted). But what it's become is more interesting for this sub: a venue where agentic businesses launch, raise from backers on day one, earn fees from real usage, and get their inference subsidized by the platform.

The live numbers on their homepage: ~$5.05B total volume, $20.32M paid out to creators, and 76.4B LLM tokens of inference given to builders. That last one matters most here: they're literally paying the compute bill for people building agent products. Their thesis, in their own words: "software is no longer a moat, capital and attention are." AI made code cheap, so the venue that allocates funding and distribution wins.

A concrete example of what launches there: gitlawb, a decentralized git network built for agents, agents push code, open PRs, and settle bounties under their own cryptographic identities instead of a human's GitHub account. But the pattern is the point: agent-native infra projects are getting funded and distributed through this channel now, not through VCs.

Honest caveats: plenty of what launches is froth, meme-tier launches, same as any early market. And the whole model lives or dies on whether real usage fees keep flowing rather than pure speculation. Open question I'd put to builders here: if a venue funds your agent's inference and gives it distribution in exchange for launching there, is that a better deal than the grant-and-accelerator route? Anyone here actually shipped an agent business on rails like these?

We're all starting to hand real build work to agents, commits, CI, deploys, reviews. But almost every one of those agents currently depends on the same centralized chokepoint, and yesterday showed exactly what that costs.

August 6, 2026: GitHub Actions, Pages, and the API were degraded for 2.5+ hours. Copilot review, the coding agent, hosted runners, webhooks, all down. The part that matters for anyone building agents: self-hosted runners went down too. You can own the hardware and still stall, because GitHub owns the orchestration, the triggers, queues, job assignment, status records. Point your agent fleet at that and one company's bad afternoon freezes all of it. It even cascaded, CircleCI pipelines hung and OpenAI's GitHub-dependent workflows failed.

This isn't a rare event either: 26 incidents in July, 23 in June, 6 in the first six days of August. Mitchell Hashimoto called GitHub "no longer a place for developers to host serious work." For humans that's an annoying morning. For an autonomous agent that's supposed to run unattended, a centralized control plane that fails monthly is a hard ceiling on what you can actually automate.

So the real question for this sub: what does build infrastructure for agents look like when you remove the single control plane? The direction that makes sense to me is open, decentralized, and agent-native by default, coordination happening across a network of nodes instead of one company's servers, so a node going down means the network routes around it instead of everyone stalling.

The clearest attempt at this I've seen is gitlawb, an open, decentralized, agent-native builder network where agents push work, claim tasks, and settle bounties across the network rather than through a central orchestrator, with inference available through the network so agents aren't single-homed on one API either. Base actually flagged it on their last Global Builder Call as an example of where builder infra is heading, which is what got me digging in.

For people here running agents in anger: what breaks first when you try to take agent build/coordination off centralized infra, trust, discoverability, or raw dev UX? Genuinely want to hear where it falls down.

August 6, 2026: GitHub was degraded for 2.5+ hours (Actions, Pages, the API, Copilot, hosted runners). Nothing new on its own, but one detail stuck with me as a git-hosting question: the self-hosted runners went down too. You can own the hardware and still eat the outage, because the provider owns the orchestration, the triggers, queues, job assignment, status records. Owning your repo and your runner still leaves you single-homed on one company's control plane.

And it's a pattern, not a bad day: 26 incidents in July, 23 in June, 6 already in the first six days of August. Hashimoto's "no longer a place to host serious work" line keeps aging well.

I know some of you have already jumped (the Codeberg threads here, self-hosted Forgejo/Gitea setups, mirroring to multiple remotes). So genuinely: what's your actual setup for not being hostage to a single git host? Multi-remote mirroring? Self-hosted forge? And how far do you take it, just the repo, or the CI/orchestration too?

The furthest end of this I've seen is decentralizing the hosting/orchestration layer itself so there's no single control plane at all. One project going at it is gitlawb (agent-native, decentralized builder network,