Research agents with evolving knowledge

Research is never finished. A paper gets superseded by a better one, a finding gets contradicted by new data, a figure everyone relied on turns out to be wrong. A research agent that treats knowledge as fixed, ingested once and never revisited, is out of date the moment the field moves, which in an active area is more or less immediately.

The model can read and synthesise research well. The harder problem is keeping what it knows current as the underlying knowledge shifts: resolving contradictions when new findings overturn old ones, re-processing sources that have been updated, and searching across the whole accumulated body of what the agent has read. This page is about the infrastructure that lets a research agent's knowledge evolve rather than ossify.

The problem

The naive version of a research agent reads a set of sources once, builds an index, and answers from it forever. That works until the field changes, which is to say it doesn't really work, because the entire character of research is that it changes. A finding from a 2023 paper that's been overturned by a 2025 one should not carry equal weight, but an index that treats both as static text has no way to know one superseded the other.

Holding everything in the prompt has the familiar ceiling: a serious literature is far larger than any context window, so the agent has to retrieve rather than remember everything at once. But retrieval over a static store doesn't address the deeper issue, which is contradiction. When two sources disagree, or a newer source overturns an older one, the agent needs a model of knowledge that resolves the conflict rather than returning both chunks and leaving the model to guess. That is the entity resolution problem applied to findings, and getting it wrong produces an agent that confidently cites superseded work, a particularly damaging form of memory drift in a research setting.

There's also the matter of keeping up without a human in the loop. Sources get revised, new papers appear, datasets get updated. An agent whose knowledge only changes when someone manually re-runs ingestion is always lagging behind the actual state of the field.

What Exabase unlocks

With memory that resolves contradictions, autonomous re-processing, and search across everything read, the agent's knowledge becomes a living thing rather than a snapshot.

When a new finding arrives that overturns an earlier one, the agent updates its picture rather than holding both as equally true. Ask it the current state of a question and it answers from the resolved, up-to-date view, flagging the supersession rather than averaging contradictory claims. The agent that knows the 2023 result was overturned in 2025 is the one whose synthesis can be trusted.

Sources keep themselves current without anyone tending them. When a tracked source is updated, a Worker re-processes it on a schedule, so the agent's knowledge reflects the latest version rather than whatever was true the day it was first ingested. The maintenance that would otherwise be a standing manual chore happens on its own.

And the agent can draw on the entire body of what it has ever read. Ask a question that spans dozens of papers and it searches across all of them by meaning, assembling an answer from the whole corpus rather than whatever happens to be recent or top of mind.

How it works

Four primitives carry a research agent, and this is one of the cases where Workers genuinely earns its place as a lead rather than a supporting role.

Memory

Exabase Memory holds the agent's evolving model of what's known: findings, conclusions, the state of open questions. The defining behaviour for research is contradiction resolution. When a new source overturns an earlier finding, the new state supersedes the old rather than coexisting with it, so the agent reasons from current knowledge rather than a pile of mutually contradictory claims. This is precisely the capability that separates a memory layer from a static index, and the reason a vector database on its own isn't a memory system: the database stores both claims; the memory layer knows one replaced the other.

Extract

Extract turns sources into clean, structured text through one API: papers, reports, datasets, whether PDF or otherwise. It chunks with page references, so a synthesis can point back to where a claim came from, and it handles the large documents research routinely involves. Nothing can be searched or remembered until it's been read out of the source cleanly, which makes this the first step in the pipeline.

Deep Search

Deep Search is how the agent finds relevant material across everything it has read. It searches at the paragraph level, semantically rather than by keyword, so a query about a concept surfaces the relevant passages regardless of the exact terminology each paper used, which matters in research where the same idea travels under different names. Results return as scored chunks with their source, ready for synthesis.

Workers

Workers are the piece that makes the knowledge evolve on its own. A Worker runs on a schedule and can re-process sources that have changed, pull in new material, and keep the searchable corpus and the memory current without anyone triggering it. This is what turns a one-time ingestion into a standing, self-updating body of knowledge, and it's the same autonomous-maintenance pattern that underpins self-maintaining knowledge bases.

Example architecture

The pipeline has a clear shape.

Scope per research area with a Base if you're keeping distinct projects or domains separate, or use a single workspace if you want the agent to range across everything at once.

On ingestion, run each source through Extract to get clean text, store the results as Resources so they're indexed for search, and send the findings worth tracking to Memory, where contradiction resolution keeps the knowledge coherent as it grows.

On a schedule, a Worker re-processes tracked sources that may have changed and pulls in new ones, updating both the searchable Resources and the memory so the agent's knowledge stays current.

On a query, the agent runs a Deep Search across the corpus and retrieves memory for the resolved state of the relevant questions, then synthesises from both.

Sources flow in through extraction, findings accumulate in contradiction-resolved memory, Workers keep the whole thing current on a schedule, and the agent reads across all of it on every query. The knowledge base maintains and corrects itself rather than freezing at ingestion.

What compounds over time

This is a use case where the value compounds in two directions at once, which makes the argument for infrastructure over a one-off pipeline particularly clear.

The corpus grows: every source the agent reads enlarges what it can search and synthesise across, and because the cost of extracting a source is paid once, the accumulated library becomes an asset the agent draws on indefinitely. At the same time the knowledge stays current rather than decaying, because Workers keep re-processing and the memory keeps resolving contradictions as new findings land. A static research index gets staler every day after you build it; this gets both larger and fresher.

The do-it-yourself alternative inverts the effort curve. A pipeline you build, an index you tune, and a re-ingestion job you babysit all get harder to maintain as the corpus grows, and the contradiction handling, the genuinely hard part, is something you'd be building from scratch. Infrastructure where the memory self-organises and Workers handle the upkeep means the system gets better with use while the work of running it stays flat.

Who's building this

Teams building literature-review agents, market and competitive intelligence tools, scientific research assistants, and any agent whose value depends on staying current with a body of knowledge that keeps changing.

For a concrete starting point, the topic researcher example builds a research agent on Workers end to end, which is the closest match to this pattern. The self-maintaining knowledge bases use case covers the autonomous-upkeep side in more depth.

Get started

Start with the getting started guide, then the topic researcher example for the full Workers-driven build. About Workers and creating Workers cover the scheduling side, and there's a free tier to build against.

FAQs

How does the agent handle a finding that's been overturned?

The new finding supersedes the old one through contradiction resolution. Rather than holding both as equally true, the memory updates to reflect the current state, so the agent synthesises from up-to-date knowledge and can flag that an earlier result was superseded.

What keeps the agent's knowledge current without manual work?

Workers. A Worker runs on a schedule and re-processes tracked sources that have changed, pulls in new material, and updates both the searchable corpus and the memory. The knowledge evolves without anyone triggering a re-ingestion.

Can it search across everything it's read, not just recent sources?

Yes. Everything extracted and stored as Resources is indexed for Deep Search, so a query draws on the whole accumulated corpus rather than only the latest additions.

Does it work with papers as PDFs?

Yes. Extract reads PDFs and other formats, returning clean text chunked with page references so a synthesis can cite where each claim came from.

How is this different from a standard RAG setup over a paper collection?

RAG retrieves chunks from a static collection; it has no notion that one finding overturned another and no mechanism to keep the collection current. This adds contradiction-resolved memory on top of retrieval and Workers to keep sources fresh, so the knowledge evolves rather than freezing at ingestion. The RAG vs agent memory piece covers the distinction.

Will search quality hold as the corpus grows into thousands of sources?

Deep Search is built to hold retrieval quality at scale, which is where naive vector search tends to suffer semantic collapse. The corpus growing makes the agent more capable rather than degrading its search.