Model Capability vs. System Capability: 26 Technical Bridges

Abstract

A base model and the complete AI system built around it are not the same technical object.

A language model may lack persistent state, current external knowledge, deterministic calculation, reliable long-horizon planning, direct environmental access, calibrated uncertainty, or the ability to execute an action. A deployed system can add some of these functions through memory stores, retrieval, multimodal components, planners, code runtimes, tools, validators, feedback loops, and model updates.

The resulting system may therefore perform a task that the isolated model cannot perform reliably.

That improvement is real, but it must be attributed to the complete configuration. Retrieval does not turn parametric knowledge into an internally updated world model. A calculator does not make the language model itself arithmetically reliable. A workflow engine does not prove that the model can plan. Persistent storage does not create autobiographical memory. A reward model does not establish motivation.

The companion capability map examines 26 human capabilities and the human-like behaviors GenAI systems can produce. This article uses the same capability targets for a different purpose: to identify the technical mechanisms through which an engineered AI system can bridge a model-level limitation, the behavior that the bridge enables, and the gap that remains.

The analysis follows one repeated sequence:

Target capability → model-level gap → system bridge → implementation mechanism → resulting system behavior → residual gap

The central conclusion is that AI systems often gain capability through composition. They do not need to reproduce the human mechanism behind a capability to provide a useful functional alternative. The alternative, however, remains bounded by the information, tools, representations, objectives, and validation mechanisms supplied by the architecture.

1. From Human Capability Gaps to Engineered Alternatives

A capability can be implemented through more than one mechanism.

Humans remember events through biological memory systems. An AI application can preserve event records in a database and retrieve them during later interactions. These mechanisms are not equivalent, but both can support continuity across time.

Humans perform arithmetic using learned symbolic procedures, working memory, written notation, and external aids. An AI system can route a problem to a calculator or code interpreter. The system may return the correct result even when the model would have produced an arithmetic error without the tool.

The engineering question is therefore not whether the system reproduces a human cognitive process.

It is:

What model-level limitation prevents reliable task performance, what technical component compensates for that limitation, and what remains unsupported after the component is added?

This requires a precise definition of the system boundary.

In this article, the base model is the generative model evaluated in an isolated inference configuration, without application-managed persistent memory, external retrieval, executable tools, independent validators, environmental sensors, or a controller that maintains state across calls.

The AI system is the complete operational configuration that may include:

• one or more foundation models;
• application instructions and context assembly;
• persistent and temporary state;
• retrieval systems and knowledge bases;
• modality-specific encoders or multimodal models;
• planners, task graphs, and workflow engines;
• calculators, code runtimes, solvers, and simulators;
• software tools, APIs, sensors, and robotic controllers;
• critic models, tests, validators, and provenance checks;
• feedback collection, fine-tuning, adapters, or online updates.

The distinction is architectural, not semantic.

If a model generates a function call but the application executes it, the external action belongs to the system. If a retriever supplies a current document, the resulting grounded answer depends on the model, the retriever, the document corpus, the ranking process, and the context assembly step. If a verifier selects one answer from several candidates, the result cannot be attributed to the generator alone.

A different mechanism can provide a valid functional substitute. It does not eliminate the need to state which component produced the capability.

2. The Technical Bridging Framework

The analysis uses six fields.

Target capability

The function the system is expected to provide: continuity across sessions, quantitative calculation, spatial reasoning, planning, uncertainty handling, action, or another measurable capability.

Model-level gap

The specific limitation observed when the model is evaluated without the additional bridge.

This should not be stated as a universal claim about every model. Capability varies by model, task, prompt, modality, context length, post-training, and evaluation method.

System bridge

The component or architectural layer introduced to compensate for the model-level limitation.

A bridge can operate at inference time, such as retrieval or tool execution, or through a model update, such as fine-tuning. These interventions change different parts of the system and should not be treated as interchangeable.

Implementation mechanism

The concrete technical process through which the bridge operates: vector retrieval, structured state, PDDL planning, code execution, scene graphs, semantic-entropy estimation, a critic model, or another defined mechanism.

Resulting system behavior

The capability that can be demonstrated in the complete configuration.

The claim should be limited to the tested behavior. A system that correctly calculates dates has demonstrated date calculation in the evaluated conditions. It has not thereby demonstrated a general temporal model.

Residual gap

The capability boundary that remains after the bridge is introduced.

Residual gaps include incomplete retrieval, incorrect formalization, stale state, tool-selection errors, distribution shift, verifier failure, missing feedback, or a conceptual difference between the engineered function and the broader human capability.

