Is architecture always physical hardware?

In the foundational agent account it includes the execution and interaction platform; software agents can interact through digital interfaces.

Is a neural-network architecture the same concept?

It is a related use of the word at a different level, describing a model's internal organization.

Can a better program overcome every platform limitation?

No. Missing observations or unavailable actions may require changes beyond the decision program.

AI Glossary / Graphs and symbolic AI / Beginner

Architecture

Definition

In the intelligent-agent context, architecture is the underlying computing and interaction platform on which an agent program runs. It supplies observations to the program and carries out the program's action choices through available interfaces or actuators. The agent's behavior therefore depends on both its program and the capabilities of its architecture.

What it means

An agent program describes how to select actions, but it needs a platform that can receive relevant information, execute the computation, and produce the requested effects. A brilliant decision procedure cannot use a sensor that is absent or issue a physical movement through hardware that cannot perform it.

Architecture is a broad word in AI. It can also refer to a neural network's arrangement of layers, a software system's components, or a cognitive design. This entry uses the foundational agent-platform sense associated with the source glossary context.

The distinction is useful when diagnosing capability limits. Some problems require a better decision rule; others require different inputs, action interfaces, storage, or computing resources. Changing one layer does not automatically repair the other.

How it works

An architecture receives percepts, meaning information available from the environment, and makes them accessible to the agent program. It provides computational resources and routes the selected action to the relevant output mechanism.

For a physical agent, this may involve sensors, processors, and actuators. For a software agent, the corresponding interaction can occur through data feeds and defined application interfaces. The abstraction is similar, although digital permissions and physical capabilities impose different constraints.

The program must fit the platform. Its expected inputs, action vocabulary, timing needs, and memory requirements must be compatible with what the architecture supplies. A mismatch can prevent an otherwise sensible policy from working.

The same abstract agent function may have different implementations on different platforms. Conversely, the same program can behave differently if its observations arrive late, its action interface has different semantics, or the environment supplies different information. These dependencies should be tested rather than inferred from a diagram alone.

Three practical examples

1. A sorting prototype receives object positions from a simulator and sends movement commands to simulated actuators. Moving the program to a physical setup requires compatible sensing and action capabilities.

2. A document assistant can read records through one interface but cannot update them through that interface. Its architecture supports analysis while a proposed editing action needs an additional authorized capability.

3. A monitoring agent runs on a device with limited memory. A program that retains every observation may need redesign or a platform change as its history grows.

Think of it this way

Think of the architecture as the instrument and the agent program as the playing instructions. Instructions for producing a sound must match what the instrument can actually do.

The analogy is limited because intelligent-agent behavior also depends on observations and interaction with a changing environment. A platform is not merely passive equipment: its timing, interfaces, and constraints shape what information the program receives and what actions are possible.

Worked example

Consider an original simulated shelf agent. Architecture A supplies only the shelf's current occupancy and supports two actions: display occupied or display empty. Program P correctly chooses between those outputs based on the observation.

Now the task changes: the agent must count how many times occupancy changed during the last ten observations. With a binary occupancy reading, there are at most nine transitions between those ten readings. The sequence empty, empty, occupied, occupied, empty, empty, occupied, occupied, occupied, empty contains four changes.

The current reading alone cannot determine that count. The program needs access to history or enough maintained state to update the count within the required window. Merely improving its current-state decision rule does not supply the missing information.

If Architecture B additionally supplies a verified transition count, a simpler program may answer directly. Both designs still need a precise time-window definition. This toy example shows how information and memory support affect a task, not a universal hardware requirement.

Illustrative case study

Fictional case: Laurel Inventory tests an agent that recommends moving items between shelves. Its planning program assumes it can retrieve exact item locations, but the available interface reports only zone-level locations.

The team revises the task model and decides which recommendations require a confirming observation. It does not treat the missing detail as a prompting problem. This invented case illustrates alignment between program assumptions and platform capabilities; it reports no deployed inventory improvement.

Common misconceptions and mistakes

Architecture is not synonymous with a trained model. A model can be one component of an agent program, while the complete agent also needs inputs, computation, and action channels.

A platform diagram does not demonstrate reliable behavior. Interface semantics, resource limits, and actual observations matter alongside the arrangement of components.

Do not assume that describing an action makes it executable. A planning symbol such as move, publish, or reserve must correspond to a capability with defined preconditions and effects. Also distinguish this agent-platform usage from neural-network architecture when reading technical material: the intended level of discussion changes the meaning.

Business use

The distinction helps businesses ask concrete capability questions before selecting an AI solution. What can the system observe? Which actions can it perform? What computing and memory resources does it require? Where do timing or access limits affect the task?

These questions connect proposed behavior to an implementable system. During evaluation, test the complete observation-to-action path, including missing data and interface failures. A strong isolated model result does not establish that the surrounding agent can obtain the necessary inputs or carry out its decisions in the target environment.

Check your understanding

A program chooses a correct action called lift, but the platform has no lifting mechanism. Does the complete agent thereby perform the lift?

Answer: No. Selecting an action symbol is insufficient unless the architecture can implement its intended effect.

Related terms

Agent program
Agent function
Percept
Cognitive architectures
sensor
actuator
cognitive architecture
neural-network architecture
task environment

Learn next

Next, describe a small agent using three columns: available observations, the program's decisions, and executable actions. Identify one assumption that must be checked at each interface.

Sources

Russell and Norvig, Intelligent Agents, author-hosted chapter, section on the structure of agents: https://aima.cs.berkeley.edu/4th-ed/pdfs/newchap02.pdf

Primary definition read. Editorial scope: architecture here means the agent's execution and interaction platform, not a particular neural model or an enterprise architecture framework. Examples are original.

Previous: Archetypal analysis Next: ARD kernel