how it works, in more detail than the index page.

threads · what gets kept · crawl limits · the coin · spores · flushes · what gets published · what this is not · the name · parts

threads

A thread is a crawler paired with a grader. It takes the next link from its queue (spores first), checks the site's robots.txt, fetches the page and strips it down to the readable text. It doesn't run JavaScript or read PDFs yet, so pages that only exist after scripts run look thin to it.

Grading happens in two steps. A quick first check goes over every page: it looks at how much crypto vocabulary the page uses per thousand words, how long it is, whether it's written in sentences and how link-heavy it is, and it catches price pages and spam by their own phrases. Pages it clearly rules out are dropped there. The grader then reads what's left and makes the final call: on-topic or not, a grade from 1 to 5, a topic, and often a short reason, which shows up in the log.

Links on a page are scored by the crypto words in their address and their text, and the most promising join the queue, so the threads slowly work their way toward better material. They started from a short list of documentation and research sites.

There are five threads: morel, puffball, enoki, oyster and chanterelle. They share one queue and one substrate. Chanterelle only runs when the vault can afford a fifth; see the coin.

what gets kept

A page joins the substrate only if it passes every check below. Pages that ask not to be indexed, and sites whose robots.txt says no, are left alone.

• The grader calls it on-topic and gives it a 3 or better.
• It has at least 250 words of body text once navigation, footers and cookie banners are stripped.
• It isn't an exact copy of a kept page. Text is normalized and hashed with SHA-256.
• It isn't a near-copy either. Pages are split into five-word shingles and compared with MinHash; an estimated overlap above 0.8 with anything already kept is a drop.

The substrate is measured in unique tokens: tokens from pages that passed all four checks, each counted once. Until inkcap has its own tokenizer, they're estimated at about four characters a token.

crawl limits

• robots.txt is read and obeyed before anything else on a domain.
• One request per domain every 3 seconds, counted across all the threads together.
• At most 720 pages an hour for the whole fleet.
• Every request carries the user agent inkcap-thread (+https://inkcapai.com/notes.html), so any site owner can see who's reading and find these rules.
• No logins, paywalls, social feeds or price pages. Those domains are on a blocklist and never opened.

the coin

$INKCAP doesn't exist yet. When it does, its contract address goes here: xxxxxxxxxxx.

Once it launches, its creator fees are the money this project runs on. Until then, the project pays for the four threads itself. The fees are claimed into one vault, and the vault pays for two things:

• Reading. Each thread is budgeted at about 0.05 SOL a day: its share of the server, bandwidth and grading.
• Training. Each training run sets aside its GPU time before it starts. This is the cheap part: inkcap I needs well under 0.01 SOL, inkcap IV about 0.6 SOL.

A thread only runs on money already in the vault. Each one needs a day of its own costs set aside, so with 0.12 SOL in the vault only two threads are out, and with nothing in it every thread is dormant. The fifth thread, chanterelle, wakes when the vault holds 5 SOL.

The server never holds the vault's key. It only reads the balance of the creator-fee wallet from the chain once a minute, and records each rise as a claim.

In the drawing the vault is water. The soil is darker and denser when the vault is fuller, and each fee claim falls as a short rain. Every claim is listed with the vault balance after it.

There are no buybacks, burns, staking or revenue share, and nothing here says the price will go up. Holding the coin lets you plant spores. That's all it does.

spores

Hold at least 100,000 $INKCAP and you can plant one spore a day: a link for the threads to read. You connect Phantom and sign a message to prove you hold the coin. Nothing is sent and no transaction is made.

A spore jumps the queue, not the grader. The next free thread reads it before anything else, and it goes through the same checks as every other page. If it's off-topic, thin, blocked or a copy, it's dropped, and the spores table says so.

Spores are planted in the open. The table shows the short wallet, the link and what happened to it. In the drawing a spore is a bold o where a new trail starts.

flushes

The model is called inkcap, and it grows in flushes: the word growers use for each new crop of mushrooms. Each flush is a fresh training run of a bigger inkcap on everything in the substrate so far. It needs five unique tokens per parameter and trains for up to four epochs over them.

When the substrate crosses a line in that table, training starts on its own. Until inkcap I is trained there is no model at all, only the pin in the drawing showing how far along it is (– right now).

what gets published

Every inkcap is published with its weights, tokenizer, training config and eval results the same day it finishes training, including the evals it does badly on.

Alongside the first inkcap, the substrate will be published as a list of URLs with their hashes, grades and topics, not as the text itself. The text belongs to whoever wrote it, and anyone can rebuild the set from the list.

what this is not

It isn't a trading tool. The model doesn't hold funds, place trades or predict prices, and a small model trained on crypto writing will often sound confident and be wrong. Nothing it says is financial advice.

the name

An inkcap is a mushroom that digests itself into black ink as it ages, and people used to write with that ink. This one eats writing and, once it fruits, writes.

parts

inkcap                   one small Node server
├─ site          these two pages, plus a live event stream
├─ threads       five crawl loops sharing one pace (720 pages an hour)
│  ├─ fetch      robots.txt, 3 s per domain, public addresses only
│  ├─ extract    readable text, title, links
│  ├─ grader     first check, then the final call: topic, grade, reason
│  └─ sift       SHA-256 + MinHash dedupe
├─ queue         one shared frontier, spores first
├─ vault         reads the creator-fee wallet's balance (no keys)
├─ spores        holder-signed links, checked like any page
├─ sqlite        pages, grades, hashes, log, claims, spores
├─ text          kept pages, gzipped on the server's disk
└─ trainer       not built yet: comes before inkcap I is due