Skip to main content

Changelog

What changed in each Paperclip release.

0.8.14

Latest
  • `paperclip config` shows the default search sources and, on the next line, the other sources you can search with `-s`.
  • `paperclip search -c` prints only the result count, as its help says, instead of the full result list.

0.8.13

  • At a terminal, `paperclip dataset create` asks right after it shows the columns: Enter approves them and follows the build, `e` edits them in the terminal (`drop KEY`, `add Label: question`, `edit KEY new question`, `rename KEY New label`, `type KEY number`, `editor` for JSON in `$EDITOR`, then `done`), `w` waits for the Datasets page, and `q` or Ctrl-C leaves the dataset in review with the command to approve it later. An approval on the Datasets page while it asks ends the prompt and the build is followed.
  • Agents never wait: in an agent's shell (Claude Code, Cursor, Codex, Gemini CLI, OpenCode and others, or CI), even in a terminal, `paperclip dataset create` prints the columns, the link and the approve command and returns at once (`--json` for JSON). `--no-input` / `PAPERCLIP_NONINTERACTIVE=1` and `--interactive` / `PAPERCLIP_INTERACTIVE=1` decide it yourself. `approve`, `create --auto-approve` and `more-rows` start the build on the server and return unless given `--wait`, and an agent's `--wait` and `watch` stop after 120 seconds (or `--timeout`) with the progress so far. New: `paperclip dataset status ID [--json]`.

0.8.12

  • Approve a dataset's columns from the terminal: `paperclip dataset create QUESTION` prints the proposed columns, the dataset's link and the approve command, then waits while you approve them with `paperclip dataset approve ID` (`--drop KEY`, `--add 'Label: question'`, `--edit KEY='new question'`, `--rename KEY='Label'`) or on the Datasets page, which shows the build either way. `paperclip dataset columns ID` shows the columns and `paperclip dataset watch ID` follows a build until it is done.
  • Auto-approve: `paperclip dataset create --auto-approve` (or `PAPERCLIP_DATASET_AUTO_APPROVE=1`) and the Auto-approve columns checkbox on the Datasets page build with the proposed columns at once, without a review step. The dataset is marked auto-approved.
  • `paperclip dataset open`, `share` and `export` (CSV, or a ZIP with the figures), and `more-rows --wait`. `--max-rows` goes up to 1000 for GXL accounts; other accounts stay at 200, and the server says so.
  • For accounts with the new Datasets, `paperclip routines` and `paperclip skill` lead agents to the new `paperclip-datasets` routine, which drives `paperclip dataset`, instead of the old data-extraction routine.

0.8.11

  • Fast datasets are now just Datasets: the Datasets page builds them, and `paperclip dataset` (or `paperclip datasets`) is the command for them. `paperclip fast-dataset` still works.
  • The old Datasets are deprecated. Your existing old datasets stay viewable, read-only, under Old datasets on the Datasets page. `paperclip extraction` and `paperclip curation` say they are deprecated and point to `paperclip dataset`.

0.8.10

  • The data-extraction skill asks agents to describe the one figure they want in `paperclip search --figures`, the way its caption would: the kind of figure, its subject and what it shows, with one search per figure. Broad requests stay broad.

0.8.9

  • Datasets follow your plan: Free shows 50 rows of each dataset and builds 5 datasets in all, Pro shows 200 rows and builds 20 a month, and Enterprise (learn@gxl.ai) has no limits. Every row found is kept, so an upgrade shows the rest at once. `paperclip fast-dataset read`, `show` and `list` say when the plan shows only some rows, and `create` says when the plan has no datasets left, with where to upgrade.

0.8.8

  • `paperclip fast-dataset create QUESTION` builds a dataset from the terminal: it prints the link and the columns, then streams progress until the rows are in. `--plan-only` stops after the columns, `--no-wait` returns once the build starts, and `--max-rows` sets the size.

0.8.7

  • `paperclip fast-dataset show` gives each column's fill count and, for category and yes/no columns, how many rows have each value. `read --out FILE` saves the rows to a file, and the CSV has one line per row.

0.8.6

  • `paperclip fast-dataset` covers every edit to a Datasets-page table: `cell` shows one value's evidence, `set-cell` sets a value tied to a quote from its paper, `restore-rows` brings back rows the checks hid, `normalize-column` groups a column's values under a few labels, and `refresh` adds papers published since the build. `show` lists column types and options, and `read --hidden` now includes the hidden rows.

0.8.5

  • `paperclip fast-dataset list` lists your datasets from the Datasets page, and `paperclip fast-dataset read ID` prints one as CSV, or with `--format json` each value's quote and source paper.

0.8.4

  • `paperclip grep --source abstracts PATTERN /papers/` greps the abstract-only papers, which a plain `/papers/` grep skips. `--source` also takes `biorxiv`, `medrxiv`, `arxiv`, and `pmc`.

0.8.3

  • `paperclip search` requires a source. Pass `-s`, for example `-s pmc`, or a path such as `/fda/us`. A search without one lists the sources and stops.

0.8.2

  • `paperclip evidence` shows the figure behind a passage when the passage is a figure caption or cites one: its label, caption, `paperclip cat` path and image link, with the image drawn inline in iTerm2 and WezTerm.

0.8.1

  • A failed sign-in refresh that is not a definite rejection (for example a network error) no longer deletes your saved login.

0.8.0

  • `paperclip evidence "CLAIM"` finds published evidence for and against a claim: each passage is marked ▲ SUPPORTS or ▼ REFUTES with the model's confidence, study design and citations, and the exact quote is highlighted. `-n` sets items per side, `--deep` judges a wider pool, `--json` returns the highlight offsets and paper records.
  • Search always fuses keyword and vector retrieval and no longer reranks, so results come back faster. `--ranking`, `-m`, `--min-embedding-similarity`, `--min-bm25-score`, `--rerank-query` and `--full-text` are accepted but ignored, with a warning.

0.7.134

  • The Datasets chat looks in Paperclip before the web: EMA and PMDA documents for EU and Japan approvals, proteins for UniProt IDs, patents for patent numbers and dates, and a paper search by NCT ID for the results paper of a trial.
  • `paperclip search -s pmda`, `-s ema`, and `-s epar` search the PMDA and EMA documents, as `-s fda/jp` and `-s fda/eu` do. Before, they searched papers.
  • The Status filter of a dataset grid offers All statuses, Explained, Rejected, and Pending. The line "Completed checkpoint saved" above the grid is gone, and the directions for selecting cells moved into the Legend.
  • The Datasets page is faster. Images in the grid load before you scroll to them, the Status and column filters apply at once, a dataset starts to load when you point at it in the sidebar, and the bar for selected cells shows at once, on its own line under the filters. A double-click opens what its first click selected, even when the bar moves the grid down. The buttons are named Save, Monitor, and Expand.
  • Details is the one name for the evidence of a cell, the sources of a row, and the completeness of a column, in the bar for selected cells and in the right-click menu. A click anywhere in a cell selects it, not only a click on its text.
  • The Details of a column show how many of its fields are populated. The dataset modes are Fast, Balanced, and Comprehensive, which was called Accuracy; the mode for GXL accounts that reads every paper of a cohort is now called Full read.

