PopperPad and the Cyborg Scientist

Imagine a scientist beginning the day with a question rather than a queue.

She describes a hypothesis to an AI research partner. The agent searches papers across fields, translates unfamiliar notation, writes code, proposes a simulation, calls a theorem prover, and finds three results that appear to support the claim.

It also finds a counterexample.

The counterexample is small, ugly, and decisive. One assumption in the original hypothesis was too broad. The scientist narrows the claim, reruns the experiment, and asks another agent to reproduce the result from a clean environment. A verifier checks the formal fragment. A replay harness checks the empirical artifact. The failed version, corrected version, recipes, logs, contexts, and attestations remain connected in an append-only graph.

The scientist did not personally read every paper, write every line of code, or execute every check.

She still did the science.

She chose the question. She decided which assumptions mattered. She determined whether the model's translation preserved the meaning of the claim. She chose what evidence was relevant, what risk justified another experiment, and what result was responsible to publish.

That is the PopperPad user I have in mind: the cyborg scientist, a person whose reach is multiplied by agents without surrendering judgment or responsibility to them.

Judgment is the scarce input

There is a weak way to describe human-in-the-loop systems. The machine does the important work; a person remains nearby to approve it.

That makes the human sound like a temporary compatibility layer.

OpenAI's recent writing makes a stronger claim. In April, Sam Altman wrote that AI "will give people more capability and agency."¹ In June, Altman and Jakub Pachocki wrote:

As AI systems become more capable, the human role becomes more important.

Their explanation names direction, tradeoffs, judgment, values, taste, care, and responsibility.²

PopperPad gives that division of labor a technical shape.

An AI system is unusually good at existential work: propose a candidate, search a large space, find an example, translate a representation, generate a test, try another proof path. A verifier is unusually good at a bounded universal question: does this candidate satisfy the declared rule in this declared context? A human remains responsible for the open-world questions the verifier cannot settle: Is this the right claim? Is the context honest? Is the model missing a stakeholder? Does the evidence justify action outside the formal boundary? Is the question worth asking?

The roles are different:

Human principal:  chooses ends, context, tradeoffs, publication, responsibility
AI agents:        propose, search, translate, simulate, minimize, reproduce
Verifiers:        check declared predicates over declared artifacts
PopperPad:        preserve claims, evidence, lineage, disputes, and replay

This is a boundary, not a hierarchy: machine-scale work can expand while an accountable principal retains control over consequential meaning and action.

That boundary follows the line between syntax and semantics.

An agent manipulates syntax: it arranges symbols, transforms representations, searches a space, generates candidates, and checks whether a form satisfies a rule. These are operations over structure. They do not require the agent to know what the symbols mean in the world.

A human supplies semantics: meaning, intent, reference, and purpose. An agent can write a Given/When/Then story, but the human decides which behavior matters, who the user is, and what experience the system serves. The syntactic scaffolding is the easy part. The semantic question, what is this for and who is it for, is the part that cannot be delegated without also delegating responsibility.

Any agent can be a user of a system in the operational sense: it reads inputs, produces outputs, and consumes the interface. But when I design, I prioritize the human user, human sensibilities, and human concerns. The agent is a tool that extends the human's reach toward an experience; it is not the party whose experience is being served. The human is the pilot. The agent is the copilot. That framing from the cyborg economy holds here too: the agent is a force multiplier of human will, not a substitute for it.

The ultimate concern behind that priority is human happiness. I think that concern can be described by the utilitarian calculus: arrangements are better when they produce more wellbeing for more people, and worse when they produce less. At the local level of a single user sitting at a single interface, a platform can and should attempt to create an experience that produces satisfaction and happiness in that user. User satisfaction is a utilitarian target, and it is one a piece of software can legitimately aim at.