The same technical mechanism can bridge several capability targets. Retrieval can support semantic knowledge, common-sense coverage, source provenance, and current information. The function it provides is different in each case.

Conversely, one capability may require several bridges. Reliable planning can require structured state, a planner, tools, environmental observations, replanning logic, and outcome verification.

The mapping is therefore many-to-many rather than one capability to one component.

3. Bridging the Capability Gaps

Memory, continuity, and learning

1. Episodic memory

Model-level gap: An isolated model call does not independently maintain a durable, ordered record of events across sessions. Conversation context can contain prior events, but context availability is not equivalent to persistent event storage.

System bridge: Application-managed event memory.

Implementation mechanisms: Append-only event stores, conversation records, timestamps, entity identifiers, summaries, vector or hybrid retrieval, recency and relevance scoring, and links back to the original record. Architectures such as MemGPT and Generative Agents demonstrate how external memory tiers or stored experience records can be retrieved to support longer-term behavior. [2][3]

Resulting system behavior: The system can refer to earlier interactions, retain task history, restore previous state, and maintain behavioral continuity across sessions.

Residual gap: Retrieved records can be incomplete, stale, incorrectly summarized, or associated with the wrong entity. Persistent event storage does not establish recollection, personal ownership of an event, or an autobiographical point of view.

2. Semantic memory

Model-level gap: Parametric knowledge can be outdated, incomplete, difficult to attribute, and unavailable for documents or facts introduced after training.

System bridge: Retrieval-augmented knowledge access.

Implementation mechanisms: Search engines, dense or lexical retrieval, reranking, document stores, knowledge graphs, database queries, source metadata, and context assembly. Retrieval-augmented generation combines parametric generation with non-parametric memory and has demonstrated improvements on knowledge-intensive tasks. [1]

Resulting system behavior: The system can answer from current or domain-specific sources and can expose supporting documents that were not encoded in the model parameters.

Residual gap: Retrieval can miss relevant evidence, retrieve misleading passages, omit exceptions, or overload the context. Access to a document does not prove that every relevant part of the document was considered. Retrieved knowledge also does not update the model’s parameters.

3. Procedural skill learning

Model-level gap: A model can describe a procedure without possessing an executable policy for completing it in a particular environment.

System bridge: Executable tools, workflow definitions, learned policies, and reusable action libraries.

Implementation mechanisms: Function schemas, APIs, scripts, state machines, workflow templates, task-specific policies, fine-tuning, reinforcement learning, and robotic skill libraries. Toolformer and ReAct demonstrate model–tool combinations in which the model selects external operations and incorporates their results. [5][6]

Resulting system behavior: The system can translate a request into executable operations, reuse known workflows, and complete tasks that require capabilities outside text generation.

Residual gap: Correctly describing or selecting a procedure does not guarantee correct execution. Tool choice, argument construction, environment state, permissions, and postconditions remain separate failure points. Function-calling evaluations also show that long-horizon and stateful tool use remains harder than isolated single-turn calls. [19]

4. Continual learning

Model-level gap: A deployed model does not normally update its parameters from every interaction. In-context adaptation changes the current inference state but is not persistent parameter learning.

System bridge: External memory updates, scheduled model updates, adapters, fine-tuning, or controlled online learning.

Implementation mechanisms: Feedback databases, corrected examples, retrieval-store writes, parameter-efficient adapters, replay data, fine-tuning pipelines, evaluation gates, and versioned model deployment.

Resulting system behavior: The system can retain corrections, adapt domain behavior, incorporate new data, or deploy a revised model without retraining the complete foundation model.

Residual gap: External memory changes system behavior without changing the model. Parameter updates can introduce regression, drift, or catastrophic forgetting. Research on LLM tuning shows that learning new data can compromise previously acquired behavior and that anti-forgetting methods reduce rather than eliminate the problem. [16]

5. Attention and working memory

Model-level gap: A large context window defines an input capacity. It does not guarantee that the model will select, preserve, or correctly use every relevant item.

System bridge: Explicit working-state and context-management layers.

Implementation mechanisms: Task-state objects, scratchpads, structured intermediate representations, selective retrieval, context compression, hierarchical summaries, recency policies, and controller-managed context assembly.

Resulting system behavior: The system can maintain the active goal, unresolved subproblems, relevant evidence, and intermediate results across several inference steps.