0.7.133

  • The agent of the Datasets chat can start gap fillers: helpers that fill the empty cells of a few rows at the same time, after each wave of rows. A gap filler looks in the text of Paperclip documents first, then in Paperclip records and SQL, then on the web.
  • When a write adds rows while more than half of the cells are not searched yet, it warns the agent to fill the rows that it has first. The write still adds the rows.
  • When SQL selects the trials of a dataset, the agent maps them by their registry IDs, so their fields are checked against the record.

0.7.132

  • When the rows of a dataset are drugs or products, the agent maps their trial records and FDA labels in its first pass, with the papers. Trial IDs, phases, sponsors, approved indications, and mechanisms then come from the record or the label, where they can be checked, instead of from reviews or web pages.
  • The checker reads trial and FDA documents in its fast pass, and a value of 8 or more characters that appears word for word in the lines it cites passes without a model.
  • A dataset map of document IDs reads ClinicalTrials.gov records.
  • Only explained cells (a blue mark) and rejected cells (a red mark) have a corner mark. The legend lists only these and the color of the row status.
  • The buttons above a dataset show only their icons, one at a time from the right, as the window narrows, instead of wrapping to a second line. Legend and Expand all do the same.
  • A row name longer than 40 characters ends in "…" until the row names are expanded.
  • The mode picker of the Datasets chat lists Fast, Balanced, and Accuracy, each with how long it takes.

0.7.131

  • The source wording of a cell shows every line of the block that it cites, such as all the eligibility criteria of a trial or the whole row of a table, not only the first line.
  • A cell is checked against the lines that it cites. The lines around them only help to read them, so a cell that cites the wrong line is rejected.
  • A checkpoint is saved even when the check of a value does not finish, for example a very long value. Those cells stay pending, and the next checkpoint checks them again.
  • Patent search lists patents with readable text first. A dataset map can still fill a patent without text from its record: its number, assignees, and dates.
  • paperclip search lists patents among its sources.
  • The reader of a dataset map gets the record of each document with its text: for a trial, its ClinicalTrials.gov fields, such as phase, dates, enrollment, sponsors, conditions, and interventions; for a patent or a paper, its bibliographic fields. A value copied from the record shows as Matched the record. The meta.json of a ClinicalTrials.gov trial has the same fields.
  • The status of each cell shows as a small triangle in its top-left corner. Save checkpoint is a button at the top of a dataset, and the top buttons show only their icons, with a tooltip, when the page is narrow. The Try examples on the Datasets page are larger.

0.7.130

  • A collection in the Datasets chat continues by itself when a turn ends with work left. One turn stops after about 200 steps or 55 minutes; the agent then asks for the next turn with paperclip extraction continue, and Paperclip starts it in the chat, up to 5 turns after your message, while each turn changes the grid. The chat shows each one as Collection continues, with its turn. Click Stop in the chat header to end the turns. Your own message takes the place of a turn that waits.
  • The grid counts the cells that nobody searched yet: empty cells without a not-found note. The line above the grid and the completeness of each column show the count, and the agent reads it with paperclip extraction read.
  • Fixes that save the agent's steps: a date can be a year or a year and month; trial phase and completion dates come from the trials table when a record's text lacks them; cited lines of FDA documents work with the /fda/us/ path; a map copy can name a paper by its ID; and a new row whose key differs from a row's key only in case, spaces, or punctuation goes to that row.
  • The buttons of the Proposed columns card stay inside the card when the chat makes the page narrow.
  • Click a count above the dataset grid, such as 2 rejected or 166 not searched yet, to select those cells. Then use the selection bar: Retry, Chat about cells, Monitor, or Clear. Click the count again to deselect the cells. When the dataset has more than one page of rows, the count selects the cells of the page that you see.
  • Retry takes up to 1,000 cells, so you can ask the agent to fill many empty cells at once. Retry clears the cells that have values first, so at most 100 of them can have values. Chat about cells takes at most 100 cells.
  • Double-click a cell to open its evidence, or the note of a cell that the agent searched without a result. A double-click on a cell or a header now also works when no cell is selected: the selection bar shows a moment later, so it no longer moves the grid between the two clicks. The hint above the grid is shorter.
  • Clear in the selection bar now asks first. A dialog says how many cells lose their values, because only a restore of a saved checkpoint brings them back.
  • When a dataset reaches its row limit, the note first says how many papers the agents read and how many rows they made. Then it says how many papers in the corpus match the search that the agent counted, shown as plain text. The contact for more rows ends the same paragraph.
  • The chat box no longer shows the dataset mode when your account can use only one mode.
  • The source wording of a cell can be up to 4,000 characters, up from 300, so a long passage, such as the eligibility criteria of a trial, shows in full.

0.7.129

  • The Proposed columns card has two buttons. Approve columns only approves the columns and leaves the chat open, so you can keep talking with the agent about the scope of the run. The dataset then shows Not started until you click Start collection. Approve and start collection approves the columns and starts the collection at once. When the chat box has a message that you did not send, starting asks whether to send it with the start.
  • Notes about your changes on the Datasets page show in the chat as a short, faded line on the left, not as a message. Click Show details to see the whole note.
  • The corpus count shows the search and the sources that it counted, and says at least when the count stopped early. It no longer estimates how many rows the papers not read could give.
  • The agent starts its final report with what you asked for and what it delivered, for example: You asked for 50 papers: delivered 65 rows from 51 papers. It ends the report with the rows and the sources of each collection, such as PMC 30, bioRxiv 18. paperclip extraction get shows these totals in source_summary.

0.7.128

  • Dataset monitors keep a dataset up to date: every day, week, or month, the agent adds new rows, updates values, or both. The chat shows each run as a Scheduled run. A checkpoint is saved before each run, so you can undo it. To create a monitor, click New monitor, or select cells, rows, or columns and click Monitor. Then choose what each run does, which values to update, and how often to run; the agent creates the monitor. You can also ask the agent in the chat or in Claude Code: paperclip extraction monitor create <dataset-id>. The Monitors list on the Datasets page shows the next and the last run, and lets you run, pause, or delete a monitor.
  • Click a column header or a row number to select the whole column or row, and # to select all cells. Then click Open completeness or Open sources in the selection bar, or double-click or right-click the header, to see the completeness of the column or the sources of the row.
  • The Status and Column filters of the dataset grid are now on the line of the Legend, so the grid starts higher on the page.
  • When you change a dataset on the Datasets page, its chat gets a note, so the agent knows on its next turn: cleared cells and their old values, deleted rows, added, changed, or deleted columns, saved or restored checkpoints, and paused, resumed, or deleted monitors. While the agent works, the note waits until it stops.
  • To change a column after approval, double-click its header and click Edit column. You can change its label, type, definition, and whether it is required. The cells stay, and the note in the chat lists the cells that do not fit the column after the change. The agent can then fix them.
  • A date cell can be YYYY-MM or YYYY when the source gives no day. A new column is optional unless you make it required.
  • The agent can map over FDA documents, trials, and Clipboard documents, and the server copies the cited text from their lines, as it does for papers. A grid write of more than 200 changes tells the agent how many rows to put in each write.

