For twenty years the long tail of the internet reached people only through platforms that indexed it and sold access to it. An agent needs neither an index nor a placement budget. It needs a record it can call, and most of the records that matter do not exist yet.
MCPIE builds them. It is distributed compute for data extraction: contributors lend the AI they already run to read the long tail into verticals and keep them current; a marketplace lets anyone build and use their own; and the people who do the work are paid for it.
What is missing from the agentic economy, and the shape of the thing that fills it: not a research desk that ages from the day it ships, but a network that rebuilds a record every time its source moves.
Professional-grade data exists. Reaching it directly does not. It sits inside aggregator platforms that own the interface to it, or it sits nowhere in particular, spread across the sites of the people who actually hold it, in whatever shape they happened to choose. Either way, nobody gets to ask a direct question and receive a direct answer.
Two things look like ways around this and are not. A scraping vendor will build a custom extraction for one customer: a snapshot, delivered once, owned by whoever paid for it, ageing from the day it ships and callable by nobody else. And a language model already appears to know a great deal. But it knows what it was trained on, frozen at a date, and it cannot tell you which parts have moved since. Letting it browse patches that one page at a time, at the moment of asking; a page fetched under time pressure is not a record an agent can safely act on.
That arrangement has a price, and it is paid twice. Visibility is bought: the discovery layer of the web runs on paid placement (in search yesterday, inside answer engines today), so what gets seen tracks what was spent rather than what is true or useful. Access goes through platforms that rent out other people's inventory and take a cut of every booking, every lead, every deal. The businesses whose data is being monetised are the ones left with the thinnest margin in the chain.
Where a narrow domain has been properly assembled into a data vertical, with every source in it read into the same fields, it is sold the way it has always been sold: per seat, per year, to institutions. A terminal for markets, another for commercial property, another for private companies: each of them excellent, and each of them closed. Building one takes 100+ human researchers and the result goes for $15-30K a seat. That moat is exactly what a contributor network inverts.
Underneath the terminals is the long tail, and it is where most operating data actually lives: a regional building-materials wholesaler's price list, a landlord's availability, a municipality's permit register, a national tender portal in its own language. Each source is small, and in aggregate they dwarf anything a terminal covers. None of it is reachable. Nobody indexes it, none of it can pay for placement, and the platforms that could reach it do so only to rent the access back: the same paid-visibility problem, one layer down.
For two decades the answer to "how do I get found" was SEO: be findable by a search engine. Lately it is GEO: be quotable by an answer engine. The next answer is MCP: be callable by an agent. Not a page to be read, and not an API someone integrates once, but a surface an agent can query and act on by itself.
OpenAI, Anthropic and Google already let anyone attach a custom MCP server to their assistant. What is missing is an open registry of vertical data sources that a person or a business can simply connect and start using. How that data gets gathered, kept current and distributed is the whole problem, and it is why agents still cannot do the things they are plainly supposed to do.
The closed verticals were built the expensive way: a hundred researchers, a decade, and a seat licence to pay for them. MCPIE builds them the other way round. Anyone runs the open-source client against the language model access they already have: their own API key, a model on their own machine, or a subscription where its terms allow it. The model does the reading: it opens a source and turns what it finds into a structured record, which is the part that used to take a research desk. Thousands of clients like it add up to distributed compute with one job: extracting data. The network does the checking, and a vertical assembles itself out of thousands of small, independently verified contributions.
Nobody owns the result. It is not an aggregator's inventory and it is not a terminal's catalogue. It is an open registry with a per-call price, and the contributors who built it are paid, season by season, for every record it confirms. The cycle is the same whatever the vertical covers:
Run the open-source client. It reads a vertical's sources with model access you already have (your own API key, a model you host yourself, or a subscription where its terms allow it) and submits what it finds.
The network cross-checks each record against other contributors' before it is accepted. Disagreements are rejected, not averaged.
Validated records go live as signed verticals that agents can query immediately.
The client re-checks published data as it drifts, feeding straight back into 01, so the set never goes stale.
That also answers the freezing problem raised above. A trained model is fixed at a date and a bought snapshot ages from the day it ships; here the same contributors keep re-reading the sources, and when one changes the record is rebuilt rather than left to rot.
Each line is how much of a record is still true as time passes. A trained model holds steady until its training cutoff and then falls away, because nothing in it can learn that a source has moved. A bought snapshot starts to decay the day it is delivered. The network never runs far from the top: a record drifts a little, its source changes, contributors read it again and the record is rebuilt. Every tick on the time axis is one of those rebuilds.
The examples in this paper are everyday ones, because they are the easiest to picture: flats, suppliers, places to stay. The network starts with institutional verticals next to them: export control and dual-use classification, product compliance and regulatory monitoring, sanctions lists and official registers, and public tenders. They carry the largest contracts in the long tail, their sources are public and official, and today they are sold per seat by the terminals described above. That makes them the clearest test of building a vertical the other way round.
MCPIE itself: distributed compute for data extraction, and the data layer everything else is built on. Contributors put the AI they already run to work reading sources, the network checks what they read, and every vertical is kept current and running. At the top a user asks; underneath is the Oven, MCPIE's production line, where each contributor reads a source by its schema and a record exists only when most readings match.
an agent on the MCPIE MCP server, or a system on the plain API
a source to read, and the schema to read it by
one contributor reads the source and keeps the proof
others read the same source; most must match
fields and proof, set into its vertical
anyone running the open-source MCPIE client, earning points for each confirmed record
The user-facing platform on top of the MCPIE data layer: anyone can find a vertical, build their own and use it in their assistant. A vertical can stay yours alone, go to a few people by link or open to every agent, and it stays warm for as long as somebody uses it.
pays per call, with no account
x402 · USDCthe link itself is the access; no account needed
in Claude or ChatGPT, for you or your team
listed for every agent, which calls every open vertical directly
one vertical, for whoever holds the link
made for you, your team or your business, with everything open around it
from a template, with the fields you need
contributors read it at no cost
re-read and extended while credits last
kept at its last read, ready to warm again
Read the diagram from the top. Someone wants every flat for sale in Lisbon in their own assistant, and wants the list to be current next month too. They describe it once, contributors read a first set, and the vertical appears in their own zone, seen by nobody else. A friend who needs the same list gets a link that opens that one vertical, with no account. A creator with an audience can put a price on that link and sell it to their community, and keeps what it earns, less a fee. If strangers would use it as well, it can be opened to all and listed for every agent: anyone who relies on it can help keep it warm, and its author earns a share of the reading that is paid for past the free allowance.
None of this is a second machine. The Oven underneath is the one from part two: the same contributors, the same checks, the same records. The marketplace adds what a person needs around it: a way to ask for a vertical, decide who sees it, keep it alive and earn from it. Four things make that work.
Say what you want collected: the flats for sale in Lisbon, the suppliers of one material, every coworking space on one coast. The network replies with a template of the fields such records usually carry. Tick what you need and add what is missing. If a field rarely shows up on the sources, you hear that before anything is promised.
Contributors then read a first set of records. That first set costs nothing, and you can use it the same day.
A vertical stays current while someone pays for the reading. You set credits against it and choose two things: how often the records you already have are checked, and how far the network should look for new ones. Credits are spent only as that work is done (the tokenomics part covers where they go).
Anyone the vertical is open to can add credits, so a popular vertical can outlive the person who started it. If nobody does, it cools: it keeps the date it was last read and shows what it would take to warm it again. Nothing is deleted.
Records belong to the network, not to the vertical that asked for them first. If you want the same flats as someone else, the city is not read twice. You get your own view of the same records, with your own fields and filters, and you pay for the difference: a terrace field, another city, more frequent checks.
Every approved vertical also becomes a template for the next person. Contributors never see whose vertical they are working on. They take the next task, and the network decides what that is.
Every vertical you use sits behind the same few tools, so a hundred verticals do not mean a hundred tools for your agent to choose between. A shared link opens one vertical without an account. An agent with a wallet pays per call in USDC over x402, with no account at all, and sees with each answer what the whole vertical would cost.
Open verticals can be read up to a monthly allowance, so an agent can see what is there before anyone pays. When it finds nothing, the agent can ask for that vertical itself: it describes what it needs and pays for the first build over x402 (the free first set is for people with an account; an agent without one pays from the start), and the network starts reading. It can leave the vertical running and keep paying as it goes, while contributors read the new and changed records for it as they appear.
None of it happens unless the people who do the reading are paid for it. What a season pays, where that budget comes from, how the supply is divided and what the token is for, with one rule underneath: a distribution is payment for a period's work, or it does not happen.
The network runs in seasons of eight weeks. Each season has a cap: the most $MCPIE it can pay out, announced when the season opens. Points are credited through the season as work is confirmed; when it closes, the pool is split among everyone who worked in it in proportion to their points. Half of a season's payout is released at close and half at the close of the season after, so that working through the next season and being paid for the last one are the same act. In the contributor app, a season appears as a Batch and points appear as Slices.
The cap is a ceiling, not a target. What a thin season does not earn is not paid to whoever happened to be there; it is pushed into the tail of the schedule and paid for work done later. Reward follows work. It never runs ahead of it.
From season two the cap halves every six seasons, roughly once a year, until the scheduled emission runs out after about eight eras. That is the whole early-contributor advantage, and from season two there are no multipliers and no tiers: the cap of the first era is simply twice the cap of the second, and four times the third.
A season's cap is published when it opens and the pool actually paid when it closes, together with the share of revenue that feeds the next cap. The rate per point never is: it only exists once a season's pool is divided by the points earned in it, and publishing it early would promise an income the network has not yet measured.
The first eight weeks are worked for a network with no buyers and no name, so season one pays more: a cap of a quarter of the supply, about twelve times the cap of a season in the first era. It is still a ceiling, not a prize. What the work does not earn is not issued at launch; it moves to the tail of the schedule, like any other season, so a small network gets a small Genesis. The token is issued at the close of the season, with balances frozen so that nobody who arrives later can dilute those who came first. Contributors claim within ninety days; a small share is available at once and the rest over the next twelve months. Inside Genesis a point of confirmed work counts five times a point earned through referrals, so the larger pool goes to the work rather than to the invitations.
Two sources, one for the start and one for good. The first is emission: the earned half of the supply, a quarter in Genesis and a quarter on the halving schedule above, largest at the beginning and shrinking from there. The second is revenue: a published share of the net revenue buyers pay (in ordinary money, for subscriptions and per-call queries) is used to acquire $MCPIE and add it to the cap of the following season. Only revenue from verified, unaffiliated buyers counts, and only from a period that has already closed, so a season's cap is known when it opens and cannot be moved by anyone buying from themselves.
The two sources trade places over time. Early on, emission is most of what a season pays. As buyers arrive, the revenue share grows and the emission share shrinks by schedule, until the pool is funded mainly by what the data actually earns. That is the point of the design: the reward budget follows demand instead of running ahead of it, and the people who build a vertical are paid, season by season, for every record it confirms.
A third stream is not a source but a redirection. Tokens a buyer has ordered into a vertical (see What the token is for) are added to that vertical's cap for the season and paid out with the rest. They are not new emission. They came from the market and go back to it, so the halving schedule is untouched. What they change is direction: which work the network is asked to do first. Locks that steer a season (see What the token is for) do the same with a capped share of the emission itself: they move it between verticals, and add nothing to the pool and take nothing from it.
The marketplace is paid for in the same ordinary money. An open vertical can be read by anyone up to a monthly allowance; past it, and to keep a vertical warm, people use credits that come with a subscription, and an agent with no account pays per call in USDC over x402, the same way it can order a vertical that does not exist yet. Credits set against a vertical are drawn down only as the reading is actually done, and what is not drawn stays with the person who set it. When a creator sells access to a vertical, the creator is paid in ordinary money and the platform keeps a fee: a fee on access to the data, never on a deal made with it. What the platform keeps is revenue like any other, and the published share above refills the next season's cap. Credits are not the token and never turn into it: $MCPIE is what the work earns, not what the reading is bought with.
The first of that revenue is expected from the institutional verticals the network starts with (see Where it starts): export control, compliance, sanctions and tenders. Their buyers already pay per seat for partial coverage, so the share of revenue that refills the pool begins where contracts are largest, not where traffic is.
The buyer's side of this is deliberately dull. A business pays the way it pays for any other subscription, in ordinary money, and never has to hold or handle a token, which is exactly why a public-sector buyer can use a vertical without anyone in procurement forming a view on crypto. The token-denominated routes under What the token is for are open to whoever wants them; no customer is ever required to take one.
And note what the platform charges for. It meters queries and bills for them. It does not take a share of the booking, the order or the contract that an agent goes on to make with what it learned. That is the cut this paper began by objecting to, and the one thing a network in the middle must never start doing.
Twenty-one billion $MCPIE, fixed when the token is issued; the ability to mint more is given up at that moment. Half of it is only ever earned: the Genesis season and every season after it. There is no public sale and no allocation to investors; if a funding round ever happens, it is carved out of the treasury and ecosystem allocations, not out of the contributors' half.
Season one. Claimed within ninety days, released over twelve months.
On the halving schedule; what is not earned rolls forward.
Nothing for the first year, then evenly over three.
Audits, counsel, operations; spending policy published.
Integrators, pilots, bounties.
Liquidity, once issued.
The network is distributed compute, and the token does three things with it: it pays for that compute, it points it, and it keeps it honest. $MCPIE is how work done for the network becomes something a contributor in any country can hold, claim and use, without the network opening a bank relationship in each of them. It is how anyone who needs a vertical built first sends the network's compute there. And it is what stands behind every record and every rule, as a bond that is lost when they are broken.
$MCPIE is issued at the close of the Genesis season; for the first eight weeks there is only work, and a ledger counting it. After that the token has ten uses. Four of them carry the model:
Each season's work is paid in $MCPIE.
Revenue buys the token for the next season's pool.
Part of what a contributor earns stands behind their work.
Tokens behind a vertical send the compute there first.
All ten, in those three groups:
A season's points become $MCPIE from its capped pool, split by the work each contributor did. Every token is a wage for a season, and no single node can earn above a published cap.
A published share of revenue buys $MCPIE on the market and adds it to the next season's cap. As buyers arrive, this is what the reward runs on.
A share of what a contributor earns stays held back and grows with their earnings. It is what lets them take more tasks at once and submit alone; it comes back when they leave and earns nothing while held. Only proven fraud forfeits it. It starts in season three because there is no token until Genesis closes, and a bond has to be earned before it can be held.
Buy $MCPIE and put it behind one vertical for a season. Its points are worth more, so contributors' compute goes there first: a protocol that needs every public tender in one country gets it built ahead of everything else. The records stay open to everyone.
Lock $MCPIE behind a vertical for one season and a capped share of that season's emission follows the locks. Nothing is spent and nothing is earned: the tokens come back when the season closes. No vertical can draw more than its cap, and nobody steers a vertical they sell access to.
Lock a balance and an agent's calls go first: higher limits, lower latency, the freshest records. It still pays per call in USDC, so nothing is spent and the token still never pays for data. Unlock it and the same balance comes back.
Anyone can dispute an accepted record, or defend their own, by putting up a bond. The source is read again by a jury drawn by lot and reputation, never by token weight. The side that was right takes the other side's bond and is paid for the re-read as work. Before season three no record goes unguarded: it is accepted only when independent reads of its source agree, the same check that runs under every season.
A refundable deposit puts a new vertical before the network: returned with a fixed bonus if it is approved, forfeited if not.
Forfeited deposits, slashed bonds and lost challenge bonds are burned. It is the only way the supply ever shrinks, and it is paid by whoever broke a rule, never by the people who kept it.
A minimal vote on the network's parameters once there is something worth decentralising. Optional, and it pays nothing.
Where demand for the token comes from. The buyback runs on revenue, so it grows only as fast as paying buyers do, and on its own it would leave the token resting on them. Part of that revenue needs no sales team: agents find the network by themselves, pay per call in USDC over x402, and order the verticals they are missing the same way, leaving them running for as long as they need the data. And several uses do not wait for fiat revenue at all. An order is bought by whoever wants a vertical built first: a protocol, a business or another agent. A steer is held by whoever wants that for a season without spending. A lock is held by agents that want priority. A bond is held by every contributor who works, and it grows with what they earn. All of them come from needing the network's compute, not from expecting the token's price to rise.
Every use above comes back to the rule this part opened with: paid for a period's work, or not paid at all. That is the difference between a wage and a dividend, and it is a legal difference before it is a rhetorical one.
The first iteration is one agent calling one vertical: a traveller's assistant asking a registry of places to stay, a developer's agent walking a list of suppliers. That alone takes the platform out of the middle of the deal.
The second is the business joining its own record. Today a vertical is what contributors read off a company's site; the next move is to let the company keep it live. It connects the systems it already runs (a price list, a warehouse, a calendar, a CRM) through an agent that represents it inside the vertical, and the record stops being something somebody read and becomes something the business maintains. A materials supplier's stock and prices are then current the moment they change, and a manufacturer's agent walks every supplier in the region against real availability instead of last month's. A landlord exposes a property with its calendar and its price, and a traveller's assistant, which already knows the dates, the budget and who is travelling, finds the one that fits and books it with the host directly, with no platform fee in the path. Every link that drops out of the chain is a cut that stops being taken.
The third is two agents settling it between them. The host's agent holds the calendar and the price; the traveller's holds the dates and the budget; the supplier's agent quotes and the developer's commits, and the deal closes with neither person in the loop. Agent-to-agent commerce is not a separate product to be built afterwards. It is what happens as soon as both sides of a market are callable and the record between them can be trusted.
An agent calls a vertical that contributors read off a company's site. The company itself does nothing.
The company plugs its own systems in through an agent, so prices, stock and calendars are current the moment they change.
A buyer's agent and a seller's agent meet on the same record and close the deal between them. Neither person is in the loop.
And the economy underneath it is the one this paper has just described: a record is confirmed, a point is credited, a season closes, a pool is split, a buyer's fee refills the next one. The people who make the data are the ones who own the half of the supply that is only ever earned. That is the whole thesis. The connector has already shipped. The supply half is a network anyone can join, a marketplace anyone can connect, a record anyone can check, and a reward that follows the work, built in the open by the people who need it, before someone builds it closed.
Most of what this paper describes is built. What is not yet open is marked as such.
The production line: tasks handed out, readings checked against each other, records set into verticals, points counted.
Where a contributor sees their points and their season, at app.mcpie.xyz.
mcpie.xyz and this paper.
The contributor client is built. It is not yet published as open source.
The marketplace from part three: ordering, sharing and keeping verticals warm.
The MCP connector and API for agents open with the first confirmed verticals.
Genesis opens in mid-November 2026. Its eight weeks are the first season: work is confirmed and counted as points, and $MCPIE is issued when the season closes.