Residual gap: Context selection can remove necessary evidence or retain distracting material. Summaries can erase constraints. Long-context research has shown that performance can depend on where relevant information appears, with degradation when information is located in the middle of long contexts. [4]

Language, perception, and grounding

6. Language

Model-level gap: The central limitation is not absence of linguistic capability. Modern LLMs can produce fluent syntax, translation, explanation, and discourse. The gap is between linguistic fluency and reliable use of domain evidence, terminology, operational state, or non-linguistic information.

System bridge: Domain grounding and language-quality controls.

Implementation mechanisms: Terminology databases, translation memories, retrieval from approved corpora, structured output schemas, grammar and terminology validators, document parsers, and task-specific fine-tuning.

Resulting system behavior: The system can produce language that is more consistent with a domain, document set, required schema, or organizational terminology.

Residual gap: Linguistic correctness does not establish factual correctness, causal validity, source coverage, or understanding of the external situation. A fluent transformation can preserve an unsupported premise.

7. Perception and grounding

Model-level gap: A text-only model has no direct access to visual, auditory, spatial, physical, or continuously sampled environmental state.

System bridge: Multimodal models, modality-specific perception components, and sensor interfaces.

Implementation mechanisms: Vision and audio encoders, OCR, speech recognition, video processing, sensor streams, state estimators, scene graphs, object detectors, and multimodal context fusion. PaLM-E, for example, integrates visual, continuous state, and textual encodings for embodied tasks. [10]

Resulting system behavior: The system can condition its output on images, audio, video, sensor observations, or robotic state rather than on text alone.

Residual gap: Environmental coupling is selective. Sensors have limited coverage and resolution; perception components can misclassify objects; observations can become stale; and a multimodal representation does not guarantee a complete or human-like understanding of the scene.

World models and reasoning

8. Common-sense reasoning

Model-level gap: Model responses can be inconsistent when ordinary background assumptions are underrepresented, culturally variable, implicit, or different from patterns in the training distribution.

System bridge: Retrieved background knowledge, structured domain models, constraints, and environmental checks.

Implementation mechanisms: Knowledge bases, ontologies, rule engines, domain-specific retrieval, simulation, object affordance models, and consistency validators.

Resulting system behavior: The system can resolve some implicit assumptions against explicit knowledge or constraints instead of relying only on the model’s learned associations.

Residual gap: No finite rule set or retrieval corpus contains all context-dependent common sense. The bridge can improve coverage in a defined domain while remaining brittle under unfamiliar situations, cultural differences, or missing environmental information.

9. Causal reasoning

Model-level gap: A plausible causal explanation does not prove that the model has represented interventions, confounders, identification assumptions, or counterfactual structure correctly.

System bridge: Explicit causal models and causal-analysis tools.

Implementation mechanisms: Structural causal models, causal graphs, statistical estimation libraries, intervention operators, counterfactual solvers, simulators, and experimental data. LLM4Causal demonstrates an architecture in which a language model identifies a causal task, invokes an external function, and interprets the numerical result. [12]

Resulting system behavior: The system can route a natural-language question into a defined causal procedure and compute an answer under explicit assumptions.

Residual gap: The result is only as valid as the causal graph, data, identification strategy, and formalization of the question. An external causal tool cannot infer missing assumptions automatically, and the model can still translate the user’s question into the wrong formal task.

10. Formal and quantitative reasoning

Model-level gap: Free-form generation can introduce arithmetic, symbolic, or logical errors even when the problem decomposition is plausible. Controlled perturbations can also cause large performance changes. [18]

System bridge: Deterministic computation and formal reasoning tools.

Implementation mechanisms: Calculators, Python or other code runtimes, computer-algebra systems, SAT or SMT solvers, theorem provers, database engines, and executable tests. Program-Aided Language Models use the model to translate a problem into a program while delegating execution to a Python interpreter. [9]

Resulting system behavior: The system can perform exact arithmetic, execute algorithms, check formal constraints, or verify candidate results within the guarantees provided by the external tool.

Residual gap: The tool can solve the formalized problem while the model formalizes the wrong problem. Unit errors, omitted constraints, invalid assumptions, and incorrect interpretation of the computed result remain system-level failure modes.

11. Spatial reasoning

Model-level gap: Text generation alone does not provide a persistent metric map, object geometry, three-dimensional state, or continuous localization.

System bridge: Structured spatial representations and geometry-aware tools.

Implementation mechanisms: Maps, scene graphs, coordinate systems, geometry libraries, spatial databases, object tracking, simultaneous localization and mapping, robotic sensors, and visual state estimation.