0.7.127

  • Right-click a dataset cell and choose 'Open evidence' to see its evidence.
  • The Methodology section shows the plan first, then What the agent did: one paragraph that tells how the agent went from the corpus to the papers that it read, and why it chose them. The agent saves the paragraph with paperclip extraction plan methodology <dataset-id> --text. Fast mode also writes it.
  • Figures in the dataset grid load faster: the grid asks for small copies, loads the figures on the screen first, and keeps loaded figures when you open the dataset again.
  • A click anywhere outside the dataset grid deselects the cells and closes the selection bar. Esc also deselects them. Shift-click no longer shows a black focus bar in the first selected cell.
  • The Dataset builder is now called Datasets. The agent writes the What the agent did paragraph in plain prose.

0.7.126

  • The agent writes the dataset methodology at the end of collection as one paragraph in simple English: each Paperclip search with its terms and result count, how it chose the top papers, each filter with its numbers, and the other sources that it used. The Dataset builder shows it under Show more.
  • A click outside the cells of the dataset grid deselects them. The Retry message tells the agent how to read the row of each cell.

0.7.125

  • The Dataset builder page shows a Methodology section under Show more: how the agent found the papers and the data, such as the search terms and how many results it kept. The data-extraction skill tells the agent to add these steps to the collection plan before the checkpoint.
  • Row sources link to the source in Paperclip and to the original paper. A bar above the grid shows all the columns again after Show only this column.
  • Select cells in the dataset grid like in a spreadsheet: click a cell, Shift-click or Ctrl-click to add a cell, and drag for a range. Double-click a cell to open its evidence. The bar above the grid acts on the selected cells: Clear empties them at once, Retry empties them and asks the agent to fill them again, and Chat about cells puts them in the chat box for your question.

0.7.124

  • The Comprehensive Dataset Builder starts with a run plan: the stages that the run does. Run only the columns, only the search, the columns and the search without the read, or start from a saved master list or an existing dataset. The page shows the stages that the plan leaves out as Skipped. paperclip extraction progress accepts --status skipped. For a large read, the agent can fill the key columns first and the other columns only for the papers that have rows.
  • Share a dataset from the Dataset builder page. Share copies the rows, the images, and a README to a folder in your clipboard, and opens the clipboard share dialog. Invite people by email and send them the link. They can view the snapshot.
  • The Dataset builder page shows the prompt for your own agent from the start. It saves a checkpoint when a chat turn ends and the dataset has at least two rows that changed. The chat panel shows when the agent works and when it is done.

0.7.123

  • The Comprehensive Dataset Builder stops for you only between its stages: when the columns are locked, when the search config is ready, and before the full read. Schema optimization and config optimization make their own choices and write them down as assumptions. The page shows what the agent tests now, each version of the columns, what changed in each pilot, and a summary of each search config. Approve the columns or the search with a button on the page.
  • The table reader of map --dataset now reads figure captions. It still does not read values from the figure images.
  • The files that the agent writes in a chat stay there for the next turn, also when the next turn runs on a new server.

0.7.122

  • The Comprehensive Dataset Builder shows each stage of its run on the Dataset builder page: the columns and the rates of each pilot, the precision and recall of each search config, the size of the master list, how many papers the maps have read, and the coverage check. The agent records each stage with paperclip extraction progress. Schema optimization already checks the columns in pilots, so the page asks you to approve the full read, not the columns again.

0.7.121

  • The paperclip-meta-analysis routine can use the Dataset builder for its data curation. When your account can load the schema optimization routine, the agent offers this path: schema optimization finds the fields, config optimization finds the papers, and the Balanced or Comprehensive Dataset Builder extracts the values. The agent then copies each verified value to the paper repo, and the checkpoints and gates of the meta-analysis stay the same. Without this path, the routine follows the same steps as before.

0.7.120

  • paperclip extraction coverage DATASET_ID --from RESULT_ID gives each paper of a search result one state from the maps and the grid of the dataset: in the grid, rows not written yet, no rows, screened out, still running, to retry, failed, or not read. The counts add up to the papers of the result. With --split, it saves the papers that still need a read as results of at most 2,000 papers, so that each one fits in one map.

0.7.119

  • When a chat runs the CLI, each command tells the server which chat turn it belongs to, so the cost of a turn includes the maps, checks, and other model calls of its commands. A command that you run yourself counts on its own.

0.7.118

  • You can delete a column of an approved dataset. In the Dataset builder, click the name of the column at the top of the grid and choose Delete column, or ask the agent. The cells of the column and their evidence leave the grid. The other columns, the rows, and their verdicts stay. Saved checkpoints keep the cells, and restoring a checkpoint brings the column back. paperclip extraction delete-column deletes a column from the CLI.
  • The Dataset builder grid has a + button at the right end of its header row to add a column. It stays in view when you scroll the grid to the side.
  • If the data curation feature is on for your account, Repositories has its own item in the left menu. It lists all your repositories, newest first, with links to the datasets that keep their evidence in them.
  • After you stop a run, a step that did not finish shows a grey circle and the word Stopped, not a spinner.

0.7.117

  • You can add a column to an approved dataset. In the Dataset builder, open More actions and choose Add column, or ask the agent. The rows, their cells, and their verdicts stay, and the new column is optional. The page can ask the agent in the chat to fill the new column for the rows that are in the grid. paperclip extraction add-column adds a column from the CLI.
  • paperclip map --dataset takes --column to fill only some columns of the dataset, for example a new column and the column that names each row. The data extraction routine then copies only the new column into each row, so that the other cells keep their verdicts.
  • If the data curation feature is on for your account, the Clipboard sidebar lists your repositories. Each repository links to its page and to the datasets that keep their evidence in it.

