Learn · AI methods
Every research-AI tool is built from a short stack of ideas. Each idea does one job well and leaves a specific gap. This is one page for the whole stack: what each is for, and what each does not establish.
After this guide you will be able to:
The ideas build on one another in roughly this order. You can read straight through, or jump to the concept you came for.
The sequence
Read the last column first. The middle columns tell you what a technique is for; the last column tells you the mistake to avoid making with it.
| Term | Main purpose | Research example | What it does not guarantee |
|---|---|---|---|
| ML | Learn patterns from data | Predict an outcome from features | Causal or scientific validity |
| LLM | Predict and generate language | Summarize a paper | Factual support for what it wrote |
| RAG | Retrieve text before answering | Search a local vault, then answer | Correct retrieval or interpretation |
| Knowledge graph | Represent entities and relations | Link claims, sources, and analyses | That the relations are true |
| GraphRAG | Retrieve through graph structure | Find connected evidence objects | That the evidence supports the conclusion |
| DAG | Control dependencies and order | Run analyses before generating tables | That the workflow is scientifically appropriate |
| Agent | Select and execute actions | Retrieve, analyse, and export | Appropriate authority or judgment |
Older software followed rules a person wrote by hand: if this, then that. Machine learning (ML) fits patterns or decision rules from data rather than requiring every rule to be written by hand. In supervised learning, the data include inputs paired with known outcomes, and the model fits a function that reproduces them and, you hope, generalizes to new inputs. Other forms of machine learning learn structure, representations, or actions without conventional labelled answers: clustering, dimensionality reduction, self-supervised and reinforcement learning. A model predicting readmission from a patient's record is supervised ML: nobody wrote the rule, the model inferred it from past cases.
What it buys you is pattern and structure detection at a scale no rule-writer could match. What it does not buy you is causation. A model can learn that an outcome co-occurs with a feature without that feature causing anything: the textbook case is the model that keys off a scanner's ID because sicker patients happened to use one machine. Prediction alone does not establish explanation or causation, and it does not certify that the pattern is real science rather than an artefact of how the data were collected.
A large language model (LLM) is a kind of ML model trained on text. Most current generative LLMs are trained initially to predict the next token from the preceding context. Post-training then shapes how they follow instructions, use tools, and respond to people, and modern systems add retrieval, multimodal encoders, and external control logic on top. Their fluent output still does not provide evidence that a generated claim is correct.
This is why fluency and accuracy come apart. An LLM will write a confident, well-formed sentence whether or not the claim in it is supported. Its training rewards successful prediction and response behaviour; it does not give the model a dependable internal test of whether each generated claim is supported. A summary of a paper can read perfectly and still misstate the finding. The gap the LLM leaves is factual support: it generates language, not verified claims.
Retrieval-augmented generation (RAG) tries to close part of that gap. Before the model answers, the system retrieves relevant text (from a document vault, a paper set, a database, or the web) and puts it in front of the model to work from. Instead of answering from memory alone, the model answers from retrieved passages, and may cite or quote them.
This genuinely helps: it can ground an answer in retrieved sources that the system may expose for inspection, and it keeps the model current with material it was never trained on. In a local or well-designed research system, those sources can be controlled and versioned. But RAG adds two new places to go wrong. Retrieval can surface the wrong passage, and the model can still misread the right one, and a RAG system does not inherently produce faithful quotations. RAG does not guarantee correct retrieval or correct interpretation; at best it makes both visible enough to check.
A basic vector RAG system divides a corpus into text chunks and retrieves chunks that appear semantically similar to a query. That works for "what does this passage say" and struggles with "how do these things connect". The structure that matters in research (this claim cites that source, this result comes from that dataset, this conclusion depends on that assumption) lives between chunks, and chunk-similarity retrieval will not reliably preserve it unless those relationships are represented in metadata, retrieval logic, or another structured layer.
So a question like "which conclusions rest on the study that was just retracted" is exactly the kind a bare chunk index handles badly: the answer is a chain of relationships, not a similar-looking paragraph. Unless the relationships were represented somewhere, there is nothing structured to retrieve.
A knowledge graph makes the relationships first-class. Instead of loose text, you have nodes (a claim, a source, a variable, an analysis) joined by typed edges (cites, derived-from, supports, contradicts). Now "what depends on this source" is a graph you can traverse, not a search you hope works.
The catch is that a graph represents relationships; it does not adjudicate them. An edge labelled supports asserts a relationship; it does not make the support real. A knowledge graph does not guarantee that its relations are true; it guarantees only that they are written down explicitly enough to be checked and argued with.
GraphRAG is a family of methods that use graph structure during indexing, retrieval, or answer generation. Some systems traverse explicit relations (pull this claim, then the sources it cites, then the analyses those sources rest on). Others, like Microsoft's GraphRAG, build entity communities and retrieve graph-derived summaries for corpus-wide synthesis. It is useful when the answer depends on relationships or corpus-wide structure rather than on isolated similar passages.
Match the method to the question. For an exact query such as "what is downstream of this source?", direct graph traversal in a graph database may be preferable and more reliable, and may need no language model at all. GraphRAG earns its place when those connected objects must also be retrieved, summarized, and explained in language. Either way, retrieving a connected subgraph is not the same as judging it: GraphRAG can hand you the claim, its citation, and the cited passage side by side, and it still does not establish that the evidence supports the conclusion. It assembles the material for that judgment; the judgment is a separate act.
A directed acyclic graph (DAG) is a graph with direction and no cycles: work flows one way and never loops back on itself. Used as a workflow, it encodes dependencies (build the analysis dataset before the model, run the model before the table) so an execution system can schedule steps in an order consistent with the recorded dependencies, and independent branches can run in parallel.
A correctly specified DAG makes dependencies explicit and permits a topological execution order. The absence of cycles does not prove that the dependencies are complete, correctly directed, or scientifically appropriate. You can build a perfectly valid DAG around the wrong estimand, an inappropriate comparator, or a model that should never have been fit. The DAG does not guarantee that the workflow is scientifically appropriate; only that, as recorded, it has no cycles and can be scheduled.
An agent is an LLM given tools and a loop: it decides which action to take, takes it, observes the result, and decides again. With the right tools it can retrieve a source, run an analysis, and export a table, chaining steps toward a goal instead of answering a single prompt.
Capability is not authority. An agent can execute a consequential step (accept an inclusion decision, finalize a risk-of-bias rating, sign off on an interpretation) without being the right actor to make that call. The gap an agent leaves is appropriate authority and judgment: doing the action and being entitled to decide it are different things, and only the second protects a research record.
Notice the pattern. Every technique above leaves a gap that must be addressed explicitly. Some gaps can be narrowed by deterministic checks, validation data, provenance, replication, or statistical diagnostics; consequential scientific judgments still require accountable human review. A person is not a universal repair mechanism, but they remain responsible for the calls that decide what a study claims. Provenance is the answer to "where did this come from"; an audit trail is the answer to "who decided what, on what evidence, and when".
This is the layer that makes the rest traceable, and therefore open to review. A retrieved passage is only as good as the record of which source it came from. A supports edge is only trustworthy if you can see who assessed it and why. An agent's consequential judgment is acceptable only when its authority, review requirements, and human responsibility were defined in advance: routine deterministic operations may be automated, but scientific decisions require an accountable human gate. None of the earlier techniques record this by default; it has to be designed in. Traceability is necessary for defensibility, but it does not create defensibility by itself.
Stack the whole thing (ML under an LLM, grounded by GraphRAG over a knowledge graph, orchestrated by a DAG, driven by an agent, all of it logged with provenance) and you have a powerful research system. You still do not have a truth machine.
Each layer establishes something narrower than it looks: ML finds patterns, not causes; an LLM produces fluent text, not supported claims; RAG grounds an answer without guaranteeing the grounding is right; a knowledge graph states relations without making them true; GraphRAG gathers connected evidence without judging it; a DAG orders work without knowing if the work is sound; an agent acts without holding the authority to decide. Provenance records all of it faithfully, and a faithful record of a flawed analysis is still a flawed analysis.
Scientific validity is not reducible to one computational test. Parts of a research claim can be checked mechanically: a reported number matches the code output, a confidence interval was computed correctly, a cited paper contains the specified result, a dataset satisfies its schema, an analysis reproduces in the same environment. But deciding whether the claim is warranted (whether the estimand answers the question, whether the assumptions are defensible, whether the evidence supports a causal reading, whether the conclusion generalizes) requires evidence, assumptions, domain knowledge, and accountable judgment. The most an honest system can do is make that judgment easier and better-documented: run the mechanical checks, put the claim next to its source, show the dependency chain, record who decided, and flag what still needs review. That is the job. Certifying the truth is not.
The one line to keep. These tools decide where to look and what to show you. They do not decide what is true or what is sound. A research tool should state clearly which parts it retrieves, calculates, records, flags, or leaves for human judgment.
See the principle in a working tool.
CiteVahti applies exactly this division of labour to one narrow question: does a cited source support the specific claim that cites it? The tool retrieves and lines up the claim and the source; you make the call; the decision is recorded with its provenance. It checks support and keeps the trail; it does not certify that the claim is true.
See CiteVahtiGo one level deeper on the last few rows in local models, agents and orchestration: what/why/how, and where the human keeps deciding. For a hands-on test of where a laptop model helps and where it fails, see can a local model check your citations? For the human-AI division of labour in practice, see AI qualitative coding, human-reviewed. More guides are on the Learn page.