What Is Small Software?

TL;DR: Small software is software with one user or a handful of users, built for a specific team rather than a market. Agents removed the cost of writing it. Everything after the writing — deploying it, letting a colleague log in, keeping twenty of them alive without doing pricing arithmetic — is where it still dies. That gap is what AgentCell exists to fill.

The definition

Small software is a script that reconciles your invoices. A dashboard for the one metric your team actually cares about. A sprint tracker shaped like your team’s sprints, not Jira’s. A prototype you want three colleagues to click through.

Three properties define it:

1. The audience is fixed and tiny. One person, or a handful. It will never have a thousand users, and that is fine — it was never meant to.
2. It is bespoke by nature. Every team does things differently, so demand for tools shaped like the team is effectively unlimited. No vendor can pre-build them all.
3. It has no operator. There is no platform team, no on-call rotation, no one whose job is the deploy pipeline. There is one person who wanted a tool, and now an agent that wrote it.

That third property is the one the entire cloud industry ignores. AWS, Vercel, Render — all of them assume someone, somewhere, operates the software. For small software, nobody does. The person who wanted the tool is not a cloud engineer and does not want to become one.

Why now: agents removed the build cost

This category did not exist at this scale two years ago because writing even a small app cost real engineering time. That cost is now gone:

• Lovable reports 100,000+ new projects per day and roughly $500M ARR (mid-2026).
• Replit saw 2M+ apps built by its agent in a six-month window.
• Vercel reports 30% of apps deployed on its platform are now AI-agent-generated.
• Claude Code went from a $500M run-rate to over $2.5B in about five months.

Building personal software with an agent is genuinely easy now — and genuinely fun. The build is autonomous right up to the moment the app has to ship. Then a human has to take over: create a project in a console, click through a deploy wizard, paste env vars into a form, wire up auth so a colleague can log in.

The agent is fully capable of doing all of it and is simply not allowed to. So every small app carries a human operator tax larger than the app itself.

The five failures after the build

1. The dashboard wall. The build is autonomous until shipping, then it becomes clicks in a console. Logs tabs, rollback buttons, env-var forms — every one of them a translation step between what the agent wants to do and what a human must click.

2. Clouds built for Big Software. Accounts, IAM, VPCs, load balancers, certificates, CI, secrets, observability, an unpredictable bill. Rational overhead for a system serving a million users; absurd overhead for a tool with three users. Most small software never leaves the machine it was built on.

3. Sharing is an auth problem. “Send this to Priya on the ops team” means picking an auth provider, wiring OAuth, modelling users and sessions, handling her leaving the company. Same work every time, wildly disproportionate to 200 lines of business logic.

4. Sharing agent-written code is a security problem. If sharing is as easy as a Google Doc, then untrusted code deployed by a non-engineer runs against company data. That needs real isolation, egress control, and secret handling — enforced by the platform, because the deployer cannot be expected to reason about it. The base rates are bad: roughly 38% of AI-generated code carries at least one security flaw, and CVEs traced to AI-generated code accelerated sharply through 2026.

5. Every company wants its own environment. Base images, private packages, internal APIs, network boundaries, data residency. A platform with one blessed runtime gets rejected by exactly the teams with the most small-software demand.

What small software is not

• Not a startup idea. It has three users and will always have three users. It does not need product-market fit, analytics, or a landing page.
• Not a prototype for big software. Some small tools grow up, but most are finished at their current size. Judging them by “will it scale” misses the point.
• Not shadow IT to be eliminated. Gartner puts shadow IT at 30–40% of large-enterprise spend. Much of it is small software solving real problems faster than IT can. The answer is a sanctioned home for it, not a ban.
• Not a notebook or a spreadsheet. Notebooks and sheets are where small software goes to be quietly hated. They work until they don’t — no auth model, no versioning, no ownership story.

The honest caveats

Two numbers should discipline everyone’s enthusiasm, ours included:

• Replit converts roughly 0.4% of registered users to paid, and only about 5% of agent-built apps reached production use. Volume is enormous; sustained, shared, paid usage is unproven.
• Val Town — the closest philosophical match to this thesis — is a ~3-person team whose stated 2026 goal is simply break-even.

Small software may be mostly personal, mostly unshared, and mostly abandoned. That is the risk our discovery process exists to kill honestly. The metric that matters is not deploys — it is cells shared with at least one other person, and weekly active users who did not build the cell.

Where to go next

• Share it like a Google Doc — how sharing works on AgentCell.
• Unlimited apps; pay only for consumption — the economics that let twenty tools stay alive.
• AgentCell vs Vercel — why Big-Software clouds can’t collapse this cost.

AgentCell is the cloud for small software: deploy the tool your agent built, share it like a doc. Deploy now.