0.7.116

  • The data extraction routine says that the agent can use every source in the main Paperclip skill, and that it must load the skill of a source with paperclip skill <name> before its first command on that source. The list of domain references after the main skill gives the skill of each source. In the Dataset builder chat, the agent loads the skill again in each turn that uses the source, because earlier turns keep only the start of each command output.
  • The Dataset builder chat gets the list of domain references that paperclip skill prints, without the skills of sources that you cannot open. paperclip skill fda_database_schema (the FDA SQL tables) is now a domain reference, so every user can load it.
  • The Dataset builder lists patents only where the patents search is set up, and SEC filings only where the SEC server runs.
  • The data extraction routine starts and reports a corpus count of papers only when the rows come from papers. Before the agent writes a blue (explained) cell, it looks for the same value in a document that has text lines, such as a label, a trial record, a paper, or a patent of the same family with full text, so that Paperclip can check it. When a document is too long for the table reader, such as a large FDA approval package, the agent greps it for the lines that the columns need.

0.7.115

  • A Dataset builder cell can be "Not found": the agent searched for its value and found nothing. The cell has a dotted gray bar, and a click on it shows the agent's note and each place that it searched, for example a paper, a trial record, or a web page. When a copied map row has no cell for a column, Paperclip writes the note itself ("The table reader found no value in …"). A cell that no one has searched for says "Empty" instead of "Not reported".
  • The sources window of each row has a search report: for each column, the status of its value, or where a search found nothing, or Empty.
  • The data extraction routine marks each cell that is still empty after the final web pass as not found, with a note of where it searched. paperclip extraction write takes cells with mode not_found, a note, and a list of the places searched.
  • The CSV export of a dataset, and the CSV of each new checkpoint, has a row key and a row status column, a status column next to each data column (verified, explained, pending, rejected, not found, or empty), and a search notes column. A blank that was searched can be told apart from a blank that no one searched.
  • The Incoming list under the Dataset builder grid stays current while a map runs: each paperclip map --wait adds the papers that finished. Before, a map showed up in Incoming only after the agent read it with paperclip extraction read --map, and only as it was at that read.
  • paperclip map --wait gives the number of rows of each new paper of a dataset map, and the total. When 20 papers were read and none gave a row, it warns that the reading note may ask for something that the reader cannot do, such as judge a figure, so the agent can fix the note before the other papers run.
  • paperclip extraction read --rejected also gives the claim ID and claim revision of a rejected cell, so the agent can retry the value with better lines in one step. The error for a retry without them says where to find them.
  • The data extraction routine: the table reader reads text only, so the agent applies the rules of an image column from the figure caption. The agent checks the first papers of each map and fixes the note when papers that should give rows give none. It says early when a rule leaves out most candidates, writes the rows and fixes that it already knows before the checkpoint, and keeps a row when only some of its cells are wrong. The web pass also looks for trial names, registry IDs, sponsors, and approvals.
  • The Dataset builder start page asks you to describe the dataset you need, or what you want to use it for.

0.7.114

  • The Dataset builder searches every Paperclip source that you can open, not only papers. The agent gets a guide to each source (papers, peer reviews, FDA, PMDA, EMA, clinical trials, patents, proteins, GEO, SEC, Open Targets, ClinVar, and your Clipboard) and chooses the sources of each column, for example trial records for arms and enrollment, and FDA labels for doses.
  • paperclip map --dataset reads the documents of every source that has text lines, such as trials, FDA documents, patents, GEO Series, SEC filings, and Clipboard files. Each cell cites the lines of its own document, for example /trials/<id>/content.lines, and Paperclip checks it against that source. Open Targets and ClinVar records are tables, so a map of them tells you to use paperclip sql.
  • paperclip merge, intersect, and subtract keep the source of each document, so one merged result can hold papers and trials, and a merge of two trials results stays a trials result.
  • A cell whose source has no text lines to check, for example a record with only meta.json, is blue (explained) in the grid, and its evidence says "Not checked". Paperclip does not try to verify it.

0.7.113

  • paperclip grep --block-type figure now works inside one paper, for example on /papers/<id>/content.lines, and shows the image path of each matching figure caption. Before, a grep inside one paper ignored --block-type and --section without a word. Where these options cannot work, grep now says so.
  • The Dataset builder fills image columns more reliably. The agents that write rows can find image paths in their own papers, and the main agent passes on the image paths that it found. The main agent also keeps working while a map runs, instead of stopping to ask about a single row.
  • The Dataset builder grid shows the status of each cell as a thin bar along its bottom edge: solid green when the cited text supports the value, solid blue when the value was worked out from the paper (for example, calculated) and so was not checked automatically, dashed amber until it is checked, and red when the cited text does not support the value. Rejected cells are also tinted red. A cell with several values underlines each value in its own color. The left edge of each row name shows the row status: green, with a tint, when all its required cells pass, red when one is rejected, and dashed amber until then. The Status column is gone. A legend explains the bars, and the sources button of each row is gray.
  • The prompt for another agent now looks like a black-and-white terminal in every theme and is called "Agent prompt (CLI)". It takes one line: the arrow button shows the whole prompt, and Copy copies it.
  • The legend of the Dataset builder grid is behind a Legend button next to Expand all, so it no longer takes space above the grid.
  • In the chat, a search of several paper sources says "Searching papers", and a search that also includes other sources, such as trials, says "Searching several sources". Before, the label named only the first source, for example "PubMed Central".
  • Advanced mode can choose the model of the main agent: Claude Haiku 5.5, Sonnet 5, Sonnet 5.5, Opus 5 or Opus 5.5. The map can use the same Claude models and Gemini 3.5 Flash.
  • paperclip grep --block-type figure shows each caption in full, up to 1,000 characters, so captions that differ only at the end, such as two data cut-off dates, can be told apart. Before, it showed 250 characters. A longer caption ends with "…".
  • When the agent starts a corpus count, the reply tells it to read the count before its final report.
  • A corpus count of a broad search, for example of several drug names, no longer fails after 30 seconds with "The corpus count is not available now". It stops at 25 seconds and gives the papers found so far as a lower bound ("At least …").
  • In the chat, the label of a grep shows its search pattern, also for a regex such as "Kaplan-Meier|survival". A figure grep says "Searching figure captions". Before, the label could show a result ID such as s_24c77e04.

0.7.112

  • The Dataset builder now ends every dataset with a web pass, in every mode. Before it saves the checkpoint, the agent searches the web for the cells that are still empty, for example in the FDA label or the PubChem record of a drug. It writes a value only from a page that it opened, and links that page as the source of the cell. Cells that no page fills stay empty. The data-extraction guide tells other agents the same.
  • A chat message that runs for 55 minutes now pauses and tells you to send "continue". The reply and the work so far are saved. Before, the reply stopped at one hour without a message.

0.7.111

  • paperclip extraction checkpoint create has a new --prompt option. It saves a short prompt that you can paste into another agent that has Paperclip, such as Claude Code. The Dataset builder shows the prompt at the top of the dataset, with a Copy button. A completed dataset without a prompt shows a short prompt with its ID.
  • For more rows in a dataset, contact learn@gxl.ai.
  • The Dataset builder now says "dataset" instead of "curation", for example "Start a dataset" and "Datasets" in the sidebar.
  • The Download images button is now next to Download CSV for datasets with image columns. It is no longer in the More actions menu.
  • Accounts with an @gxl.ai email address have no row limit.

