Research

MRKL Systems: A Modular, Neuro-Symbolic Architecture That Combines Large Language Models, External Knowledge Sources and Discrete Reasoning

Ehud Karpas12 min readResearch
FOUNDATIONALAI AgentsAdvanced

Key takeaway

Foundational work on llm + external tools/modules.

Updated on Oct 3, 2026

01

Abstract

  • MRKL stands for Modular Reasoning, Knowledge and Language.
  • The architecture combines large language models with external knowledge sources and discrete reasoning modules.
  • A router directs each natural-language input to the expert module best suited to answer it.
  • Experts may be neural models, symbolic programs, calculators, currency converters, databases, or APIs.
  • The paper introduces Jurassic-X, AI21 Labs' implementation of the MRKL approach.

02

Introduction

  • The paper argues that large LMs are powerful general-purpose language interfaces but remain unreliable for several classes of problems.
  • Static pretrained models cannot reliably access constantly changing information such as exchange rates, stock prices, weather, or today's date.
  • They also lack direct access to proprietary information such as company databases or online-game state.
  • Neural LMs can perform some arithmetic but become unreliable as arithmetic complexity increases.
  • Fine-tuning individual models for every task creates a model-explosion problem: specialization improves task performance while reducing versatility.

03

Problem

  • MRKL addresses four limitations: missing current information, missing proprietary information, weak discrete reasoning, and model explosion.
  • The system should retain a general-purpose LM as a safe fallback for inputs that do not match a specialized expert.
  • New capabilities should be addable without retraining the entire language model.
  • Multi-hop requests may require routing different parts of a problem to different experts.
  • The architecture therefore separates language understanding from computations and knowledge access that are better handled by dedicated modules.

04

Methodology

  • Every input is processed by a router that chooses an expert module.
  • The output of an expert can either become the final MRKL response or be routed to another module.
  • Experts can be neural, such as the main LM or smaller specialized LMs, or symbolic, such as calculators and database APIs.
  • Each expert is independently trained, enabling capability additions without changing existing experts.
  • The router is the component that needs retraining when new experts are introduced.
Figure 1

How MRKL combines a language model with specialist tools

Read the diagram from top to bottom. Input text first reaches the language model, labeled J-1. An input adapter connects the interpreted request to specialist modules such as a weather API, currency service, wiki API, calendar, database, or calculator. Different requests need different experts: a calculation can be delegated to a calculator, while a weather question can use an external data service. The expert result then returns to the language-model stage to be expressed as output text. The two language-model boxes show stages in the flow rather than necessarily two distinct models, and the expert grid represents available modules rather than a requirement to call every tool. The modular design combines language understanding with external information and precise operations; its usefulness still depends on choosing the right module, passing valid inputs, and handling the returned result correctly.

Source: user-supplied MRKL systems architecture diagram.

05

Architecture

  • MRKL provides safe fallback because unmatched inputs can go directly to the general-purpose LM.
  • Robust extensibility comes from independently trained experts; adding a capability does not require retraining existing experts.
  • Interpretability can improve because the invoked expert can provide a concrete rationale, such as a calculator result.
  • External APIs provide access to up-to-date information.
  • External databases allow access to proprietary information unavailable to the pretrained LM.
  • Compositionality allows multi-hop requests to be decomposed across different expert modules.

06

Dataset

  • The paper's main empirical test case is extraction of arithmetic arguments from natural language before passing them to a symbolic calculator.
  • The calculator, rather than the LM, performs the actual arithmetic operation.
  • Training examples vary operand representation between digits and number words.
  • Experiments cover operands with 1–9 digits.
  • The arithmetic operation set is addition, subtraction, multiplication, and division.
  • Both one-operation and two-operation expressions are evaluated.
  • Two-operation expressions include different bracket placements, with 29 distinct natural-language combinations.

07

Training

  • Jurassic-X uses the 7B-parameter J1-large model for the arithmetic argument-extraction experiments.
  • The model is adapted using prompt tuning with 10 prompt tokens.
  • The learning rate is 0.3 with linear decay and batch size 32.
  • Experiments 1 and 2 use 3,000 training steps.
  • Later experiments use linear weight decay of 0.001 and select the best checkpoint on validation data.
  • Each experiment is repeated 3–5 times and reports mean ± standard deviation.
  • The train/test split explicitly prevents overlap in the underlying arithmetic expression, even when wording differs.

08

Experiments

  • Experiment 1 trains only on single-digit arithmetic and tests generalization to 1–9 digit operands.
  • Experiment 2 tests transfer between numbers represented as digits and numbers represented as words.
  • Experiment 3 trains on one natural-language question format and evaluates on five formats.
  • Experiment 4 studies transfer between addition, subtraction, multiplication, and division.
  • A separate two-operation experiment partitions 29 possible operation combinations into 14 training and 15 testing combinations.
  • Ten random train/test splits are used for the two-operation setting.

09

Baselines

  • The principal comparison is between the MRKL/Jurassic-X calculator pipeline and language-model-only arithmetic.
  • GPT-3 results are used as a representative comparison for models without an external calculator.
  • In the digit-generalization experiment, GPT-3 is evaluated with few-shot examples matched to the number of digits, while Jurassic-X trains only on one-digit operands.
  • The architecture also tests cross-format and cross-operation generalization rather than evaluating only in-distribution arithmetic.

10

Results

  • With training only on 1-digit operands, Jurassic-X achieved 1.00 accuracy on addition for every tested operand size from 1 through 9 digits.
  • Multiplication accuracy was 1.00 for 1–5, 7, 8 and 9 digits and 0.98 for 6 digits.
  • GPT-3 addition accuracy dropped from 1.00 at 2 digits to 0.804 at 3 digits, 0.255 at 4 digits, and 0.093 at 5 digits.
  • This demonstrates the benefit of delegating arithmetic computation to the symbolic calculator while the LM handles language-to-expression mapping.

11

Conclusion

  • MRKL demonstrates a practical division of labor: neural models interpret language while symbolic modules perform computations for which deterministic procedures are more reliable.
  • The architecture addresses model explosion through modular experts and lightweight router retraining.
  • The arithmetic case study shows that a pretrained LM can be adapted to extract symbolic arguments with near-perfect performance on many tested settings.
  • The paper emphasizes that module selection and reliable argument extraction are central engineering problems in neuro-symbolic systems.
  • Jurassic-X was being piloted with partners and presented as an implementation of the MRKL architecture.

12

References

Primary source: Karpas et al., “MRKL Systems: A modular, neuro-symbolic architecture that combines large language models, external knowledge sources and discrete reasoning,” arXiv:2205.00445.

  • The paper's authors include Ehud Karpas, Omri Abend, Yonatan Belinkov, Barak Lenz, Opher Lieber, Nir Ratner, Yoav Shoham, Hofit Bata, Yoav Levine, Kevin Leyton-Brown, Dor Muhlgay, Noam Rozen, Erez Schwartz, Gal Shachaf, Shai Shalev-Shwartz, Amnon Shashua, and Moshe Tenenholtz.
  • The paper explicitly treats routing and neural-to-symbolic argument extraction as technical challenges.
  • The authors stress that the boundary between neural and symbolic computation should remain flexible rather than prescribing a universal division.

Continue reading

Related research

Browse all research