Category
Engineering
Published
June 27, 2026
Reading time
10 min read

Architecting Agentic Systems for Production

Why production agents need controlled agency: scoped skills, deterministic tools, permissions, observability, review, and evaluation.

Share this page

Key Takeaways

Production agents are not about maximum autonomy; they are about controlled agency.
Use agents for ambiguity and deterministic tools for truth.
An agent without observability is not production infrastructure; it is a black box with permissions.

Agents become serious when they can act

This article is not about building impressive agent demos. It is about what changes when an AI system is allowed to act.

The moment an AI system can call tools, change data, trigger workflows, send messages, create tickets, update records, deploy code, or make decisions, the architecture problem becomes much more serious. A chatbot can be wrong and still be contained. An agent can be wrong and change something.

Production-grade agentic systems are not defined by autonomy. They are defined by boundaries, permissions, tools, observability, ownership, and evaluation. Agents are not powerful because they can do anything. They are useful because they can do the right thing inside clear boundaries.

Controlled agency beats unlimited autonomy

Agents do not become production-ready by giving them more freedom. They become production-ready by giving them the right constraints.

A useful agent is not a chatbot with a vague instruction to complete the task. A useful agent is a controlled actor inside a system, with scoped skills, explicit context, deterministic tools, permission boundaries, human review where needed, observable steps, testable outcomes, clear ownership, escalation paths, evaluation loops, and iteration over time.

The future of agents is not unlimited autonomy. It is controlled agency. Autonomy should be earned, not assumed, and it should expand only when the team can observe, evaluate, and govern the behavior.

Do not call everything an agent

A workflow follows known steps. A deterministic tool performs a reliable action. An agent chooses between possible steps within boundaries. A human owns judgment, accountability, and escalation.

That distinction matters. Many agent demos are just workflows with extra risk. If a process is predictable, deterministic, and repeatable, it may not need an agent. It may need a normal workflow, script, queue, rule engine, or API integration.

Use agents for ambiguity. Use deterministic tools for truth. Use agents when there is interpretation, prioritisation, context-switching, or uncertainty. Use deterministic systems when correctness, repeatability, and auditability matter.

Treat agents like junior developers with tool access

An agent should be treated like a junior developer with tool access. You might let a junior developer analyse a problem, suggest a solution, prepare a pull request, or write documentation. You would not give them unrestricted production access, the ability to approve their own work, or the authority to change business-critical data without review.

The same applies to agents. The point is not that agents are useless. The point is that capability needs supervision, scope, and accountability.

Do not give an agent more freedom than your organisation can observe, evaluate, and govern.

The backend should provide truth

If an agent needs to answer a pricing, eligibility, product availability, delivery status, or account-specific question, it should not invent the answer from text. It should call a deterministic tool: an API, database, pricing engine, eligibility checker, stock service, CRM, ERP, or other source-of-truth system.

The agent can interpret the user request and decide which tool to use. The tool should provide the reliable answer.

The model should handle ambiguity. The backend should provide truth. This is one of the most important architectural separations in reliable agentic systems.

The chatbot that became a Drupal consultant

I once tested an e-commerce product chatbot on an external hard drive product page. The screenshot below is intentionally hard-redacted. The point is not to call out a retailer. The point is to show how quickly an AI interaction can move from one business context into another.

The user asked whether an external hard drive could be used as a temporary staging environment for a Drupal website, with Drupal code on the drive and Node, PHP, Composer, Drush, cron, and a queue worker running from that project folder. The chatbot answered with a detailed Drupal setup plan: folder paths, Composer commands, Drush commands, cron setup, queue worker loops, database setup, and local PHP server commands.

At first glance, the answer looked helpful. It even included some relevant product context: the drive was an HDD, so it might be acceptable for temporary staging but slower than an SSD for heavier development workloads. That is where the architecture question begins.

A hard-redacted boundary failure example

Hard-redacted screenshot of an e-commerce product chatbot answering a broad Drupal implementation question.