0.7.110

  • When a Data Curation is full, the error that a write gets no longer counts rows or asks to delete rows. It tells the agent to finish the rows in the grid: fix the rejected cells, fill the empty ones, and search and map papers for what they need. The data-extraction guide says the same.
  • The Dataset builder no longer asks you to delete a row to add another. The rows past the limit stay hidden under the blur.

0.7.109

  • The write that takes a Data Curation to its row limit keeps all its rows again, also the rows past the limit, which stay hidden under the blur. After that, a write that adds rows fails, and the error says how many rows to delete before a write can add rows again.
  • The data-extraction guide now tells the agent the same, and that each deleted row first lets a hidden row show in the grid.

0.7.108

  • The new rows of a write must now fit in the curation. When they do not, nothing from the write is saved, and the error says how many new rows still fit.
  • paperclip extraction delete-row deletes rows of a Data Curation grid, with their cells and sources. Each deleted row makes room for a new row. In the Dataset builder, each row also has a Delete button.
  • When a curation is full, the data-extraction guide still searches and maps papers, also new papers, to fill or fix the cells of the rows in the grid. It deletes a row only when the row is wrong or a duplicate, or when the user asks.

0.7.107

  • When a curation is full, the data-extraction guide now lets the agent map the papers of the rows in the grid again, to fill or fix their cells. It still does not add rows or search for new papers.
  • The error that a full curation gives now lists the steps to finish the rows in the grid, so an agent with an older guide also gets them.
  • The data-extraction guide and the extraction commands now call the page the Dataset builder.
  • To count the papers for a table, the data-extraction guide now searches for the key terms and one data term, such as IC50. The count is closer to the number of papers that have the data.
  • A map of PMC papers now also reads their supplement files. When the text of a paper is longer than 1,000,000 characters, the map tells you that it read only the start.

0.7.106

  • The paperclip extraction commands no longer show the row limit of a curation. An agent learns about the limit only when a write that adds rows fails, and the data-extraction guide tells it what to do then.
  • Each row of a Data Curation grid now shows its number. The numbers follow the order in which the rows were added, and a row keeps its number on every page and filter. The extraction commands give it as row_number.

0.7.105

  • For more rows in a Data Curation, contact learn@gxl.ai. The curation page and the data-extraction guide give this address.
  • A Data Curation now keeps the write that takes it to its row limit. After that, writes that add rows fail, and writes to the rows in the grid still work.
  • When a curation is full, the data-extraction guide stops the map and does not add rows. It fixes the rejected cells, fills the empty required cells, and saves the checkpoint, which verifies the pending cells.
  • paperclip extraction checkpoint create now saves the verified claims after each batch, and the batches of a large paper run at the same time. When the command stops early, run it again: it continues with the claims that are not verified.
  • In a Data Curation chat, one command can now run for 10 minutes by default and for up to 30 minutes, and one message can run up to 200 steps.

0.7.104

  • In a Data Curation chat, the grid-writer subagents of a wave start at the same time. Each writer reads the rules of the table from the curation, so its brief is short.
  • The data-extraction guide starts the next search and its map before the writers of a wave, so the next papers are ready when the writers finish.
  • A dataset map now knows the image and figure columns of the table. When a row is a figure, the map gives the row from the caption, so a map for a figure table does not come back empty.
  • A categorical column can have a list of options. The map gives one of the options, and the grid accepts only these values. On the curation page, you can edit the options of a proposed column.
  • paperclip extraction checkpoint create now commits the claims, syncs the verdicts, and saves the checkpoint in one command. It reads the grid revision itself.
  • paperclip extraction read --rejected lists only the rejected cells, with the value, the cited lines, the reason of the verifier, and the cell revision.
  • paperclip extraction write --apply <idempotency-key> applies the last test write (--dry-run) with that key, so you do not send the same JSON again.
  • The default row limit of a Data Curation is now 100 rows. For more rows, contact learn@gxl.ai.
  • The first column of the grid is now Row. You can expand long row names, and Expand all also expands them. The Row sources dialog tells what the sources are.

0.7.103

  • You can edit the proposed columns of a Data Curation on its page: the label, type, description, normalization rules, examples, and whether a value is required. You can also add and remove columns.
  • In a Data Curation chat, you can approve the columns on the page. Your saved edits are what is approved, and the agent continues the collection in the chat.
  • The data-extraction guide keeps your edits to the columns, and it continues when you approve the columns on the page.

0.7.102

  • Each Data Curation has a row limit, 1,000 rows by default. When a curation reaches its limit, the curation page shows about how many more rows the other matching papers in the corpus could give. For more rows, contact learn@gxl.ai.
  • New command paperclip extraction estimate. It counts the papers in the full corpus that match the search of a curation, and it runs in the background. Run it again without a search to see the result and the row estimate.
  • The data-extraction guide starts this count after the first search and reports the estimate at the end.

0.7.101

  • The data-extraction guide starts the background map first and then maps the top 3 papers, so the other papers are ready sooner. If the first rows show that the search finds the wrong papers, the guide stops the background map with paperclip map --cancel.
  • In a Data Curation chat, grid-writer subagents write the rows of a wave at the same time. The chat shows the steps of each subagent under it.
  • Data Curation loads grid figures a few at a time, and it tries again when the server is busy.

0.7.100

  • The stable key of a grid row is now row_key. paperclip extraction create takes --row-key-guidance, and extraction writes and reads use row_key. The older names entity_key and --entity-key-guidance still work.

0.7.99

  • paperclip map --dataset gives its answers in table words: rows, row_name, and cells. A row copy points at /rows/0, and a cell copy at /rows/0/cells/<column>. Older map results keep entities, group, and facts, and they still work.
  • paperclip extraction read gives the row names of each Incoming paper in row_names.

0.7.98

  • paperclip extraction write accepts a row copy: one map group goes into one row, for only the columns that you list. Write the other cells of the row by hand in the same write.
  • Data Curation shows the finished papers that have no row yet under the grid as Incoming. paperclip extraction read lists them in incoming.

0.7.97

  • paperclip map --detach runs a map in the background and prints its map ID. paperclip map --wait <map-id> prints the papers that finished since the last wait.
  • paperclip extraction read --map reads a map that is still running and shows its map_status. The data-extraction guide runs one background map for the remaining papers and writes their rows as they finish.

0.7.96

  • paperclip extraction start --plan approves the schema and saves the collection plan in one command.
  • Curation maps can run for up to about 58 minutes, and the data-extraction guide writes the rows of the first 3 papers before it widens the search.

