Recent progress in the development of language models has been defined by scale, with each generation absorbing more of the world's knowledge into its weights. However, many practical applications benefit more from robust reasoning than from extensive parametric knowledge. In this setting, task-specialized small language models (SLMs) offer a principled design choice. We introduce Optimal Cognitive Core (OCC), a family of SLMs built around this premise. As a variant of OCC, we present OCC-RAG, optimized for faithful question answering (QA) grounded in the provided context. This task directly aligns with the OCC design approach, requiring multi-hop reasoning over supplied passages while ignoring memorized knowledge. To train OCC-RAG, we implement a novel pipeline for synthesizing multi-context, multi-hop QA data at scale, producing a corpus of over three million examples targeting multi-hop reasoning, strict context faithfulness, and calibrated abstention. We release OCC-RAG-0.6B and OCC-RAG-1.7B, both mid-trained on this corpus. The models produce structured reasoning traces with source citations grounded in literal quotes from the context. Through OCC-RAG, we demonstrate that compact, task-specialized SLMs can match or exceed general-purpose models 2 -- 6x their size across multi-hop reasoning (HotpotQA, MuSiQue, TAT-QA), faithfulness (ConFiQA), and refusal (MuSiQue-Un) benchmarks.
Alex: Welcome to another episode of ResearchPod. Today, we're looking at a new study about how we train language models to be more reliable.
Sam: We're discussing research called the "Optimal Cognitive Core," or OCC. The central puzzle is something that frustrates a lot of people who use AI tools: why do even very large, powerful language models sometimes make things up, even when you've handed them the exact document they should be reading from?
Alex: So this paper is arguing the problem isn't how big the model is, but how it's been taught to behave?
Sam: Exactly. The researchers suggest that instead of just building bigger models, we should focus on training them to be disciplined. They've built a system that forces the model to ignore its own memorized knowledge and rely only on the documents you actually give it.
Alex: What does that look like in practice?
Sam: Think of a legal assistant whose job is to answer questions based only on one specific contract. If that contract doesn't contain the answer, the assistant shouldn't reach into their general knowledge and guess. They need to say, "I don't know—it's not in here." Researchers call this quality "faithfulness"—the ability to stay strictly true to the text you've been given, and nothing more.
Alex: So the model has to be smart enough to reason through complex questions, but disciplined enough to admit when the text simply doesn't have the answer.
Sam: Precisely. The authors built a family of models called OCC-RAG. These are what researchers call "Small Language Models"—compact, task-focused versions of larger AI systems. They're not trying to know everything about the world. They're specialists. Their one job is to carefully process whatever specific information you hand them.
Alex: And how do you actually teach a model to be that disciplined?
Sam: They use a process called "mid-training." Think of it like this: a student finishes their general education, and then gets enrolled in a very demanding specialist course that has one rule—you must always show your work. The researchers feed the model three million carefully constructed examples, and in every single one, the model must follow what they call a "reasoning trace."
Alex: A reasoning trace—that really does sound like showing your work on a math test.
Sam: That's the right way to think about it. The model can't just jump to an answer. It has to write out its steps: what is the question asking, what does the source text actually say, what can I logically conclude from that? And crucially, if the answer isn't in the text, it's trained to explicitly label the situation as "unanswerable" rather than filling the gap with a guess.
Alex: So the goal isn't just a correct answer—it's a transparent, traceable path to that answer.
Sam: Exactly. And that structure is what prevents hallucination—which is the term researchers use when a model generates information that sounds plausible but isn't actually supported by the evidence. By requiring the model to quote directly from the source text at each step, it becomes much harder for it to drift into invention. The paper reports that these smaller, disciplined models can outperform general-purpose models that are up to six times their size.
Alex: That's a meaningful finding. It suggests that for a lot of practical applications, raw size might matter less than the quality of the training process.
Sam: Right. And the quality control on that training data is quite strict. Every reasoning trace the model learns from has to pass several checks—including a separate "judge" model that verifies the answer is actually correct. If a trace is missing steps, or gets the answer wrong, it gets discarded entirely. They also filter out what they call "overthinking"—where the model produces long, rambling reasoning that isn't actually grounded in the text. The goal is logic that is direct and evidence-based.
Alex: How do they make sure the training questions are actually hard enough to build real reasoning skills?
Sam: They construct what's called a "knowledge graph"—think of it as a map of the facts inside a document, where each fact is a location and the connections between facts are the roads. To build a good training question, they trace a path across that map that requires the model to connect multiple facts together. These are called "multi-hop" questions—you can't answer them by finding one sentence. You have to bridge information from different parts of the document.
Alex: And the "unanswerable" cases?
Sam: They deliberately build in examples where the bridge is missing—where the map has a gap. The model has to recognize it doesn't have enough information to complete the journey. By including a lot of these cases in training, the researchers make sure the model genuinely learns to distinguish "I can reason to an answer" from "the answer isn't here." It turns uncertainty from a failure mode into a reliable, logical output.
Alex: There's something almost counterintuitive about that. We tend to think of a model saying "I don't know" as a weakness. But here, it's actually a sign the system is working correctly.
Sam: That's a good way to put it. The whole philosophy of this research is that trustworthiness comes from process, not just from scale. A smaller model that shows its reasoning, cites its sources, and knows the limits of what it's been given can be more useful in a real-world setting than a much larger model that confidently generates an answer you can't verify.
Alex: It's a useful reminder that in AI development, as in a lot of fields, bigger isn't always better—sometimes more careful is better. Thanks for listening to ResearchPod.