LMXAI is an EU-based AI engineering studio that designs and builds production-grade agentic systems with LangGraph, controlled tool use, retrieval, evaluation and observability. The focus is not on autonomous demos, but on bounded workflows that can be tested, monitored and operated safely in real business environments.

Based in Leiden, the Netherlands, LMXAI works across architecture, backend engineering, model integration, RAG, inference and product delivery, so the agent layer is designed together with the systems it must actually use.

What makes an agentic system production-grade?

A production agent needs more than an LLM connected to tools. It needs explicit control over what the model can decide, what it can access, how failures are handled and how quality is measured.

LMXAI typically treats an agentic system as six connected layers:

Orchestration — state, routing, retries, branching and deterministic steps.
Model layer — one or more models selected according to task quality, latency, privacy and cost.
Tools — internal APIs, search, databases, document services, MCP servers and business actions.
Retrieval — relevant internal or external knowledge with source attribution and access controls.
Evaluation — repeatable tests for tool selection, task completion, groundedness and failure cases.
Observability & governance — traces, logs, permissions, approvals and operational metrics.

LangGraph is useful because it lets us make state and control flow explicit rather than hiding the entire workflow inside a long prompt.

LangGraph without uncontrolled autonomy

LMXAI uses LangGraph where a workflow benefits from model-driven decisions but still requires engineering control.

Examples include:

routing a request to the correct tool or knowledge source;
decomposing a complex task into bounded steps;
retrieving additional evidence when the first result is weak;
requiring approval before a consequential action;
validating tool output before it reaches the next node;
escalating to a human when confidence or policy conditions are not met.

The goal is not maximum autonomy. The goal is the minimum autonomy required to solve the task reliably.

Tool use as an engineering interface

Tool calling is where an agent starts interacting with real systems, so tool design matters as much as prompt design.

LMXAI designs tools with:

narrow, explicit schemas;
validated inputs and outputs;
scoped permissions;
idempotency where actions may be retried;
predictable error contracts;
auditability of tool calls;
timeouts and fallback behavior;
approval gates for high-impact actions.

Tools can be exposed through direct APIs, internal service wrappers or MCP when interoperability is useful. The model should never receive broader access than the task requires.

Retrieval for agents

Agentic systems often need to choose between multiple data sources rather than query one fixed vector index. LMXAI can combine:

dense and sparse retrieval;
hybrid search;
Elasticsearch or other enterprise search infrastructure;
metadata- and permission-aware retrieval;
query rewriting and decomposition;
multi-index routing;
source verification before response generation.

This turns retrieval into a controlled relevance layer instead of a generic “search tool”.

Evaluation before production

An agent is not ready because a few manually tested conversations worked. LMXAI builds evaluation around the actual decisions the system must make.

Depending on the use case, evaluation can include:

task completion rate;
correct tool selection;
tool argument accuracy;
retrieval recall and groundedness;
citation correctness;
refusal and escalation behavior;
loop and retry rates;
latency and token cost;
regression tests across model or prompt changes.

For tool-use systems, LMXAI also works with benchmark-style evaluation patterns such as BFCL-derived function-calling tests, combined with domain-specific test sets that reflect the client's real workflows.

Observability and auditability

Production agents need traces that explain what happened across a workflow. LMXAI can instrument agent runs with technologies such as OpenTelemetry and Phoenix so teams can inspect model calls, tool calls, retrieval steps, latency, failures and token usage.

This is especially important when agents operate in regulated or high-stakes domains. A team must be able to distinguish a model error from a retrieval failure, tool failure, permission problem or orchestration bug.

Example architecture

A typical system may look like:

User or application → API → LangGraph workflow → model/router → retrieval + tools → validation/approval → response or business action

Across the workflow sit identity, permissions, traces, evaluation and policy controls.

The final architecture can run with frontier APIs, self-hosted open models or a hybrid setup. LMXAI is model-agnostic and also builds sovereign inference stacks with vLLM and Kubernetes when data residency or infrastructure control requires it.

Relevant LMXAI experience

LMXAI has built production systems across enterprise, education and allied health, including:

enterprise AI workspaces with sovereign inference;
LangGraph-based agentic workflows;
MCP and custom tool integrations;
RAG systems with enterprise retrieval;
multimodal tool-use fine-tuning;
AI gateways with streaming, isolation and observability.

The engineering stack includes LangGraph, LangChain, MCP, FastAPI, Elasticsearch, vLLM, Kubernetes, OpenTelemetry and Phoenix.

Explore LMXAI's agentic capabilities

When should you use an agent?

Agentic architecture is useful when a task requires dynamic decisions between tools, sources or workflow paths. It is often unnecessary when a deterministic service, fixed pipeline or normal search endpoint can solve the problem more reliably.

LMXAI therefore starts with the business workflow and asks where model reasoning actually adds value. Autonomous complexity is added only when it earns its operational cost.

What a typical engagement delivers

A production engagement can cover:

workflow and architecture design;
LangGraph implementation;
tool and MCP integration;
retrieval architecture;
model selection and routing;
evaluation datasets and release gates;
observability and tracing;
permissions and human approval flows;
deployment, load testing and production hardening;
documentation and handover.

Need an EU team to build the system, not just prototype it?

LMXAI can take an agentic product from workflow design to production architecture, implementation, evaluation and deployment under one engineering owner.

Discuss your agentic system with LMXAI

Production-grade agentic systems with LangGraph, tool use & evaluation