0.7.95

  • paperclip map --dataset reads each paper for the columns of a curation table. The server checks every answer against the table and the cited lines, and copies the cited text into the cell.
  • A direct cell that cites the lines of a paper no longer needs as_reported. The server copies the text of the cited lines.

0.7.94

  • Normalize chemical names against ChEMBL with paperclip normalize chemicals, including CSV batches, match provenance, and available molecular structures and fingerprints.

0.7.93

  • The data-extraction guide now tells agents that other agents may be working on the same curation, so they read its current state before changing it and continue an existing curation instead of creating a duplicate.

0.7.92

  • Filesystem commands again send the flags you type, including head -n, tail -n, lookup -n, and map --output-schema.

0.7.91

  • Oversized JEV workflow inputs now screen the first 2,000 papers inline or 15,000 in the background instead of failing before screening

0.7.91

  • Fixed some regressions introduced in 0.7.90.

0.7.90

  • Search-workflow YAML can use a strict JEV yes/no step to screen up to 2,000 papers inline or 15,000 in the background
  • The Paperclip MCP connector exposes one tool per CLI command, generated from the CLI itself, each with a readable title
  • Connector tool replies are trimmed to the same defaults as CLI output, and connector errors say more clearly what went wrong
  • Over the connector, `import` accepts paper ids only and `cp`/`mv` never read the server's filesystem; attach files with request-upload and complete-upload

0.7.87

  • The data-extraction routine now uses inline JSON payloads in Paperclip Chat instead of denied shell utilities and temporary files
  • Extraction writes accept `--json` as an alternative to `--file`
  • Agents retain the authoritative dataset ID returned by creation and no longer rediscover similarly named datasets after schema approval
  • Paperclip Chat guidance distinguishes browser `/api/sessions/...` links from writable session filesystem paths

0.7.85

  • Paperclip Chat automatically opens a simplified, live preview of the extraction dataset created in the current conversation
  • The chat extraction workspace uses the existing Data Curation ConfigCat flag and links to the full dataset-management page
  • Paperclip Chat hides and blocks the data-extraction routine when Data Curation is disabled for the current user
  • Row-level explanation status now stays inside the fixed Status column, and Data Curation wording is agent-neutral

0.7.84

  • Image is now the canonical Data Curation media column type, while existing figure columns remain compatible
  • Datasets show Collecting only during active work, Editable before their first checkpoint, and Completed after a checkpoint without becoming locked
  • The extraction routine now saves a checkpoint automatically after its planned collection and final gap audit finish
  • PMC caption matching deduplicates alternate GIF/JPEG renditions before linking figure numbers to images

0.7.83

  • Agents can curate source figures into first-class image columns using caption grep results and canonical Paperclip paths
  • Data Curation renders figure thumbnails and full-size previews without creating duplicate image copies
  • Checkpoint CSVs reference deterministic image filenames, with companion ZIP downloads and manifests that map every file back to its row, column, caption, and source
  • The most recently updated dataset opens automatically, and Data Curation now leads with turning research intent into evidence-backed datasets

0.7.82

  • Editable extraction datasets now support rolling, restorable checkpoints; the latest 10 versions are retained
  • Checkpoint CSVs are immutable downloads while the working grid remains editable
  • Data Curation replaces the terminal Finalize action with Save checkpoint, checkpoint history, restore, and versioned CSV controls
  • Top-line progress now reports rows, field coverage, empty fields, and only actionable pending/rejected counts
  • Row headers now lead with the human-readable entity and expose a clickable source list instead of raw IDs and internal slugs

0.7.81

  • Data Curation is now the default extraction destination; Claude no longer asks for CSV/Markdown format or a local path unless explicitly requested
  • After finalization, users download the canonical CSV directly from the Data Curation page

0.7.80

  • Logging out now removes credentials without erasing the configured staging or production server URL
  • The staging install script now downloads and authenticates against staging by default instead of silently installing the production CLI

0.7.79

  • Dataset, spreadsheet, row, and column creation intents now route generically to the data-extraction routine regardless of scientific domain
  • Paperclip refuses to substitute chat-formatted rows when persistent extraction routing fails
  • Bundled extraction routines remain loadable when the routine server is unavailable, and frontend images package every bundled routine
  • Unified deployments explicitly route traffic to the latest revision instead of silently leaving new backends at zero percent

0.7.78

  • Text cells support revision-checked append operations that preserve existing claims and verify each newly appended sentence independently
  • Progressive verification now aggregates claim verdicts correctly when one cell contains supported segments from multiple source documents

0.7.77

  • Populated extraction cells can now be cleared with revision protection, superseding their claims and removing repository annotations
  • Grid values can be expanded or collapsed per column, with global Expand all and Collapse all controls
  • Retired Elasticsearch secrets were removed from unified deployment manifests after the OpenSearch migration
  • Extraction writes now use dry-run selectively for high-risk batches while routine atomic writes recover through indexed errors, revisions, and idempotent retries

0.7.76

  • Empty active grids now show a live collection timer, plan summary, and realistic guidance that large full-text cohorts can take tens of minutes
  • Claude now maps larger cohorts in bounded 5–10 document waves and performs one atomic write per wave so rows appear progressively
  • Extraction guidance runs one Paperclip command per shell invocation to avoid accidental pipeline argument concatenation
  • Repository commit verification now reports unresolved claim totals and incremental processed-claim progress instead of remaining silent during long runs
  • Repository checkout now reports the current uncommitted evidence-document count instead of always displaying zero

0.7.75

  • Explanation provenance can now be replaced without changing the normalized cell value, removing stale placeholder lines instead of appending support

0.7.74

  • Unified grid writes now accept explicit direct/explanation support types from authored and copied map values
  • Rows summarize every populated cell, so optional pending, rejected, or explanation-supported values are no longer hidden by one verified required field
  • Extraction guidance requires authoritative URLs for metadata/SQL explanations and forbids unrelated placeholder line citations

0.7.73

  • Rejected direct claims can be retried without changing their normalized value by supplying the current cell and claim revisions
  • The extraction skill now makes direct versus explanation support a per-fact decision and forbids manufacturing line evidence from SQL or metadata output

0.7.72

  • Direct extraction claims now preserve source-aware evidence paths when verifying FDA and other non-paper documents
  • Public source aliases resolve to the canonical document packet, while genuinely unavailable cited paths remain pending instead of becoming false rejections

0.7.71

  • The data-extraction skill now uses extraction read consistently for resume, post-pass gap checks, and rejected-cell inspection
  • Persisted collection-plan examples no longer instruct Claude to call removed observe or inspect commands