An anonymised e-commerce product chatbot answered a broad Drupal implementation question from an external hard drive product page. The example is not about the brand; it is about how quickly an AI interaction can move from product context into another domain.

A useful answer can still raise an architecture question

The interesting part of this example is not deciding what the chatbot should have answered. That depends on the business. Some organisations may want a product chatbot to stay close to product-fit guidance. Others may deliberately allow broader technical advice because it supports customer confidence, discovery, or conversion. Both choices can be valid if they are intentional.

The architecture question is whether that responsibility was designed. When a product chatbot moves from product context into implementation guidance, several questions become relevant. Is this a supported domain? Does the business want to own this kind of answer? Which sources should the chatbot rely on? Should the answer include limitations or disclaimers? Should it stay at product-fit level, or is deeper technical guidance part of the intended experience?

The lesson is not that this specific chatbot should have answered differently. The lesson is that agent boundaries should be explicit. An agent can produce a useful answer and still reveal an unclear responsibility boundary.

Make responsibility explicit

This example shows why agentic systems need scoped responsibilities. A chatbot might have a product-fit skill, a technical guidance skill, a troubleshooting skill, or all of them. The important part is that those capabilities are explicit. If an organisation wants technical implementation advice, that capability should have its own scope, source rules, review expectations, disclaimers, and evaluation criteria.

The same applies to any agentic system. Do not let a broad model response silently define the product boundary. Decide what the agent is responsible for, what it is not responsible for, and how the system should behave when a user asks for something near the edge of that boundary.

Agent architecture is mostly not about prompts. It is about boundaries, tools, permissions, and feedback loops.

Permissions are architecture

Permissions are one of the hardest parts of agentic systems. It is not enough to ask whether the agent can do something. You need to ask which user the agent is acting for, which data it can see, which tools it can call, which actions are read-only, which actions require approval, which actions are irreversible, and which context should never be shared between tasks.

You also need to decide what happens when the agent is uncertain and who is responsible when the agent takes an action.

Permissions should be designed as part of the architecture, not added later. The moment an agent can act on behalf of a user, permission design becomes product design, security design, and workflow design at the same time.

Observability is not optional

If an agent takes five steps, the team should be able to see those steps. What did it read? What context did it use? Which tool did it call? What did the tool return? Why did it choose the next action? Where did it ask for human approval? What changed in the system?

Without observability, an agent is not production infrastructure. It is a black box with permissions.

Observability is what makes agent behavior governable. It supports debugging, review, compliance, evaluation, and trust. It also gives teams a way to improve the system over time instead of treating agent behavior as mysterious model output.

Production agents need feedback loops

A production agent is not finished when the first version completes a task. Models change. Tools change. Business rules change. User behavior changes. Edge cases appear. The system needs evaluation and iteration.

Teams should know which workflows actually need an agent, which should remain deterministic, what tools the agent may use, which skills should be scoped and standardised, what permissions apply per user or action, which steps require human approval, what should be logged, how behavior is evaluated over time, and what happens when the model changes.

The article cannot solve every operational question in one page, and it should not try to. The useful point is clarity: production agents are architecture projects, not prompt projects.

Build agents that can do the right thing

Agents are useful when they can act, but dangerous when they can act without boundaries. The goal is not to build the most autonomous agent. The goal is to build the most reliable system around the agent.

Context makes the agent relevant. Skills make the agent useful. Deterministic tools make the agent reliable. Permissions make the agent safe. Observability makes the agent governable. Human review keeps accountability with the team. Evaluation catches failures and drift. Iteration makes the system production-ready.

Do not build agents that can do anything. Build agents that can do the right thing, with the right tools, inside the right boundaries, while humans can still understand, evaluate, and improve the system.

Share this page

READY FOR DEPLOYMENT

Let’s discuss reliable AI systems.

If this topic connects to a challenge inside your team, I am happy to compare notes.