Resulting system behavior: The system can query object relations, calculate distances, preserve a map across observations, plan routes, or constrain actions using explicit geometry.

Residual gap: Spatial accuracy depends on perception, coordinate alignment, map freshness, occlusion handling, and representation quality. Textual relations, two-dimensional images, navigation, and three-dimensional manipulation remain distinct task classes.

12. Temporal reasoning

Model-level gap: Models can make errors in date arithmetic, event ordering, recurrence, timezone conversion, duration calculation, or long-term tracking.

System bridge: Explicit temporal state and deterministic time tools.

Implementation mechanisms: Calendar APIs, datetime libraries, temporal databases, event logs, interval representations, timezone data, recurrence engines, and temporal constraint solvers. Toolformer included external calendar access among the tools used to extend language-model behavior. [5]

Resulting system behavior: The system can calculate dates, resolve schedules, order recorded events, detect conflicts, and maintain a timeline across interactions.

Residual gap: A calendar can compute from supplied records but cannot recover an event that was never recorded. Vague temporal language, uncertain dates, conflicting sources, changing timezones, and missing state still require interpretation.

13. Transfer and abstraction

Model-level gap: Performance on one formulation does not guarantee transfer to a structurally equivalent task, a new representation, or a different distribution.

System bridge: Reusable formal representations, modular tools, retrieval of analogous cases, routing, and targeted adaptation.

Implementation mechanisms: Schema induction, program synthesis, task templates, few-shot retrieval, domain adapters, shared intermediate representations, and model or tool routing.

Resulting system behavior: The system can reuse a workflow or representation across related tasks and select a specialized component when the base model is unreliable.

Residual gap: The system still needs to recognize that two tasks share the same structure. Surface variation, unobserved constraints, and distribution shift can break both the router and the selected component. Controlled mathematical evaluations show that apparently minor changes can materially alter model performance. [18]

Goals, planning, self-models, and action

14. Planning and executive control

Model-level gap: A generated sequence of steps can be infeasible, inconsistent with the current state, or unable to recover after an action changes the environment.

System bridge: Search, formal planning, explicit task state, and execution control.

Implementation mechanisms: Task graphs, workflow engines, finite-state machines, PDDL planners, tree search, candidate evaluation, replanning, budgets, stop conditions, and environment observations. Tree of Thoughts adds explicit search over alternative reasoning paths, while LLM+P translates natural-language planning problems into PDDL for a classical planner. [7][8]

Resulting system behavior: The system can decompose a goal, preserve dependencies, search alternatives, execute steps, observe results, and replan after defined failures.

Residual gap: Formal planners require a correct state representation, action model, and objective. Search can increase the chance of finding a useful plan without guaranteeing that the evaluated alternatives cover the correct strategy. A workflow also cannot adapt beyond transitions represented in its control logic.

15. Valuation and motivation

Model-level gap: A model can discuss preferences or optimize an assigned objective without possessing persistent needs, stakes, or self-generated motivation.

System bridge: Explicit objectives, utility functions, preference models, reward models, and priority policies.

Implementation mechanisms: Scoring functions, reward models, ranking models, constraint hierarchies, cost functions, service-level objectives, user-preference stores, and decision policies. Constitutional AI is one example of using an explicit set of principles together with critique, revision, preference modelling, and reinforcement learning to shape assistant behavior. [17]

Resulting system behavior: The system can rank alternatives and choose actions relative to encoded objectives or learned preferences.

Residual gap: The objective is supplied through training, configuration, or user input. A reward signal is not subjective value or desire. Misspecified objectives, conflicting preferences, proxy optimization, and incomplete state can produce behavior that is consistent with the encoded score but inconsistent with the intended outcome.

16. Self-knowledge and agency

Model-level gap: A model’s statements about its own tools, permissions, prior actions, or limitations can be inaccurate because the model does not automatically observe the complete runtime configuration.

System bridge: An explicit operational self-model.

Implementation mechanisms: Capability registries, tool inventories, permission state, current-task state, model and software version identifiers, action logs, execution receipts, and runtime introspection supplied by the application.

Resulting system behavior: The system can report which tools are available, distinguish proposed from executed actions, identify its current state, and attribute an observed result to a recorded system operation.

Residual gap: The registry can be stale or incomplete, and the model can misread supplied state. Accurate operational self-description does not establish autobiographical identity, subjective agency, or awareness of internal computation.

17. Embodied action and tool use

Model-level gap: Text generation does not itself create a software or physical side effect.

