Software 3.0

We're in the middle of a transition most people misunderstand.

Software 1.0 is deterministic logic. You write if/else, it runs forever exactly as written. Reliable, narrow. Every new behavior requires an engineer.

Software 2.0 is learned logic. Neural networks trained on data that handle a far wider range of problems than any hand-written rules. Karpathy defined this in 2017: the weights are the program. Deterministic on the trained distribution. Wide.

Software 3.0 is agents. General-purpose, autonomous, capable of novel tasks. LLMs calling tools, browsing the web, writing code. But they have a fatal flaw: they're nondeterministic. You can't ship a product that hallucinates 5% of the time.

The industry is converging on a fix: give agents deterministic skills. Claude Code has skills— bundled procedures that mix prompts with deterministic hooks. MCP gives agents standardized access to tools and data. Cursor, Windsurf, every coding agent is building the same thing: a way to bolt reliable, repeatable behaviors onto a nondeterministic core.

This is the right instinct, wrong destination. These skills are still Software 1.0 — hand-written procedures, shell scripts, explicit instructions. They're narrow. They break when inputs drift. They require a human to write and maintain them.

This is the part most people miss: the real fix is for agents to generate Software 2.0.

Instead of writing a skill as a script, the agent produces a small trained model. The model is deterministic on its distribution, handles a wider range of inputs than any hand-written procedure, and costs nothing to run. An agent's skills shouldn't be generated code. They should be learned programs.

That's Software 3.0: agents that create Software 2.0 in real time.

The economics point the same way. A frontier model costs orders of magnitude more than a small specialized model doing the same narrow task. The gap will only widen. General intelligence is expensive. Specialized intelligence is cheap. The natural architecture is to use the expensive thing to produce the cheap things.

This is the same pattern everywhere in computing. The hot path gets optimized. The cold path stays general. Compilers exist so interpreters don't have to run forever. JIT compilation exists because some code paths are worth turning into machine code. In Software 3.0, the hot path is a trained model. The cold path is the agent.

The agent observes, handles novel situations, and when it notices a pattern recurring, it distills that pattern into a specialist. The specialist handles the routine. The agent handles the unknown. Over time, less is unknown. The agent gets called less. The specialists get better.

Think about what a mature system looks like. Dozens of tiny specialized models: one that triages email, one that extracts action items from meetings, one that classifies screen activity, one that decides when to interrupt you. Each trained on your data, by an agent that watched you work. Each deterministic on its distribution. Each costs nothing to run.

The agent that created them still exists, but it's called less and less. It handles edge cases, retrains when distributions shift, creates new specialists when it notices new patterns. It's the manager. The models are the employees.

None of this is the hard part. The logic layer — agents producing specialized models — is solvable with today's technology. The actual bottleneck is context.

An agent can only train models on what it knows. And right now, agents know almost nothing about what you've actually been doing. They see the current prompt. They don't see the eight hours of screen activity, the meetings, the messages, the patterns in how you work. Without that context layer — continuous, comprehensive, ambient — the agent has nothing to distill.

Solve context, and Software 3.0 follows.

Software 1.0: humans write deterministic programs.
Software 2.0: humans train models that replace programs.
Software 3.0: agents train models that replace agents.

We're building the context layer at screenpipe. We capture everything you see, say, and hear — screen recordings, audio, UI events, meetings. The models are small enough to run on your laptop. The missing piece is the agent that closes the loop — that watches, distills, and improves. We're working on that.