GitHub Is Planning for 30x More Repos — The Infrastructure Signals That Proactive Agents Are Almost Here
GitHub is preparing for 30x repo growth from agent activity. Stripe's agent-driven signups are exponential. Here's what the infrastructure data reveals.
GitHub Is Planning for 30x More Repos. That Number Tells You Something.
GitHub is preparing its infrastructure for a 30x increase in repositories — not from human developers, but from agents. Stripe is seeing agent-driven account creation go exponential. These aren’t projections from a research paper. They’re operational decisions that infrastructure teams are making right now, in 2026, because the load is already arriving.
If you build AI agents or work on AI-powered products, those two data points are worth sitting with for a moment. Not because they’re impressive, but because of what they imply about where the agent economy actually is versus where most product conversations assume it is.
The gap between “agents are coming” and “GitHub is literally scaling for agent traffic” is the gap this post is about.
The Numbers That Forced Infrastructure Decisions
GitHub’s 30x repo projection isn’t a marketing number. Infrastructure teams don’t plan for 30x growth unless they’re already seeing the early curve of it. You don’t over-provision by an order of magnitude on a hunch. That kind of planning happens when the monitoring dashboards are already showing something unusual and the on-call engineers are asking uncomfortable questions about headroom.
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
What’s driving it? Coding agents. Tools like Codex, Cursor, and Claude Code went from “curious developers playing around” to default workflow somewhere around December 2024 through early 2025. The nerds were experimenting in 2025, but then the models crossed a threshold and adoption followed. Now agents are creating repositories — not just committing to them, but spinning up new ones — at a rate that’s stressing GitHub’s capacity planning.
Stripe’s data tells a parallel story on the business side. Agent-driven account starts have gone exponential. Agents aren’t just helping humans start businesses faster. They’re starting businesses. The chart shape is the kind that makes you double-check the axis labels.
These are infrastructure signals, not capability claims. The difference matters.
Why This Is Easy to Misread
The obvious read is: “agents are getting better, therefore more activity.” That’s true but incomplete.
The more interesting read is about what kind of activity is growing. The GitHub repo explosion isn’t primarily humans using better tools. It’s agents creating artifacts autonomously — code repositories as outputs of agentic workflows, not as workspaces for human developers. The artifact of the work is the repo, and agents are producing artifacts at a rate humans never could.
This is a structural shift, not just a speed improvement. When Stripe sees exponential agent-driven account creation, that’s not humans signing up faster. That’s agents creating business entities as part of automated workflows. The Symphony protocol — an open-source coordination layer built by engineers at OpenAI — exists precisely because this kind of agent activity needed a different coordination model. Symphony moved agent work into issue trackers as the source of truth, so humans could review outcomes instead of managing sessions. That’s an infrastructure response to a real load problem.
AWS is making similar moves: managed agents with identities, logs, steering, and production controls. These aren’t features you build speculatively. You build them when production traffic demands them.
The pattern is consistent: the infrastructure is being built reactively, in response to actual load. Which means the load is already there.
What the Infrastructure Signals Are Actually Tracking
There’s a useful way to think about what these signals represent. Agent activity on GitHub and Stripe isn’t measuring the same thing as chatbot usage. Chatbot usage is reactive — a human has a question, opens a tab, types something. The human is the trigger.
Agent activity on GitHub is different. An agent creates a repo because it was given a task that required one. The task might have been assigned by a human, but the artifact creation was autonomous. The agent decided “I need a repository for this” and made one. That’s a different category of behavior.
This distinction matters for how you interpret the growth curves. Chatbot adoption grew because more humans started using chatbots. Agent-driven repo creation grows because agents are doing more work that produces repos as side effects. The growth driver is agent capability and deployment, not human behavior change.
Stripe’s agent-driven account starts are the same phenomenon in a different domain. An agent running a business formation workflow creates an account because the workflow requires one. The human may have initiated the workflow, but the account creation was an autonomous step.
What you’re watching in these numbers is the early shape of an agent economy — one where agents are economic actors, not just tools. If you’re building agent infrastructure or agent-powered products, that’s the context your work is entering.
The Anticipation Gap: Why Infrastructure Isn’t Enough
Here’s where the infrastructure story gets more complicated.
The GitHub and Stripe numbers are real, but they’re almost entirely in one domain: code and business formation. Coding agents have conditions that make them unusually tractable. Code either runs or it doesn’t. Tests pass or fail. There’s a compiler. You can write evals. The feedback loop is tight and objective.
Consumer life doesn’t have any of that. Did the agent book the right flight? How do you define right? Did it write the right email? There’s no compiler for tone. Did it summarize the meeting correctly? There’s no test suite for whether the summary captured what actually mattered.
This is what makes the infrastructure signals both exciting and incomplete. The agent economy is clearly real — GitHub and Stripe are proving that with operational data. But the current agent economy is heavily concentrated in domains with clean verification. The messy, subjective, high-stakes domains of consumer life are still largely untouched.
The term for this gap is the anticipation gap: the distance between agents that wait for you to assign them work and agents that notice when work needs doing. Current agents, even the good ones, are mostly reactive. You open them, tell them what you want, they try to do it. The GitHub repos being created by agents exist because a human or another agent explicitly triggered the creation. The Stripe accounts exist because a workflow step required one.
A genuinely proactive agent would notice that you need a repo before you ask. It would see the pattern in your work and surface the next step. That’s a much harder problem, and the infrastructure signals don’t tell us it’s solved — they tell us the reactive version is scaling fast.
The Products Trying to Cross That Line
Several consumer agent products are making different bets on how to get from reactive to proactive.
Clicky.so builds on Codex primitives and computer use. You talk to it, a small cursor appears on your screen, and it does the task you described. You can spin up ten of them in thirty seconds. It’s reactive — you still have to notice the task and assign it — but the UX is genuinely low-friction in a way most agent products aren’t. Mac only, and it will drain your battery, but the interaction model is worth studying.
Poke lives in iMessage, SMS, and Telegram. It connects to your email and calendar. The bet is that messaging has almost no cognitive overhead — people already text constantly, and the interface doesn’t feel like software. It nudges you about emails and reminders. The vision is clear. The execution isn’t quite there yet, partly because the messaging rails aren’t fully under Poke’s control (Apple, Meta, and SMS costs are all in the dependency chain), and partly because knowing what actually matters to a specific person is still an unsolved personalization problem.
Cluey takes a different angle: invisible AI assistance during conversations and interviews. The demand is real — visible AI use is socially costly, so invisible AI use feels like an advantage. The current critique is that the answers feel canned and the latency is noticeable. If an interviewer hears a pause followed by a generic-sounding answer, the tool has made things worse, not better.
Co-work is the most interesting signal for where proactivity might actually emerge first. It takes the multi-step knowledge work pattern from Claude Code and points it at non-technical work. The Chronicle memory feature in Codex is the clearest preview of what proactive agents might look like: it tracks your work sessions and proactively suggests next tasks. The example from the source is concrete — Chronicle noticed a pattern of process work and suggested writing an SOP. The user hadn’t thought to ask. The first draft was 80-85% good. That’s a load-lifting moment, which is exactly what proactive agents need to deliver to earn trust.
For builders who want to wire together agent workflows without building the orchestration from scratch, platforms like MindStudio handle this layer: 200+ models, 1,000+ integrations, and a visual builder for chaining agents and tools. The infrastructure problem of connecting models to real-world data sources is largely solved at the platform level — the remaining hard problem is the anticipation logic on top.
The Trust Ladder That Determines Adoption Speed
The infrastructure scaling at GitHub and Stripe is happening in a specific zone of the trust ladder. There are five rungs:
- Read — the agent can see your files, email, screen, calendar
- Suggest — the agent surfaces something proactively, but you stay in charge
- Draft — the agent prepares the action; you approve before it goes anywhere
- Act with confirmation — the agent does things in the world but asks before consequential moments
- Autonomous — the agent buys, books, sends, and signs without you
The GitHub repo explosion is happening at rung 4-5 for coding workflows. Agents are creating repos autonomously because the trust has been established in that domain. The verification is tight enough that the error cost is manageable.
Consumer life is mostly stuck at rungs 1-2. Agents can read your calendar and suggest things. The jump to rung 3 — drafting actions you then approve — is where most consumer products are trying to get to. The jump to rung 5 in consumer contexts is where Stripe’s agent wallets become relevant: it’s a real product that lets agents make purchases on behalf of users. The rails exist. The trust hasn’t been established yet at scale.
The infrastructure signals from GitHub and Stripe are telling you that rung 4-5 is achievable when the domain has clean verification. The open question is whether consumer domains can develop equivalent verification mechanisms — or whether the trust ladder just takes longer to climb when success is subjective.
For builders working on AI agents for product managers or knowledge work automation, this is the practical implication: start at rung 2 or 3, build the verification mechanisms that let users trust the outputs, and earn your way up the ladder. The agents that try to jump straight to autonomous action in ambiguous domains are the ones that break trust and get uninstalled.
Three Signals Worth Watching in 2026
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
If you want to track when the agent economy expands beyond code into broader consumer domains, there are three concrete things to watch.
Key hires at the labs. OpenAI hired Peter Steinberger, the creator of OpenClaw. That’s not a random engineering hire — it’s a signal that the lab is seriously working on proactive consumer agents. Anthropic’s hiring page currently shows a focus on HR tech. These are public signals of product direction. Most people don’t read hiring pages carefully enough. You can infer a company’s next product bets from the roles they’re trying to fill.
Load-lifting moments in products you’re testing. The Chronicle memory feature in Codex is the clearest example of what to look for: a moment where the agent noticed something you hadn’t assigned it and did useful work. If you’re running multiple agents over several months, you’re looking for an increasing frequency of those moments. Decreasing frequency means the product isn’t progressing. Increasing frequency means something is working.
Model release notes mentioning long-running agentic intent with memory for consumers. When frontier model releases start describing not just long-running coding tasks but long-running consumer intent with memory — that’s the capability signal that the anticipation gap is starting to close. It’s a necessary condition, not a sufficient one. The Hawaii weight-loss goal example illustrates why: the same prompt (“I want to get in shape for Hawaii”) means something completely different depending on the user’s actual habits and commitment level. An agent that assumes maximum optimization will schedule five HIIT sessions a week for someone who goes to the gym once a week at best. The model capability has to be paired with behavioral understanding.
For builders working on AI agents for marketing teams or other domain-specific applications, the practical version of this is: build in the behavioral signals. Don’t just read the stated goal. Read the usage patterns, the calendar density, the response latency to agent suggestions. The stated goal and the actual behavior are often different things.
What You Can Build Right Now
The infrastructure signals from GitHub and Stripe are telling you the agent economy is real and scaling. The anticipation gap is telling you where the next opportunity is.
The coding domain is largely claimed. The consumer proactivity problem is open. The products trying to solve it — Poke, Clicky, Cluey, Co-work — are all making interesting bets, none of them fully there yet.
The builders who figure out how to deliver genuine load-lifting moments in messy, subjective consumer domains — without requiring users to manage a fleet of agents — are working on the most valuable unsolved problem in consumer AI right now.
Not a coding agent. A product manager.
Remy doesn't type the next file. Remy runs the project — manages the agents, coordinates the layers, ships the app.
If you’re building in this space and want to see what spec-driven development looks like at the infrastructure layer, Remy takes an interesting approach: you write your application as an annotated markdown spec, and it compiles into a complete TypeScript backend, SQLite database, auth, and deployment. The spec is the source of truth; the code is derived output. It’s a different answer to the same underlying question the agent economy is asking — how do you move the human’s contribution up the abstraction stack?
The GitHub and Stripe numbers are the proof that agent-driven artifact creation is already happening at scale. The question for 2026 is which domains come next, and what the infrastructure for proactive consumer agents looks like when it arrives. The signals are there if you know where to look.
For a practical starting point on building agents that can actually do research and synthesis work autonomously, the 9 AI agents for research and analysis roundup covers the current landscape of what’s deployable today. And if you’re curious about the open-source side of the proactive agent space, the OpenClaw overview is worth reading alongside the Steinberger hire — the connection between the two tells you something about where the labs think consumer agents are heading.
The 30x number is already baked into GitHub’s infrastructure plans. The only question is what gets built on top of it.