System bridge: Tool runtimes, APIs, robotic controllers, and feedback loops.

Implementation mechanisms: Function calling, typed schemas, API clients, browser or software controllers, robotic skill libraries, sensors, action execution, result observations, retries, and postcondition checks. ReAct interleaves reasoning with external actions, while SayCan combines language-model guidance with learned robotic skills and value functions grounded in the physical environment. [6][11]

Resulting system behavior: The complete system can query external sources, modify software state, operate devices, or act through a robot.

Residual gap: Tool selection, argument accuracy, permissions, execution, feedback interpretation, and outcome verification are separate stages. Strong performance on isolated function calls does not imply reliable stateful or long-horizon execution. [19]

Social cognition, affect, empathy, and norms

18. Theory of mind and mental-state prediction

Model-level gap: Mental-state answers can be sensitive to prompt formulation, incomplete history, or heuristic patterns. Performance also differs across false-belief, indirect-request, irony, misdirection, and faux-pas tasks. [20]

System bridge: Explicit actor-state and belief-state tracking.

Implementation mechanisms: Per-actor records, conversation memory, perspective-specific knowledge stores, dialogue state, event histories, relationship graphs, and consistency checks that distinguish what each actor has observed.

Resulting system behavior: The system can preserve different information states for different actors and use them to generate more context-consistent predictions or responses.

Residual gap: The actor model contains inferred or supplied representations, not direct access to another mind. Incorrect assumptions can persist across turns. Belief-state tracking can support bounded social prediction without establishing a general Theory of Mind mechanism.

19. Emotion and affect

Model-level gap: A model receives observable cues rather than direct access to another person’s affective state. Textual or multimodal signals are ambiguous and context-dependent.

System bridge: Affective-signal analysis and bounded response policies.

Implementation mechanisms: Emotion or sentiment classifiers, prosodic analysis, facial-expression models, conversation history, uncertainty scores, personalization state, and routing rules that control how inferred signals may affect tone or escalation.

Resulting system behavior: The system can detect selected cues and adapt wording, pacing, or support strategy to a hypothesized user state.

Residual gap: The inferred state is not ground truth. The same cue can have different meanings across people, languages, tasks, and cultures. Producing affective language or adapting tone also does not establish felt affect in the system.

20. Social communication and empathy

Model-level gap: A fluent response can ignore relationship history, non-verbal cues, conversational roles, or the distinction between emotional recognition and appropriate support.

System bridge: Dialogue state, relationship context, multimodal cues, and response evaluation.

Implementation mechanisms: Speaker tracking, user-approved profile state, communication-style constraints, conversation memory, multimodal perception, candidate-response scoring, and task-specific review criteria.

Resulting system behavior: The system can produce responses that are more consistent with the relationship, conversational context, and observable emotional cues.

Residual gap: A response judged empathetic demonstrates communicative performance. It does not establish affective sharing, attachment, compassionate motivation, or concern for another person’s welfare. Stored relationship state can also preserve incorrect or outdated assumptions.

21. Ethics and norms

Model-level gap: Model behavior can vary across formulations, contexts, and learned social patterns. A generated moral explanation does not guarantee consistent application of a norm.

System bridge: Explicit principles, policy rules, preference models, and independent checks.

Implementation mechanisms: Rule sets, constitutional prompts, policy classifiers, decision tables, domain-specific constraint engines, preference modelling, and review or escalation workflows. Constitutional AI demonstrates one training approach in which written principles are used to generate critiques, revisions, and preference signals. [17]

Resulting system behavior: The system can apply defined constraints, explain a decision using an encoded framework, and route unresolved conflicts for additional review.

Residual gap: Norms can conflict, remain underspecified, or depend on facts the system does not possess. Rule compliance is not moral agency, stable personal commitment, or responsibility for consequences.

Metacognition, uncertainty, and provenance

22. Metacognition and self-monitoring

Model-level gap: A generated self-critique is another model output. It can repeat the same error, rationalize an incorrect answer, or report confidence unrelated to actual correctness.

System bridge: Independent verification and observable tests.

Implementation mechanisms: Critic models, candidate generation and ranking, unit tests, executable checks, formal validators, cross-model comparison, retrieval-based fact checking, and error-triggered revision loops. Training verifiers to rank candidate mathematical solutions has been shown to improve performance relative to generation alone. [13]

Resulting system behavior: The system can detect and correct some errors before returning a result.

