Skip to content
Service 02 / 05

AIEngineering.

AI engineering for production. We build systems your team can run: retrieval-augmented generation and agent workflows with access that respects permissions, evaluation before release, controlled use of tools and monitoring in production.

01 / The Shift

From Demo to Dependable

Today

Isolated prototypes

A model demo can look promising and still be a long way from daily use. It needs reliable retrieval, access controls, evaluation and a route to deployment before people can depend on it.

Target

Governed AI systems

Approved knowledge and scoped tools are connected to the workflow. Releases are evaluated on representative tasks, failures can be traced, and actions with real consequences wait for approval.

02 / Methodology

Built in Three Layers

01 / Reasoning01 / 03

The Thinking Layer

Choose and adapt models for the task, retrieve only the evidence the user is allowed to see, and build context so that an answer can point back to its sources.

  • Foundation models
  • Fine-tuning
  • Evidence retrieval
Selected evidence composes contextSelected source passages keep their distinct signatures as they join an assembled context. Other passages remain outside it. Selection is illustrative and does not establish that an answer is correct. Conceptual marks, not measured quantities or production records.

Make the answer inspectable.

Retrieve
Select relevant source material within the caller’s access permissions.
Compose
Build context from the question, the permitted evidence and the task instructions.
Answer
Cite the supporting passages and check important claims. Citations by themselves do not prove an answer is correct.
02 / Execution02 / 03

The Working Layer

Expose internal APIs and SQL tools through MCP, then enforce identity, scope and action policy at the edge of the application.

  • MCP servers
  • Internal APIs
  • Scoped access
Application policy before tool dispatchRequests meet the host application's policy boundary before permitted calls reach tool interfaces. Held requests stay on the caller side, and separate result paths return from the tools. MCP itself does not grant permission. Conceptual marks, not measured quantities or production records.

Authorise every tool call.

Protocol
MCP describes tools and invokes them. It does not grant business permissions.
Policy
Enforce identity, scopes and action rules in the application and in the API behind it.
Approval
Hold consequential writes for human approval when the action policy calls for it.
03 / Oversight03 / 03

The Watching Layer

Test how an agent behaves before choosing a release, and send consequential actions to human review when their policy requires it.

  • Evaluation cases
  • Release gates
  • Human review
Evaluation evidence before an agent releaseA candidate fans out into representative evaluation evidence. The evidence reaches a release gate before an approved version continues. This pre-deployment decision is separate from authorization of actions at runtime. Conceptual marks, not measured quantities or production records.

Release against clear criteria.

Evaluate
Test source attribution, access refusal and action routing with representative cases.
Release
Review the candidate’s evaluation evidence against the agreed acceptance criteria.
Runtime
Apply the action policy on every run and keep the decisions for oversight and review.
03 / Trust & Safety

Guardrails That Hold

Representative traceFive requests. Three controls.
Inspect a request
Blocked01 / 05

Rules before reasoning

The rule is evaluated before anything runs, not inferred from a prompt. The agent never reached the table, so nothing sensitive could enter its reasoning.

Request
agent.query
Target
customer_pii
Recorded
  1. 01Rules before reasoning
  2. 02Audit trails
  3. 03Human oversight
04 / Core Architecture

The Agent Loop

  1. Reason

    The model proposes an answer or a tool call.

  2. Authorize

    Host policy checks scope and any required approvals.

  3. Execute

    Permitted calls reach enterprise tools through MCP.

  4. Observe

    Tool results return as context for the next step.

Agentic System

Inference
Execution
Inference & reviewAI hostSupplies the objective and receives the final response. Input content does not grant additional permissions.User Intent REQUEST / RESPONSEBuilds model context and feeds tool results into the next turn. Completion, cancellation and configured limits stop the run.Agent Runtime AGENT LOOPHost policy checks arguments, scope and required approvals before its MCP client dispatches calls. Held or denied actions are not sent.Tool Gateway MCP CLIENTValidates and authorizes MCP tool calls, invokes system adapters and returns results to the host client.MCP Server TOOLS / ACCESSExisting APIs, data platforms and jobs execute scoped requests. Their own permissions still apply.Enterprise Systems APIS / DATA / JOBSReturns an answer or proposed tool call from selected context. The application controls execution.Model API CONTEXT / OUTPUTApproves or rejects an action when host policy requires review. Held or rejected calls are not dispatched.Human Review WHEN REQUIRED
Technical notes & sources

Reference architecture reviewed 7 September 2026.

MCP boundaries. One client communicates with one server; the host can manage several clients. Servers advertise supported tools, resources and prompts. This drawing follows an MCP tool call; native API adapters are another integration choice. Standard transports are stdio and Streamable HTTP. The HTTP authorization specification applies to protected HTTP servers; local stdio credentials are managed separately. MCP architecture, transports and authorization.

Runtime and context. Model inference, tool execution and stored run history are separate concerns. Checkpoints support recovery; selected context controls what enters each model call. Completion, cancellation and step or time limits bound the run. Retrieval and long-term memory are optional and do not require a vector database. Sandboxes and specialist agents depend on the task. Runtime separation, context engineering and persistence.

Action controls. Tool results do not confer authority. Input validation, least-privilege access and policy-based approval govern execution. Generated code needs a constrained execution environment. Record redacted events and evaluate model, prompt and tool changes before release. Bound retries and use idempotency or deduplication so resuming work does not duplicate a business action. Tool security, approval and resumable execution, and agent evaluations.

Optional delegation. A2A can connect independently deployed agents. It is a separate interoperability choice, not a required hop in every tool call. A2A overview.

05 / The Interface

Talk to It

06 / Delivery & platforms

Designed. Built. Handed Over.

Your team receives the application and its configuration, an evaluation set, release checks and operating instructions. The choice of model and platform follows the task, the data boundaries, and the latency and cost you need.