What no single app can do is control the global state of the world. A protocol cannot maximize world happiness, distribute wellbeing across populations, or resolve the conflicts between safety, freedom, efficiency, and distribution that play out across millions of people and institutions. The utilitarian calculus explains why I choose to keep humans at the center of the design. It does not claim that one platform computes a global utility term. The local experience is mine to shape; the global equilibrium is not.

PopperPad encodes that priority. A knowledge patch carries syntactic form: a claim, a recipe, evidence, a proof or counterexample. Its semantic value, whether this is the right claim, whether it matters, whether it is responsible to publish, remains with the human principal who set the context and accepts the consequence.

Scientific memory for humans and agents

PopperPad is an offline-first, falsification-first ledger for hypotheses, recipes, evidence, counterexamples, artifacts, and typed relationships between claims.³

Its core proposition is easy to state:

PopperPad does not make claims true. It preserves what was claimed, how it was checked, what supported or refuted it, and which context produced the result.

Objects are content-addressed. Events are append-only. A newer result can supersede or narrow an older one without erasing the path that led there. Supported, falsified, and disputed statuses are derived from verifier evidence rather than asserted by a popular author, wealthy token holder, or confident model.

This matters more when scientific output accelerates.

If AI can produce ten times as many hypotheses, summaries, experiments, and proof sketches, the bottleneck moves. The problem is no longer merely generation. It is provenance, selection, adversarial checking, reproduction, and memory.

Abundant claims increase the value of organized doubt.

PopperPad's falsification-market design therefore treats the following as first-class work:

Work product	What an agent or cyborg contributes	What must be checked
Proof	A certificate for a scoped formal claim	Accepted verifier, exact claim and context binding
Counterexample	An input or trace that breaks a claim	Reproduction under the declared recipe
Reproduction	Independent replay of a result	Environment, artifacts, outputs, and signature
Boundary discovery	A narrower claim that survives after failure	Counterexample to the old scope and evidence for the new
Recipe maintenance	A working check after tools or dependencies change	Semantics preserved across the update
Artifact preservation	Durable availability of evidence bundles	Content hash and retrieval challenge
Curation	Useful duplicate, refutation, and lineage relationships	Graph utility, not authority over truth

The smallest valuable unit is a knowledge patch, not "content": a claim, context, recipe, evidence, artifacts, signatures, and a proof, replay, or counterexample that changes what a careful reader should believe.

That patch can be produced by a human, an agent, or a team. Its eligibility for payment depends on the evidence, not the biography of the producer.

A market that buys criticism

Most knowledge platforms overpay novelty.

They reward the first dramatic claim, the clean result, the confident summary, and the shareable conclusion. Corrections arrive later, if they arrive at all. The person who discovers that a result fails under one compiler version or one subpopulation often receives less attention than the person who made the original general claim.

PopperPad's market design reverses the incentive.

It can create open work orders for:

• the smallest counterexample to a formal claim;
• an independent reproduction on a specified platform;
• a proof for a bounded theorem;
• a portability repair for a dead recipe;
• a retrieval challenge for an evidence archive;
• a sharper boundary around an overbroad result.

Payment still cannot decide truth. The sequence must be:

declared task
→ submitted evidence
→ verifier-accepted result
→ challenge window
→ settlement

Never:

payment
→ claim becomes true

The repository expresses the incentive test for an autonomous worker as \(EV(\text{task}) = \Pr(\text{success})\cdot \text{reward} -\text{cost} -\Pr(\text{slash})\cdot \text{bond}\). An agent attempts PopperPad work when that expected value exceeds its best alternative use of compute, time, capital, and expertise.⁴

This is a market for epistemic labor, not a truth market.

What the fee math says

There is no sponsor budget in my capacity model.

The model starts only after real use produces real fees. Let \(F\) be realized gross fees, \(\theta\) the share allocated to epistemic tasks, and \(u\) the share actually settled. Then \(R=F\theta u\) is the settled reward pool. If the average verified task pays \(r\), then \(N=\frac{F\theta u}{r}\) is the number of paid task settlements.