Residual gap: Generator and verifier failures can be correlated. A verifier can accept a persuasive but incorrect answer, reject an unfamiliar correct answer, or validate only the property it was designed to test. External verification improves reliability without giving the generator human metacognition.

23. Uncertainty handling

Model-level gap: Token probabilities, sequence likelihood, verbal confidence, and answer correctness are different quantities. A model can sound certain when wrong and hesitant when correct.

System bridge: Measured uncertainty, calibration, and abstention policies.

Implementation mechanisms: Log-probability analysis, repeated sampling, ensembles, semantic clustering, semantic entropy, calibration models, retrieval-coverage measures, confidence thresholds, and selective prediction.

Resulting system behavior: The system can estimate uncertainty for a defined task, defer low-confidence cases, request more information, or route them to another process. Semantic-uncertainty methods address the fact that different generated sentences can express the same answer. [14]

Residual gap: Calibration is task- and distribution-dependent. A system calibrated on one dataset can become miscalibrated after a domain shift. Low sample diversity can also create false confidence, while token-level probability does not directly measure factual correctness.

24. Source monitoring and epistemic provenance

Model-level gap: Parametric knowledge generally lacks a recoverable source trace, and a generated citation can be unsupported or fabricated.

System bridge: Retrieval provenance and claim-level evidence tracking.

Implementation mechanisms: Document identifiers, immutable source versions, passage offsets, retrieval traces, tool logs, claim-to-source links, citation validators, and evidence-support checks.

Resulting system behavior: The system can show which retrieved source supports a claim and preserve evidence about the source version and retrieval path.

Residual gap: A citation can point to a real document that does not support the claim. Retrieved evidence can also be incomplete. ALCE evaluations found substantial gaps in complete citation support even among strong systems, demonstrating that citation generation and citation validity must be measured separately. [15]

Creativity, generalization, and robustness

25. Creativity

Model-level gap: A single decoding path explores only a small part of the possible output space and may converge on predictable or repetitive results.

System bridge: Diverse generation, explicit search, external evaluation, and iterative selection.

Implementation mechanisms: Multiple samples, controlled randomness, diverse decoding, search trees, novelty filters, constraint checks, critic models, human evaluation, and refinement loops. Tree of Thoughts demonstrates an inference architecture that explores and evaluates alternative paths rather than committing to one left-to-right trajectory. [7]

Resulting system behavior: The system can generate a wider candidate set, compare alternatives, and optimize for defined criteria such as novelty, usefulness, style, or constraint satisfaction.

Residual gap: The evaluator defines what counts as a successful creative result. Search can increase diversity without guaranteeing originality or value. Creative output does not establish intention, subjective experience, authorship, or a human-like creative process.

26. Adaptive generalization and robustness

Model-level gap: Benchmark performance can degrade under paraphrase, irrelevant clauses, numerical substitutions, new tools, longer horizons, or distribution shift. [18][19]

System bridge: Evaluation-driven adaptation and failure-aware system composition.

Implementation mechanisms: Perturbation testing, adversarial evaluation, model routing, ensembles, retrieval, specialized tools, fallback workflows, feedback collection, fine-tuning, regression suites, monitoring, and versioned deployment.

Resulting system behavior: The system can route around known weaknesses, recover from selected failures, and improve performance across a wider range of evaluated conditions.

Residual gap: No finite evaluation establishes robustness to every future distribution. New inputs can affect the model, retriever, router, verifier, or tool interface in different ways. Fine-tuning for a new distribution can also damage existing behavior through catastrophic forgetting. [16]

4. What the Technical Bridge Actually Adds

The capability map contains several technically distinct forms of extension.

Bridge type	What it adds to the system	What it does not establish
External state	Durable records that can survive beyond one model call	Model learning, autobiographical memory, or guaranteed correct recall
Retrieval	Access to selected external information	Complete evidence coverage or automatic source validity
Context management	Selection and preservation of task-relevant working state	Reliable use of every context item
Specialized computation	Deterministic calculation, formal search, simulation, or constraint solving	Correct translation from the original task into the formal representation
Planning and orchestration	Explicit state transitions, branching, retries, and stop conditions	General adaptive planning by the base model
Multimodal and environmental interfaces	Visual, auditory, spatial, sensor, or software observations	Complete grounding or human-like embodiment
Tools and actuators	External queries and side effects	Correct tool selection, authorization, execution, or outcome
Verification	Independent tests, ranking, evidence checks, and candidate selection	Infallibility or human-like metacognition
Adaptation	Updated memory, routing, models, policies, or parameters	Stable continual learning without regression