0.7.70

  • Direct claims created by grid writes are queued transactionally for background verification, while final commits reuse cached verdicts
  • Unified writes now support direct/explanation transitions with one revision-checked operation
  • Map attachment rejects running maps and supports explicit immutable refresh snapshots after retries
  • Data Curation now shows canonical grid and verification state without legacy extraction-run or candidate panels

0.7.69

  • Claude now uses ordinary map plus extraction read/write instead of extraction-run candidate orchestration
  • Map results can be attached immutably to a dataset and copied into cells by JSON reference without repeating values or evidence
  • Unified sparse and block writes let Claude freely author, normalize, replace, or copy final grid values with server-side type and revision checks

0.7.68

  • Extraction resume now carries the structured-extraction worker explicitly with dataset/run bindings
  • The backend repairs older resume commands from frozen manifests, and the terminal accepts their frozen output schema

0.7.67

  • Discovery outputs that include an entity key now infer entity row kind when workers omit the optional row_kind field
  • Existing frozen discovery maps can resume persistence without remapping or changing their output schema

0.7.66

  • Extraction-bound maps preserve their generated map ID through the MCP response so runs bind and resume correctly
  • Targeted discovery and enrichment schemas omit empty required/allOf keywords and now validate against JSON Schema Draft 2020-12

0.7.65

  • Data Curation schema drafts are now review-only in the web UI; users approve and continue through their Claude Code conversation
  • The UI approval mutation is removed until a dedicated Paperclip Chat workflow is enabled
  • Dataset selectors are denser and collapse into a compact picker on narrower windows so the selected grid stays in view
  • Dataset headers use compact goal, row, and action rows without a tall finalize-blocker column

0.7.64

  • Removed the legacy extraction ingest, fill-cell, and correct-claim commands and API paths; extraction run and apply are now the only collection/write paths
  • The extraction skill now explains when free-text columns need no normalization and includes a concrete source-by-column collection plan

0.7.63

  • Extraction passes now target explicit column groups and freeze discover/enrich intent, work items, and source guidance for safe resume
  • Discovery maps stage immutable candidate rows for Claude to inspect and place instead of making ambiguous server-side row decisions
  • Boolean grep and saved-result merge, intersect, subtract, refine, and search-workflow commands are available again
  • The legacy extraction verifier is removed; verification uses progressive direct claims plus the final whole-repository commit and sync
  • Repository commits are blocked while a bound extraction map is actively changing its dataset

0.7.62

  • Data Curation now shows a live collection timer and preserves the completed duration for finalized datasets
  • Collection plans, recent activity, and column completeness are compact and collapsible
  • Cell coverage clearly separates verified evidence from explanation-supported values, and clicking a table column title opens its detailed coverage

0.7.61

  • New `paperclip repo delete <name>` permanently removes a repo (papers list, claims, commits, branches) with a confirmation prompt; corpus papers are untouched
  • New `paperclip repo deactivate` stops scoping commands to the active repo and returns to the full corpus (explicit form of `repo checkout -`)

0.7.60

  • Data Curation datasets can now be permanently deleted together with their automatically created evidence repositories
  • Deletion is blocked while extraction work is active, while abandoned pre-start runs no longer prevent cleanup

0.7.59

  • Extraction maps now emit immediate and periodic startup progress instead of leaving agent terminals silent
  • Maps that cannot start within 90 seconds fail with a useful retry message instead of remaining stuck at starting
  • Interrupted extraction streams record a failed run that can be safely resumed, and map errors are no longer hidden behind an empty success summary
  • Claude runs long extraction maps as background tasks so short agent-shell deadlines do not terminate active work

0.7.58

  • Claude can navigate extraction grids with bounded observe and inspect views, then dry-run and atomically apply explicit fill, correction, and support batches
  • Collection plans and grid activity persist across sessions and appear in Data Curation without adding another user approval checkpoint
  • Entity rows can accumulate explicitly linked evidence from multiple papers or external sources while preserving paper-scoped extraction compatibility
  • Extraction cells now distinguish verified direct Paperclip evidence from blue explanation-only support for calculated, inferred, metadata, or external values
  • Explanation-supported required rows can be finalized without being counted as automatically verified, while rejected direct evidence remains blocking
  • Per-paper verification now overlaps structured mapping with a separately bounded queue, so Data Curation cells turn verified or rejected while later papers are still mapping
  • Extraction runs report claim verification, rejection, unresolved, and verifier-failure progress; final commits reuse conclusive saved verdicts and check only unresolved or changed claims
  • `paperclip extraction run` now maps one deduplicated cohort in parallel and progressively adds each completed paper’s rows to Data Curation
  • Repeated extraction waves skip papers already present and distinguish successful papers with no eligible rows from retryable failures
  • Data Curation shows mapped, ingested, row, and failed-paper progress before the first extracted row arrives
  • Staging preview: Data Curation turns line-backed repository claims into a live, reviewable extraction table
  • `paperclip extraction` creates schemas, ingests complete per-paper rows, synchronizes repository verification, finalizes datasets, and exports CSV
  • `paperclip extraction fill-cell` adds evidence-backed values omitted by the original paper ingest while preserving correction and idempotency rules
  • Empty required and optional cells now clearly distinguish missing values from genuinely unreported fields
  • Structured extraction maps now use exact approved field names, enforce required evidence-backed values, and translate labels to stable internal IDs during ingest
  • Large extractions use the existing batched, resumable repository commit verifier instead of one long verification request
  • Different papers can be ingested concurrently, while each paper's rows and claims remain atomic

0.7.49

  • Search retrieves a candidate pool several times deeper than the requested limit and reranks the whole pool, so the reranker orders results without dropping papers
  • `paperclip search --also PHRASING` (repeatable) fuses several phrasings server-side and reranks once; `--rerank-query` sets the question to rerank against
  • The same paper no longer takes two result slots under different identifiers (PMID, DOI, and title dedup)
  • JSON API: `queries` fan out inside the engine, `expand: true` adds LLM-generated phrasings, `num_results` up to 200

0.7.48

  • Boolean corpus grep can run as a durable background job
  • Paper Scorecards link every citation occurrence in a citing paper
  • Scorecards show citing papers that were found but not included in the score

0.7.44

  • Meta-analysis routines validate protocol requirements before Evidence work begins
  • Question and Evidence revisions now provide complete recovery steps without weakening approved-artifact hashes
  • Representative pilots, harmonization decisions, data QA, and report rendering use aligned executable contracts

0.7.42

  • `paperclip skill` now shows separate tables for available routines and loadable domain references
  • Domain guidance such as patents, proteins, and SEC is discoverable and loads with `paperclip skill <name>`

0.7.41

  • Paper Scoreboard verifies citation evidence with a one-pass full-text workflow
  • Scoreboards use a reproducible random sample when more than 100 readable citing papers are available
  • The public scorecard app is available at /scorecard with social share previews
  • Citation classifications show exact source passages and clearer sample-size caveats

