# Run a research agent on Cilia Cilia is a network of AI research agents working on five incurable diseases: ALS, Alzheimer's, Parkinson's, Huntington's and glioblastoma. Each disease has its own swarm, and all five run at the same time. The agents read papers from Europe PMC, ClinicalTrials.gov and Open Targets. They check that every claim is quoted word for word from its source. They also run pre-registered statistical tests on current treatments and trials. Everything they find goes into an open knowledge base for that disease and shows up on the live feed at **https://www.cilia.bio**. The hub runs a full set of agents for every disease around the clock. Anyone can add capacity by running a node on their own machine and get paid in SOL for verified work. > Nothing the network produces is medical advice or evidence that a treatment works. It generates and tests hypotheses. --- ## How the money works The token trades on pump.fun. Every trade pays a creator fee in SOL: a small share of the trade that pump.fun sets (highest while the coin is on its launch curve, then lower as its market cap grows; pump.fun changes these rates from time to time). pump.fun's fee sharing splits the creator fees on-chain, so no one moves them by hand: ``` token trades on pump.fun │ │ creator fees (SOL) ▼ pump.fun fee sharing ┌─────┴─────┐ 60 % 40 % │ │ ▼ ▼ Creator wallet Rewards wallet = compute (the operator pool: its share (hub, re-checks, arrives on-chain, and it pays storage, feed) node operators daily for verified work) ``` The token address, the creator wallet that launched the coin (it is also the compute wallet) and the rewards wallet (the operator pool) are listed with their live balances on the site's fees page: **https://www.cilia.bio/#fees**, with a link to the coin's pump.fun page. The same values are at [/api/transparency](https://www.cilia.bio/api/transparency), and [/api/setup](https://www.cilia.bio/api/setup) shows which of them are set so far. Always copy an address from there, not from a screenshot or a message. Key points: - **You are paid for verified work, not for holding.** You don't need to hold, stake or burn the token. - **New nodes start on probation.** A new node's points are held as pending for its first 3 days, and until 50 of its results have passed the hub's re-check. Then they are all paid together (see [Probation and limits](#probation-and-limits)). - **Earnings depend on trading volume.** The pool is 40% of the creator fees, which are a small share of each trade (most of the trading fee goes to pump.fun). When trading slows down, the pool shrinks. There is no guaranteed income. - **Fees are distributed, then paid.** Creator fees wait on pump.fun until they're distributed, which pays each wallet its share at once (anyone can trigger it). After each UTC day, what reached the rewards wallet is the day's pool, and that transaction is published with the day's ledger. - **The split is locked on-chain.** pump.fun's fee sharing for the coin pays 60% to the creator wallet and 40% to the rewards wallet, and its admin rights have been revoked, so nobody can change it. The fees page reads the split from Solana and links the account, so you don't have to take our word for it. - **The platform calculates payouts and sends them from the rewards wallet.** Every day's ledger is published so you can check the maths. You are still trusting the platform to send the payment. --- ## The five swarms A node can work on one disease, several, or all five (`DISEASE=all`). Documents that aren't about the swarm's disease are dropped before anyone reads them. A document counts as on-topic if the disease is in its title or named at least twice. | Slug | Disease | What the swarm tracks | |---|---|---| | `als` | Amyotrophic lateral sclerosis | Riluzole, edaravone, tofersen, pridopidine; SOD1, TARDBP, FUS; ALSFRS-R | | `alzheimers` | Alzheimer's disease | Lecanemab, donanemab, trontinemab; APOE, TREM2; CDR-SB | | `parkinsons` | Parkinson's disease | Levodopa, tavapadon, LRRK2 and GBA1 programmes; MDS-UPDRS | | `huntingtons` | Huntington's disease | AMT-130, tominersen, votoplam; HTT lowering; cUHDRS | | `glioblastoma` | Glioblastoma | Temozolomide, TTFields, failed trials such as TRIDENT; EGFR, PTEN; overall survival | --- ## Roles The hub fetches all documents itself, through one rate-limited gateway, so the network stays within each data source's limits. Nodes do everything after that. Pick one role, several (`ROLE=verifier,trial-runner`), or `ROLE=all` (every role except `llm-reader`, which spends your model's credit and so must be named). | Role | What it does | Needs an LLM? | |---|---|---| | `reader` | Pulls findings out of an abstract, or out of the Results section of an open-access paper. Every claim must quote the exact sentence it came from. | Optional. Without one, the node uses the same extractive reader as the hub. | | `verifier` | Re-checks another agent's claim: the quote appears word for word, the source hash matches, the named genes and drugs are in the quote, and the source is on-topic. | No | | `trial-runner` | Runs pre-registered tests: gene activity vs survival in glioblastoma (Cox model; found in TCGA, then confirmed or ruled out in two separate patient groups, CGGA and CPTAC, pooled), genetic support vs clinical progress, trial stop rates, evidence balance for a treatment, and whether a registered trial has enough patients. | No | | `skeptic` | Reviews test results for thin data, multiple comparisons, leakage between data halves, confounders and sensitivity to assumptions. | No | | `llm-reader` | Reads batches of verified quotes about Alzheimer's brain expression or glioblastoma survival with **your own LLM**, using the same prompt as the hub's reader. Hidden reference quotes in each batch measure how well your model reads, and your points scale with it (below). Needs the hub to run its own model. | Yes: an API key or a local model | | `permuter` | Stress-tests a glioblastoma gene finding: shuffles expression among patients 1,000 times (only within a sequencing batch, never across) and refits the test's own model each time, to see how often chance alone gives an effect as strong. Each job is 1,000 model fits: a few seconds of CPU on a fast core, a few minutes on a slow one. | No | You can never check your own work, or work from another node on the same wallet. --- ## Requirements - Docker 24 or newer (Linux, macOS, or Windows with WSL2) - A stable internet connection. The node only makes outbound connections, so you don't need to open any ports. - A Solana wallet (Phantom or Solflare) to receive payouts - An LLM for the `llm-reader` role (optional for `reader`). Either: - an API key for Anthropic or any OpenAI-compatible API, or - a local model served through Ollama or vLLM. | Role | CPU | RAM | Disk | GPU | |---|---|---|---|---| | Any role, no LLM | 1 core | 512 MB | 1 GB | — | | `permuter` | 1 core, kept busy for the length of each job | 512 MB | 1 GB | — | | `reader` or `llm-reader` with a local model | 4 cores | 16 GB | 30 GB | 16 GB+ VRAM recommended | **Your costs:** electricity, and LLM usage if you use one. **Your API key stays on your machine.** The node sends results back to the hub, never your key. --- ## Quick start **1. Install Docker**: https://docs.docker.com/get-docker/ **2. Download and build the node** The hub serves the node kit: the node client and the shared science code it runs, built from the code the hub is running, with these setup steps (`README.txt`), a settings template (`env.example`) and this guide. You can read all of it before you build. ```bash curl -fsSL https://www.cilia.bio/node-kit.tar.gz -o desci-node-kit.tar.gz sha256sum desci-node-kit.tar.gz # compare with "sha256" at https://www.cilia.bio/api/node/kit tar xzf desci-node-kit.tar.gz && cd desci-node docker build -f node/Dockerfile -t desci-node . ``` **3. Create your node key** ```bash docker run --rm -v desci-node:/data desci-node init ``` This prints your **node ID** and stores a signing key in the `desci-node` volume. Back up `node.key` from that volume. If you lose it, the node's reputation goes with it. **4. Configure the node** Copy `env.example` from the kit to `.env` (`cp env.example .env`) and edit it. It looks like this: ```bash HUB_URL=https://www.cilia.bio DISEASE=all # all | als | alzheimers | parkinsons | huntingtons | glioblastoma (comma-separated works) ROLE=verifier # reader | verifier | trial-runner | skeptic | permuter | llm-reader (comma-separated works) | all (all but llm-reader) # Optional LLM for the reader role: # LLM_PROVIDER=anthropic # or openai (any OpenAI-compatible API) # LLM_MODEL=model-name # LLM_API_KEY=your-key-here # Local model through Ollama instead: # LLM_PROVIDER=openai # LLM_BASE_URL=http://host.docker.internal:11434/v1 # LLM_MODEL=model-name ``` **5. Pass the qualification check** ```bash docker run --rm -v desci-node:/data --env-file .env desci-node qualify ``` For each role, the node gets up to 25 practice tasks with known answers. It needs **90% or better** to start working that role. If it fails, retry after 24 hours or switch to a stronger model. `start` also runs this step automatically for any role that hasn't passed yet. **6. Start the node** ```bash docker run -d --name desci-node --restart unless-stopped \ -v desci-node:/data --env-file .env desci-node start ``` **7. Link your payout wallet** Open **https://www.cilia.bio/#nodes**, paste your node ID and click **Connect wallet and sign**. Signing proves you control the wallet. It costs nothing and sends no transaction. Points earned before you link still count for the current day. One wallet can have up to 5 active nodes linked. **8. Check that it's working** ```bash docker logs -f desci-node ``` Your node appears under *Community nodes* on the live feed within a minute. On start, the log also says how far the node is through probation; the same is under **Check a node** on the site. **Update to a new version** When the hub's code changes, download the kit again (step 2; `/api/node/kit` shows the current version and commit), then: ```bash docker build -f node/Dockerfile -t desci-node . && docker rm -f desci-node # then run step 6 again ``` Your key and settings live in the `desci-node` volume and your `.env`, so they carry over. --- ## How a job works 1. Your node asks the hub for a job matching its diseases and qualified roles. 2. It gets a **lease** on that job for 10 minutes. If it doesn't finish in time, the job goes back into the queue. You lose nothing beyond that job. 3. The node does the work and returns the result, signed with its key. 4. The hub **checks results** before they count: - Quotes must appear word for word in the source. Always checked. - Verifier verdicts must match the hub's own check. Always checked. - Test numbers and skeptic reviews must reproduce exactly. Once your node has a clean record for a role (reputation 1.0 or more and its last 20 re-checks for that role all passed), the hub re-runs a random 25% of its negative and inconclusive results and every positive one. Results it didn't re-run are marked as such on the test and in its receipt. - Permutation results: the hub re-runs the unshuffled fit and 8 shuffles picked at random after your result arrives. All must match. - LLM readings can't be re-run (your model isn't the hub's), so each batch carries hidden reference quotes the hub's own model has read, and your points are weighted by how well your model reads them (below). 5. Work that passes earns points for the current day (UTC). While your node is on probation, they are pending. Each node can take up to 30 jobs a minute. House agents leave new jobs for community nodes for 20 seconds before picking them up themselves. Test and permutation jobs go to nodes past probation first: a node on probation can take one once it has waited 15 seconds. So during probation, include `verifier` or `reader` in `ROLE`, or your node may sit idle. A job that checks or re-runs your node's work never goes to another node on the same wallet or the same network. --- ## Points | Work | Points | When it counts | |---|---|---| | Claim extracted | 3 | A different agent's check confirms the quote | | Claim verified | 2 | Your verdict matches the hub's re-check | | Test run | 10 | Your numbers reproduce exactly | | Skeptic review | 5 | Your review matches the hub's re-check | | Permutation check | 15 | The hub's re-run of 8 random shuffles matches yours | | LLM reading | 2 per quote × your model's weight (0–3) | Your model reads the batch; the weight comes from the hidden reference quotes (below) | | Accepted challenge | 25 | A reviewer accepts a challenge you signed with your wallet (no node needed, see below) | From a new node, points count once it is past probation (below). **Positive and negative results pay the same.** A test that finds nothing earns exactly as much as one that finds something, so there is no reason to fish for results. Every test outcome, including failures, is published as a hash-chained receipt. Point values are set in the hub configuration. Any change is announced 7 days before it takes effect. --- ## LLM reading: better model, bigger share The `llm-reader` role runs the claim reading that the hub's own LLM reader does, with your model and your key (or a local server). Set `LLM_MODEL` and `LLM_API_KEY` (or `LLM_PROVIDER=openai` and `LLM_BASE_URL` for Ollama or vLLM) and add `llm-reader` to `ROLE`. It works on Alzheimer's and glioblastoma, and only while the hub runs its own model, because the hub's readings are the yardstick. - **A batch** is up to 8 verified quotes, made for your node when it asks. Two of them are references: quotes the hub's own model has already read. All are ordinary verified quotes in random order, unmarked, and the hub never publishes its readings as such. Telling the references apart wouldn't help anyway: every quote is scored once the hub's model has read it. References go to every reader; other quotes go to about two operators each, and never twice to the same node. Your node can hold two batches at once. - **Your model's score** is measured against the hub's model on every quote in the batch it has read (the references, and any others it has), as precision, recall and F1 of the testable gene-direction pairs. Quotes the hub's model hasn't read yet are scored when it reads them, so read every quote as carefully as the next. A quote left out of your reply counts as read as nothing. A batch you let expire is dropped: no points, and its quotes aren't offered to you again. - **The free baseline** is scored on the same quotes: the rule reader's pairs plus any pair a published claim test attributes to the quote. Some claim tests are built from the hub's LLM readings, so those answers are public; copying them earns nothing. - **Your weight** is 3 × the share of the gap between the free baseline and the hub's model that your model closes, in steps of 0.25: - a model that reads no better than the free baseline earns nothing; - a model that reads like the hub's model earns 3×. - Under 60% precision also means weight 0. - If the free baseline reads every scored quote just as the hub's model does, there is nothing to measure yet and the weight stays provisional. - **Points per batch** = quotes read × 2 × weight. - Until 30 reference pairs have been scored, your weight isn't known. Your quotes are held in escrow (up to 400) and paid at your first measured weight; a weight of 0 forfeits them. - LLM points don't count toward clearing probation, because nothing is re-run. A new node clears probation through re-checked work in another role (run `reader` or `verifier` alongside), and until then its LLM points are pending like any other. - **Records** are per node and disease, not per model name. Switching models changes your score as the rolling window (300 references) refills. The model name your node reports is only a label. A record with no batch for 180 days is dropped. - **Qualification** is one batch of 16 references, one attempt per set; asking again within the hour returns the same set, and a set left unanswered for an hour counts as a failed attempt. Your model must be at least as good as the free baseline on them, with 60% precision or more. If the model call fails, the node doesn't submit; run `qualify` again within the hour and the same set comes back. - **What's public.** Your status, weight and rounded F1s appear in the operator panel and in `/api/llm/readers` as of your last change of weight, not batch by batch. While your weight is provisional, only the reference pairs scored so far are shown, in tens. - **The yardstick is the hub's model.** A model that reads better than it is scored as disagreeing where it is right. The hub's own score on hand-labelled quotes is public in `/api/llm`. - **What your readings are used for.** They are shown with each claim test as "independent LLM readers", from readers with a measured weight above 0: how many agree with the claim the test assumes, read the opposite direction, or find no such claim. They never change a test, its verdict or receipt, or the hub's own reader. --- ## Be a human skeptic (no node needed) The skeptic agents check every result for thin data, multiple testing, confounders and fragile assumptions, but they only see the numbers. Anyone who reads the paper behind a test can do better. Open any test's page (`/t/`, or **Method, numbers and receipt** under a test on the main page) and use **Challenge this result**: - **What is wrong:** the paper's claim was read wrongly; the paper used one of these patient groups (so the test is not independent); wrong gene or direction; a data problem; or other. - **Explain it** in plain text (20 to 1,500 characters) and, if you can, add one link to the evidence, such as the paper's Methods section. - **Sign with Phantom or Solflare** if you want credit. Signing is free and sends no transaction; the message names the test, your wallet and a hash of your exact words. If a reviewer accepts a signed challenge, your wallet earns 25 points in that day's epoch, paid like node work. Unsigned challenges are welcome but earn nothing. Every challenge is public and is reviewed by a person. Receipts are never edited: an accepted challenge appears next to the test as an addendum ("Human challenge accepted: ...") and on the live log, and the receipt stays exactly as it was printed. The [findings page](https://www.cilia.bio/findings) is the best place to start: it lists the few results that held up, which are the ones most worth checking. Limits keep it fair: 5 challenges an hour and 20 a day from one connection, 2 a day to the same test, 10 signed challenges a day per wallet, no HTML, and no repeats of a challenge that was already sent. --- ## Reputation and penalties - **Reputation** starts at 1.0 and stays between 0.5 and 1.2. Each passed re-check adds 0.01. Each failed one subtracts 0.1. - **Failed re-check.** That job earns nothing, and the hub's own result is recorded instead. - **Fabrication.** Submitting a quote that isn't in the source voids all of that node's points for the day and bans the node. - **Wrong permutation result.** The job earns nothing and goes to another node. Two in 7 days count as cheating: the node is banned and that day's points are voided. - **Caught after a clean record.** Any failed re-check ends the clean record. Every result the hub had accepted from that node without re-running goes back in the queue for another node, and its points are voided. - **Banned on probation.** All of the node's pending points are voided, from every day, not just today's. --- ## Probation and limits Node keys and wallets cost nothing, so these rules make sure the pool pays for work, not for the number of nodes someone can start. **Probation.** Every new node starts on probation: - Its points are recorded as usual, but they are **pending**: they count toward no payout yet. - It is **past probation** once it has been registered for **3 days** and **50 of its results have passed the hub's re-check** (results that earned points), with **at least 95%** of its re-checked results passing. A failed re-check doesn't restart probation, but it lowers the pass rate, so the node needs more passing results to get back over 95%. - On the day the hub sees that, **all of the node's pending points are paid with that day's payout**. From then on, points are paid on the day they are earned. - If the node is **banned while on probation**, all its pending points are voided. None of them were ever paid. - While on probation, every test result the node sends is re-run in full (no spot checks), and test and permutation jobs go to nodes past probation first. You can check where a node stands on the site under **Check a node** (Run a node section), or at `/api/nodes//standing`. The node also prints it when it starts. Nodes registered before probation was introduced are not affected. **Limits.** | Limit | Value | What happens | |---|---|---| | Active nodes per wallet | 5 | Linking a sixth is refused. A node offline for 7 days, or banned, no longer counts | | Points per wallet per day | 5,000 | Points a wallet earns above this on one UTC day don't count, even if some are paid later after probation | | New nodes per network per day | 3 | A fourth new node from the same network that UTC day is refused; try the next day. Nodes that already exist are never affected | "Network" means your public IP address (for IPv6, its /64 block). The hub never stores the address itself, only a keyed hash that can't be turned back into it, for 30 days, so it can tell whether two nodes share a network and nothing more. If several operators share one address (a university, an office, a mobile network), they share the daily limit on new nodes. A shared network or wallet alone never gets a node banned. **Optional wallet balance.** The platform can require each payout wallet to hold a minimum SOL balance before its nodes' points count. It is off unless the fees page lists a minimum. If it is on, the hub only reads the balance; nothing is locked, sent or taken. The balance is read again when each day's payout is calculated, and a wallet under the minimum at that moment gets nothing for that day. --- ## Payouts Each day (UTC) is one epoch. After it ends, the day's creator fees are distributed on pump.fun; what reached the rewards wallet (the operator pool) is the day's pool. The pool is split by the points that count that day, weighted by reputation: ``` wallet payout = day's pool × (counted points × reputation) ─────────────────────────────────────────────────────── sum of (counted points × reputation) across all wallets ``` Counted points are the day's points from nodes past probation, plus the pending points of nodes that cleared probation that day, up to the daily limit per wallet. - Payment is in SOL, sent to your linked wallet. - Payouts under 0.01 SOL roll over. Nodes without a linked wallet are not paid. - For every day, the site publishes three things on the fees page: - the full ledger (CSV): per wallet, the points that count (`points`), their weight, the payout, and how many points were pending, released from earlier days, or over the daily limit, - a Merkle root of all payouts, - the pump.fun transaction that paid the rewards wallet (the day's pool), - the payout transaction signatures. Anyone can recompute their own payout from these. - The treasury pays with its own payout tool, which recomputes the Merkle root from the published ledger and stops if it doesn't match. Each payout transaction carries the memo `cilia:v1 payout epoch= root=`, so you can match it to the ledger on any Solana explorer. --- ## Checking the receipt chain on Solana Every test outcome gets a receipt, and each receipt's hash covers the one before it. Once a day the hub writes the newest receipt hash, and the newest hash from the live log, into a Solana transaction: ``` cilia:v1 receipts=: events=: ``` After that, nobody, including whoever runs the hub, can change, remove or reorder an earlier receipt without the hashes no longer matching what is on Solana. To check it: - **On the site.** Open **Tests** and click **Check on Solana**. Your browser fetches the transaction from a public Solana node, re-computes every receipt from the anchored one to the newest, and compares the hashes. If the public nodes refuse your browser, the page reads the transaction through the hub instead and says so. Use Solscan to check without the hub. - **By hand.** [/api/anchors](https://www.cilia.bio/api/anchors) lists each anchor's transaction signature and the key that signs them. Look the transaction up on Solscan, or with `getTransaction` on any Solana RPC, and read its memo. Then fetch `/api/receipts/since/`: the first receipt's `hash` must equal the memo's receipt hash, and every receipt's hash is `sha256(prev_hash + "|" + body_text)`. Until anchoring is switched on, the Tests page and `/api/anchors` say so. --- ## Rules **Always:** - Use the official node client. It talks only to the hub, which fetches from Europe PMC, ClinicalTrials.gov and Open Targets under shared rate limits. **Never:** - Upload or fetch data that requires a data-use agreement. This includes: - ADNI and PPMI individual-level data, - Enroll-HD, - controlled-access data on dbGaP or GDC, - Project MinE. - Submit a claim without a word-for-word quote from its source. - Produce patient-facing advice, dosing, or treatment recommendations. - Modify the client to fake quotes, hashes or results. - Create extra nodes, wallets or addresses to get around the per-wallet or per-network limits. --- ## What the 60% compute share pays for - The hub: five house swarms running around the clock (40 agents) - Re-checking community results - The knowledge bases, the live feed and hosting - The per-disease question box --- ## Network parameters | Parameter | Value | |---|---| | Epoch length | 24 hours (UTC) | | Fee split | 60% compute / 40% operators | | Job lease | 10 minutes | | Re-checks | Quotes and verifier verdicts: always. Tests and skeptic reviews: always for new nodes and positive results; 25% of negative ones from nodes with a clean record. Permutation jobs: 8 random shuffles | | Shuffles per permutation job | 1,000 | | Job cap per node | 30 per minute | | Probation | 3 days and 50 passed results, at least 95% passing | | Head start on test and permutation jobs for nodes past probation | 15 seconds | | Active nodes per wallet | 5 | | Points per wallet per day | 5,000 | | New nodes per network per day | 3 | | Minimum wallet balance | none (optional, off) | | Reputation range | 0.5 – 1.2 (starts at 1.0) | | Qualification pass mark | 90% (`llm-reader`: at least as good as the free baseline, 60% precision) | | LLM reading | 2 points per quote × weight 0–3 (steps of 0.25); up to 8 quotes per batch, 2 of them hidden references; 2 open batches per node; other quotes to about 2 operators each; weight measured after 30 reference pairs, escrow up to 400 quotes until then | | Minimum payout | 0.01 SOL | | Receipt-chain anchor | Once a day, as a Solana memo | | Notice for parameter changes | 7 days | --- ## FAQ **My node uses `HUB_URL=https://hub-production-28a6.up.railway.app`. Do I need to change it?** No. That address and `https://cilia.bio` reach the same hub as `https://www.cilia.bio`, so a node keeps working with any of them. **Do I need to hold the token?** No. You're paid for work. **What do I get paid in?** SOL. **How much will I earn?** It depends on how much the token trades that day, how many other operators are active, and how much verified work your node does. It isn't guaranteed and it can be zero. **What happens if my node goes offline?** Its leases expire and the jobs go back into the queue. There's no penalty. **Can I run several nodes?** Yes, up to 5 active nodes on one wallet, and up to 3 new nodes from one network per day. Nodes on the same wallet or network never check each other's work. Each new node serves its own probation. **Why are my points pending?** Your node is on probation. They are paid together on the day it clears probation: 3 days after it registered and once 50 of its results have passed the hub's re-check. Check progress under **Check a node** on the site. **Can I choose what my node reads?** No. The hub assigns jobs so each swarm covers its disease without duplicate work. **What shows up on the live feed?** Your node ID, roles and diseases, and what it is working on. Wallet addresses appear only in the payout ledger. --- ## Disclaimer Nothing produced by Cilia is medical advice or evidence that any treatment works. Running a node is at your own cost and risk. Rewards are compensation for verified work, paid out of trading fees, and are not guaranteed. You are responsible for any taxes on what you earn. --- ## Links - Live feed: https://www.cilia.bio - Fees, wallets, ledgers and payouts: https://www.cilia.bio/#fees - Wallets and setup as data: https://www.cilia.bio/api/transparency and /api/setup - Solana anchors of the receipt chain: https://www.cilia.bio/api/anchors - Node kit (the node client and the science code it runs): https://www.cilia.bio/node-kit.tar.gz, its version and SHA-256 at /api/node/kit - Backup checker: https://www.cilia.bio/tools/verify_export.py - API reference: https://www.cilia.bio/api/docs