These bridge types should not be collapsed into a single concept of “augmentation.”

Retrieval changes the information available during inference.

Persistent state changes what the application can retain.

A solver changes which computations the system can perform.

A planner changes how alternatives and dependencies are represented.

A tool changes whether the system can interact with an external environment.

A verifier changes how candidate outputs are accepted or rejected.

Fine-tuning changes model parameters.

Each mechanism creates a different capability boundary and requires a different evaluation.

5. What Remains Unresolved

Technical bridges move the boundary of capability. They do not erase it.

Retrieval does not guarantee knowledge coverage

A retrieval system can expose current or domain-specific information. It can also miss a relevant source, retrieve a partial passage, or select evidence that supports only one side of a claim.

The system has gained access to external information. It has not gained complete knowledge of the corpus.

Persistence does not create autobiographical memory

An event store can preserve what happened, when it happened, and which entities were involved. The model can use that record to maintain continuity.

The record is still an application-managed data object. It does not demonstrate recollection, personal ownership, or subjective continuity.

A formal tool does not correct the wrong formalization

A calculator, solver, planner, or simulator can return a correct result for the input it receives.

If the model omits a constraint, uses the wrong units, constructs an invalid causal graph, or translates the user’s task incorrectly, the tool can execute perfectly while the system produces the wrong answer.

Workflow control does not imply general planning

A task graph can enforce dependencies and prevent a workflow from skipping required stages. It can also encode retries and stop conditions.

The system remains limited to the states, transitions, and recovery paths represented in the workflow or discovered by its search procedure.

Objective functions do not create motivation

A reward model, priority score, or utility function can make system choices more consistent relative to a defined objective.

That objective was encoded, learned from supplied preferences, or assigned at runtime. It does not establish desire, personal stakes, or self-generated intention.

Actor models do not provide direct access to mental states

Belief tracking and relationship memory can improve consistency in social reasoning. They remain models built from observed or supplied evidence.

An incorrect inference can become persistent state and influence later responses.

Verification remains a fallible component

A verifier can detect properties that the generator does not check reliably. It may still share the generator’s blind spots, operate on incomplete evidence, or validate a proxy rather than the real requirement.

Verification must therefore be evaluated as its own component.

System capability cannot be assigned automatically to the model

When retrieval, tools, planners, sensors, and validators participate in a result, the observed capability belongs to the complete tested configuration.

Removing one component may remove the behavior.

The correct claim is not simply that “the LLM can do the task.” It is that a specified system, under specified conditions, achieved a measured result using an identified set of components.

6. Evaluating the Resulting System Capability

An end-to-end success rate cannot show which component created the improvement or which residual gap remains.

Evaluation should separate four conditions.

1. Base-model condition

Evaluate the model without the bridge.

This establishes the baseline and defines the model-level gap under the tested conditions.

2. Component condition

Evaluate the added component independently where possible.

Examples include retrieval recall, planner validity, tool execution accuracy, calibration error, citation support, or verifier precision and recall.

3. Interaction condition

Evaluate the interface between the model and the component.

The model may select the wrong tool, construct invalid arguments, misread a tool result, retrieve the correct passage but ignore it, or send an incorrectly formalized task to a correct solver.

4. Complete-system condition

Evaluate whether the full system achieves the required task outcome under realistic operating conditions.

This condition should test the final state rather than only the generated response.

A useful evaluation contract includes:

Evaluation field	Question
Target behavior	What observable capability is being claimed?
System boundary	Which models, stores, tools, controllers, and validators are included?
Baseline	What happens when the bridge is removed?
Component metric	Does the added component perform its own function correctly?
Interface metric	Does the model invoke and interpret the component correctly?
Outcome metric	Did the complete task reach the required final state?
Perturbation set	Does performance survive paraphrase, reordering, irrelevant information, and new cases?
Residual-gap metric	Which known failures remain after the bridge is added?
Evidence record	Can the result be traced to the components and sources that produced it?

Use ablations to attribute the improvement

If a system contains retrieval, memory, planning, tools, and verification, evaluate it with selected components removed or replaced.

Ablation does not prove a component is sufficient. It helps establish whether the component contributed to the measured behavior.

Generative Agents, for example, used ablations to examine the contribution of observation, planning, and reflection to the resulting behavior. [3]

Measure capability-specific failure modes

Different bridges require different measurements.

For memory:

• retrieval precision and recall;
• entity-association accuracy;
• temporal consistency;
• stale-record rate;
• source traceability.

For retrieval:

• corpus coverage;
• passage relevance;
• evidence completeness;
• citation correctness;
• answer support.

For planning:

• plan validity;
• constraint satisfaction;
• path cost;
• replanning success;
• final-state completion.

For tools:

• tool-selection accuracy;
• argument validity;
• abstention accuracy;
• execution success;
• postcondition success.

For uncertainty:

• calibration error;
• selective risk;
• error-detection recall;
• abstention utility;
• performance under distribution shift.

For social-state modelling:

• actor-state consistency;
• sensitivity to relevant belief changes;
• invariance to irrelevant wording changes;
• recovery after a corrected assumption.

For robustness:

• worst-case performance across controlled perturbations;
• performance on unseen distributions;
• regression after updates;
• component-specific failure attribution.

Preserve the distinction between performance and mechanism

If a system succeeds after adding a bridge, the evaluation should state:

1. what behavior improved;
2. which component supplied the missing function;
3. whether the base model changed;
4. which conditions were tested;
5. which residual failures remain.

This prevents an end-to-end result from being converted into a broader claim about the model’s internal capability.

Conclusion

AI systems can bridge many model-level capability gaps without reproducing the corresponding human mechanism.

Persistent stores can create continuity.

Retrieval can add current and domain-specific information.

Multimodal components can expose visual, auditory, and sensor observations.

Calculators, code runtimes, causal tools, and formal solvers can add computations that free-form generation performs unreliably.

Planners and orchestration layers can maintain state, search alternatives, and enforce task dependencies.

Tools and actuators can connect model outputs to software or physical action.

Verifiers can test candidate results.

Feedback and model updates can adapt later behavior.

These additions can produce genuine functional capability. They also move responsibility for the result from the model alone to the complete system.

The remaining question is not whether the system behaves exactly like a human.

It is whether the architecture supplies the function the task requires, whether the resulting behavior survives controlled evaluation, and whether the remaining gap is stated explicitly.

The professional attribution is therefore:

Model-level gap → technical bridge → resulting system capability → residual gap

That sequence describes what the system can do without confusing the component that generated language with the architecture that made the full result possible.

Continue from capability targets to system architecture

Separate observed behavior, model capability, external system capability, and the mechanisms responsible for each result.

• Capability article

  Human Capabilities vs. Human-Like AI Behavior →

  Compare human capabilities with AI behavior while separating performance, mechanism, and attribution.

  Open
• Architecture article

  LLM Memory vs. Context: 5 Architecture Boundaries →

  Separate model parameters, invocation context, retained state, retrieval, persistence, and updates.

  Open
• Architecture article

  Tool-Using LLMs: Model-Led vs. Orchestrator-Led Execution →

  Compare where tool selection, validation, execution authority, retries, and stop conditions are placed.

  Open

References

1. Lewis et al. Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
2. Packer et al. MemGPT: Towards LLMs as Operating Systems
3. Park et al. Generative Agents: Interactive Simulacra of Human Behavior
4. Liu et al. Lost in the Middle: How Language Models Use Long Contexts
5. Schick et al. Toolformer: Language Models Can Teach Themselves to Use Tools
6. Yao et al. ReAct: Synergizing Reasoning and Acting in Language Models
7. Yao et al. Tree of Thoughts: Deliberate Problem Solving with Large Language Models
8. Liu et al. LLM+P: Empowering Large Language Models with Optimal Planning Proficiency
9. Gao et al. PAL: Program-Aided Language Models
10. Driess et al. PaLM-E: An Embodied Multimodal Language Model
11. Ahn et al. Do As I Can, Not As I Say: Grounding Language in Robotic Affordances
12. Jiang et al. LLM4Causal: Democratized Causal Tools for Everyone via Large Language Model
13. Cobbe et al. Training Verifiers to Solve Math Word Problems
14. Kuhn, Gal, and Farquhar. Semantic Uncertainty: Linguistic Invariances for Uncertainty Estimation in Natural Language Generation
15. Gao et al. Enabling Large Language Models to Generate Text with Citations
16. Li et al. Revisiting Catastrophic Forgetting in Large Language Model Tuning
17. Bai et al. Constitutional AI: Harmlessness from AI Feedback
18. Mirzadeh et al. GSM-Symbolic: Understanding the Limitations of Mathematical Reasoning in Large Language Models
19. Patil et al. The Berkeley Function Calling Leaderboard: From Tool Use to Agentic Evaluation of Large Language Models
20. Strachan et al. Testing Theory of Mind in Large Language Models and Humans