A doctoral literature review is never finished. New papers land every month, the committee expects the review to reflect them, and the quality bar in my field is specific: journal articles only, from the FT50 list or journals rated A* or A on the ABDC list. No conference papers, no preprints, no working papers, however topical. Keeping three streams of literature current by hand meant a few hours in Scopus every few weeks, most of it clicking.

This is the pipeline that replaced the clicking. An agent runs it, I review the output, and Zotero ends up with the papers, tags, abstracts and notes in place. The research topics themselves are not the subject here. The process is.

The quality filter comes first

Everything downstream depends on one rule written at the top of the skill file the agent reads: keep only journal articles in FT50 journals or ABDC 2022 A* and A journals. Exclude the rest, with no exception for recency or fit. The agent checks every candidate’s venue against the official ABDC spreadsheet, which it downloads from the source rather than trusting a cached copy, because journal titles differ between Scopus and the list. “Human Resource Management (US)” and “Applied Psychology: An International Review” are the kind of mismatch that drops a paper if matched carelessly.

Writing the rule down had a side effect I did not plan. The older bibliographies, built before the rule, contained conference papers and preprints. The agent now flags them on request instead of silently keeping them.

One query per stream

The search runs against the Scopus Search API with a key read from a config file at run time. The agent never prints the key, and the skill says so twice.

Each research stream has a topic query in Scopus syntax over title, abstract and keywords. To that the agent appends the journal whitelist as a long OR of source titles, in chunks of 30, which is the clause length that worked, plus a year floor and a document-type filter for articles and reviews. The part that makes it a refresh rather than a re-search is a load-date filter: only records Scopus added after the previous refresh date. Candidates already triaged and rejected do not come back.

The API key has no entitlement for abstracts or full author names. The agent learned this from a run of 401 errors and wrote the workaround into the skill: abstracts come from OpenAlex, fifty DOIs per call, and full author names, volume, issue and pages come from Crossref. Scopus is used for what it is good at, the search and the venue, and nothing else.

Dedupe against the database, not the list

Before anything is shown to me, the agent removes every candidate whose DOI or title already exists anywhere in the Zotero library. It does this with a read-only query on the SQLite file, which works whether or not the app is open. Dedupe against the whole library, not the stream’s collection, because a paper read for one stream is often relevant to another, and the right answer then is to cross-file the existing record, not to create a second one.

The last refresh added 61 papers across the three streams. The agent triaged the candidates with a one-line reason per paper, kept or dropped, and I read the list rather than the papers. A triage I disagree with takes a minute to reverse. A triage I never saw takes a committee meeting.

Import, then enrich

Creating items in Zotero is fastest through the app’s own importer, so the agent writes an RIS file and I import it. Everything after that the agent does directly in the database: stream tags, a refresh tag with the date, abstracts where the import lacked them, and a child note with a summary for each paper.

Direct writes come with a ritual, all of it in the skill:

  1. I quit Zotero. The agent waits until it is closed.
  2. The agent backs up the database file with a timestamp.
  3. It maps item keys to internal IDs, then writes everything in one transaction.
  4. It marks each changed item as unsynced and updates its modification dates, so the app uploads it on the next sync.
  5. It verifies with a read query and tells me to reopen the app and click sync.

Sync cannot be triggered from outside the app, so the last step stays manual. The agent asks; I click.

The silent failure

The ritual exists because of what happened without it. Item keys in Zotero are eight characters drawn from a specific alphabet that excludes zero, one and the letter O. Items the agent had created directly in the database over several months used keys with those characters. The app accepted them locally and the sync server rejected them, with an error I never saw because sync fails quietly when it fails on an item. For nine months nothing I added through the agent reached the cloud.

The discovery came from an unrelated sync error that named a key. The agent diagnosed the character problem, wrote the query that finds every bad key, rekeyed 75 items with the app closed, with the attachment folders that carry the key renamed to match, marked everything unsynced, and the next sync went through. Then it wrote the whole episode into the skill with the date, the query, and the alphabet.

I include this because it is the honest shape of agent work. The agent caused the problem, by doing something plausible that the documentation did not forbid. The agent also found it, fixed it, and made it impossible to repeat. The net is positive only because the last step happened.

One record, one note

A paper that matters to two streams is the common case, and the obvious failure is two Zotero records and two vault notes that drift apart. The rule is one record in Zotero, added to each stream’s collection with each stream’s tag, and one literature note in the vault, kept in the stream that reads the paper most deeply. The note opens with a small table listing every stream that uses the paper and the angle each one takes. The other streams keep a one-paragraph annotation in their bibliography and a pointer to the shared note.

The agent enforces this by searching before it writes. Searching the vault before writing a new note is a two-second step for an agent and a step I used to skip.

Where the agent reads from

The agent has three ways to read the library, used in order. First, the Zotero MCP tools, which give search by text and by tag, collection listings, item metadata, full text and annotations, and a semantic search over the whole library. Second, the local read-only HTTP API the app exposes while running. Third, the SQLite file, read-only, when the app is closed. The skill lists them in that order with the exact calls, and it states which writes the MCP tools can do, so the agent uses those for notes and tags before falling back to SQL.

What I would tell someone starting this