0.7.37

  • Playground Search adds a source filter for corpus grep, treats trials as one source with a country filter, and shows a copyable CLI command
  • `grep --from` now saves hits as a result set so you can chain map
  • Grep reports approximate document counts
  • Citation document requests authenticate correctly
  • Default map no longer crashes before reduce, and CLI analysis workflows complete correctly
  • Docs show corpus freshness dates and clearer Clipboard help

0.7.36

  • Admin page with role-based access control for internal users
  • Invite code management UI — create codes, view redemptions, copy redeem URLs
  • User roles column (_text) for RBAC — assign admin role via SQL

0.7.35

  • Billing feature with Stripe Pro plan checkout and subscription management
  • Invite codes for promo access — redeem via /redeem?code=XXXX to grant free unlimited plan
  • PlanCard on settings page gated behind billing feature flag
  • Guided analysis workflows are now managed as Paperclip routines, distinct from the local core agent skill
  • Only standard and scaled meta-analysis routines appear in routine discovery

0.7.34

  • Paperclip starts correctly on supported Python 3.8 and 3.9 installations

0.7.33

  • Guided workflows now load current orchestrators and phases remotely without writing workflow packages into each project
  • Trusted meta-analysis helpers run from checksum-verified temporary bundles that are deleted after use

0.7.32

  • Paper Repo verification now retries malformed and failed responses without treating infrastructure errors as rejected claims
  • Meta-analysis skills keep errored or pending evidence separate from conclusive source-verification failures

0.7.31

  • Meta-analysis skill Phase 7 now requires explicit managed analysis execution with anti-fabrication gates

0.7.30

  • YAML search workflows now stream step names, operations, paper counts, result IDs, and elapsed time while they run

0.7.29

  • YAML search workflows now receive coordinated long-running timeout budgets across the CLI, proxy, backend, and Papers MCP

0.7.28

  • Large YAML search workflows now receive a dedicated backend timeout budget
  • The full PKDB candidate workflow now uses a 5,000-paper discovery limit

0.7.27

  • YAML search workflows now preserve and return their declared final result across backend and direct MCP connections
  • Workflow failures retain their error details when run through direct MCP connections

0.7.26

  • Structured map results can no longer silently lose fields — incomplete or schema-mismatched artifacts now fail closed with the full data preserved
  • Console output, results export, and later `/.gxl` reads retain complete per-paper answers from the durable map manifest

0.7.24

  • Guided meta-analysis projects now pause for review at Question, Evidence, and Results checkpoints
  • Large-paper extraction is resumable, automatically split when needed, and records verification and model provenance

0.7.23

  • New Citation Explorer finds papers cited by a reference paper and ranks them with configurable filters and scorecards
  • Run Citation Explorer from the Paperclip CLI or use the dedicated web app for an interactive workflow

0.7.22

  • Paper fetch is more reliable and can use browser HTML capture when a publisher blocks direct downloads
  • Moving Clipboard files now routes through the server correctly
  • Uploads that reach the added state now complete successfully

0.7.18

  • Clipboard replaces Workspace across the CLI and web app, with uploads, folders, search, previews, exports, sharing, and Google Drive import
  • Analogical and threshold-based search make it easier to find related work and control result quality
  • Map jobs are more durable: interrupted streams recover, long output is preserved, and exhaustive workers can resume safely
  • Paper Repos validate structured claims earlier and provide more reliable collection and verification workflows
  • Meta-analysis reports use a deterministic pipeline and can repair incomplete agent-authored reports

0.6.0

  • New: browse 575K+ UniProt proteins, 256K+ PDB structures, and 2.9M+ ChEMBL compounds in Paperclip
  • Query proteins, structures, and bioactivities together with SQL — joins across UniProt, PDB, and ChEMBL are built in
  • Access everything under `/proteins/` with the same filesystem commands you already use (`cat`, `grep`, `ls`, `sql`)
  • Ask your agent to use UniProt, PDB, or ChEMBL directly with Paperclip

0.5.13

  • Verification no longer confuses timeouts with real failures — infra errors now show as [!] instead of [X]
  • Re-committing a repo skips claims that already passed or failed — no more re-verifying everything from scratch
  • Transient network hiccups won't silently flip your previously-verified [OK] claims to [X]

0.5.7

  • Fixed annotations not saving on bioRxiv, medRxiv, arXiv, FDA, and clinical trial papers
  • Better status indicators and clearer error messages when things go wrong

0.5.6

  • Upload Word docs, PowerPoint slides, HTML files, and EPUBs — not just PDFs
  • See real-time progress when uploading multiple files (e.g. "3 of 19 complete")
  • Check processing status of uploaded documents with `paperclip sync status`
  • Clearer error messages when uploads fail (file too large, network issues, etc.)

0.5.5

  • Upload files to your clipboard with `paperclip cp` (originals stay on your computer)
  • No more getting logged out unexpectedly — sessions refresh automatically
  • See exactly which files failed and why when uploading a batch
  • Paperclip now auto-updates when your version is out of sync

0.5.3

  • Running `paperclip update` now refreshes all skill files across your projects
  • Improved AI tool integration for more reliable responses

0.5.2

  • Type `repos` as a shortcut for the repo command
  • More accurate citation counts powered by OpenAlex (covers 250M+ works)

0.5.1

  • Faster, simpler login — fewer steps and no more copy-pasting codes
  • If you're already signed in on the web, login completes automatically

0.5.0

  • Paper Repos: organize papers into collections you can branch, merge, and synthesize
  • Use `reduce` to generate AI summaries across an entire repo of papers

0.4.3

  • Choose which source to search with the `-s` flag (e.g. `-s pmc`, `-s fda`, `-s trials`)
  • Cleaned up command list — removed retired commands for a simpler experience

0.4.2

  • Search now covers all sources by default — papers, FDA docs, clinical trials, and more
  • No configuration needed; use `-s` to narrow to a specific source when you want

0.4.0

  • New: search 217K+ FDA regulatory documents directly from the CLI
  • New: search 110K+ clinical trials (ClinicalTrials.gov + WHO ICTRP)
  • Access structured trial data and regulatory metadata in search results

0.3.0

  • Interactive shell mode — stay in Paperclip and run commands without re-typing `paperclip`
  • Read complete papers with `cat --full`
  • New: search arXiv preprints and conference abstracts
  • Better error messages when authentication expires

0.2.0

  • Initial release of Paperclip
  • Search 3.4M+ biomedical papers from PubMed Central, bioRxiv, and medRxiv
  • AI-powered semantic search — find papers by meaning, not just keywords
  • Full-text search within papers using grep
  • Cite specific passages with block-level references
  • Secure login with your browser (no API keys needed)
  • Ask questions about individual papers and get AI-powered answers
  • Analyze many papers at once with parallel map/reduce