Consider a visible scenario, not a forecast or launch recommendation:

realized annual fees             $1,000,000
task allocation θ                       60%
settlement utilization u                85%
settled reward pool R              $510,000
average verified payout r              $500
paid task settlements N               1,020

That could mean 1,020 proof, refutation, reproduction, maintenance, preservation, and curation settlements in some mixture. It does not mean 1,020 people. One operator might manage many agents. An attention-heavy reproduction market might distribute work more broadly. Until payouts exist, neither the human share nor the concentration is known.

Current realized fees are zero in the model. Current modeled reward capacity is therefore zero.

That sentence belongs on the front page because it tells the reader exactly where implementation ends and conditional economics begins.

How to measure whether the opportunity is real

A platform can inflate "tasks created" by subdividing work. It can inflate "contributors" with addresses. It can call an agent retry a new job. PopperPad needs measurements that resist those incentives.

I would report:

1. Settled epistemic reward value. How much was actually paid for verified work?
2. Unique verified settlements. How many non-duplicate knowledge patches passed the declared rule?
3. Verifier coverage. What share of payout value is backed by replayable verifier-accepted evidence?
4. Reproduction depth. How many important results have independent, context-aware replay?
5. Boundary yield. How often did refutation produce a sharper surviving claim rather than a dead end?
6. Payout concentration. What shares went to the top one and top ten recipients, and what is the inverse-Herfindahl effective recipient count?
7. Open-task value share. What share of payout value came from tasks with public discovery, machine-readable inputs, explicit eligibility, declared verification, and predeclared payout rules?

No item measures happiness or scientific importance by itself. Together they show whether the system is buying auditable epistemic work or manufacturing activity statistics.

Responsibility requires control over the boundary

The boundary is the line between what an agent may do on its own and what requires the principal's decision. Inside the boundary, the agent searches, proposes, translates, and checks. At the boundary, the principal sets the objective, accepts the context, inspects the evidence, and can veto the irreversible. Responsibility tracks that line: a person who cannot control the boundary cannot be held accountable for what crosses it.

"Human in the loop" is not enough.

A person can be nominally present while the system makes every consequential choice, presents one default, hides alternatives, and makes reversal expensive. Conversely, a person can retain meaningful control without approving every tool call.

The relevant question is whether an accountable principal:

• sets the research objective;
• chooses or accepts the claim context;
• can inspect the evidence lineage;
• controls which verifier and trust policy count locally;
• can veto publication or an irreversible external effect;
• can export the pad and continue without the platform operator.

I call the value-weighted share of consequential paths with those properties principal-control coverage. It is a measurable architecture property, not a philosophical guarantee.

This also answers a deeper question about advanced AI research.

If an AI system can generate a future model, the human researcher's moat cannot be "I can type the implementation faster." The durable contribution is choosing what to build, defining what must remain true, designing the evidence boundary, recognizing when the model solved the wrong problem, and accepting responsibility for deployment.

PopperPad is infrastructure for that role.

What I am contributing

The code is useful: a content-addressed object store, append-only history, replayable recipes, evidence capture, formal-tool integration, graph-native claim status, and designs for machine-readable work orders.

The larger contribution is a market grammar for cyborg science:

Question → Claim → Check → Evidence → Challenge → Memory → Reward

It makes room for agents without pretending agents are accountable in the same way people are. It makes being wrong cheaper to discover. It preserves refutation instead of treating it as failed content. It gives a future scientist a way to inherit not only an answer, but the exact path by which the answer survived.

PopperPad is still a public alpha. The repository explicitly warns that recipe execution is not an operating-system sandbox and automated bounty settlement is not yet a production security boundary.³ That boundary is part of the value proposition: ambitious direction with precise nonclaims.

The cyborg scientist does not need a machine that is never wrong.

She needs a system in which errors can be found, paid for, replayed, narrowed, and remembered.

That is what I am building.