Contract fit · AWS Bedrock · Agentic AI

Production AI is the job. Bedrock is the service layer.

This contract is a strong overlap with how I already work: Python/FastAPI backends, RAG and vector retrieval, MCP, multi-agent orchestration, AWS delivery, observability, security and the final mile from prototype to a production system people can actually run.

View the full CV See agentic systems
Why the fit is real

I build the layer between the LLM demo and the production service.

The useful part of this brief is not simply calling a foundation model. It is grounding it in enterprise data, giving agents reliable tools, exposing the capability through clean APIs, deploying it safely, and making quality, latency, cost and failure visible.

That is the operating pattern behind my current agentic platforms and the same production discipline I have used across regulated and large-scale delivery.

Python + FastAPI
RAG + GraphRAG
Embeddings + vector DBs
MCP + tool use
Multi-agent orchestration
AWS + IAM
Docker + CI/CD
Observability + fallbacks
Requirement → evidence

The role, line by line.

A useful fit assessment should show evidence, not just repeat the job description.

Production AI applications
Strong

15+ years shipping production software and four years focused on production agentic systems. AIOS, AIBO and ABC are live multi-agent platforms with typed tool contracts, automated tests, human approval and recoverable provider fallbacks.

Python + FastAPI
Strong

Hands-on backend engineering with Python, FastAPI, REST/JSON APIs, inference pipelines and production integrations across the current agentic stack.

RAG + vector search
Strong

RAG, GraphRAG, embeddings, hybrid search, chunking, retrieval optimisation, LlamaIndex and vector stores including pgvector, Pinecone, Weaviate, FAISS, Chroma and MongoDB Atlas.

Agentic / multi-agent AI
Very strong

A 115-role multi-agent workspace plus production orchestration patterns covering planner/router/executor flows, tool use, memory/state, A2A hand-offs, approval gates and recoverable fallbacks.

MCP integrations
Very strong

MCP is part of the daily engineering model: own and third-party servers, typed tool interfaces, skills, subagents, hooks and production tool-use workflows.

AWS + containers + security
Strong adjacent fit

Production AWS experience across EC2, S3, Route53 and IAM, plus Docker, NGINX, GitHub Actions and CI/CD. The role-specific Bedrock/ECS/EKS depth is the right detail to validate directly rather than hide behind generic cloud experience.

Observability + cost control
Strong

Production patterns include observability, model routing, retries, caching, provider fallbacks, audit trails, incident-aware controls and explicit cost/latency trade-offs.

Enterprise product delivery
Very strong

Delivery across Allianz, RWS, Sainsbury's, Dun & Bradstreet/Cogniflare and other enterprise environments, bridging product, engineering, governance and hands-on implementation.

ABC workflow diagram · production request lifecycle

The full Bedrock path — from click to governed action.

Apps initiate intent. Backoffice owns the probabilistic machinery. Context owns the durable truth. Hover any node for the operational detail behind the box.

A
APPS
Thin product surfaces — no hard-coded model logic
hover nodes for detail
01

Request enters

Web · chat · API · event

A user, application or system event creates a typed request. The app collects tenant, user, session and channel metadata without embedding provider-specific model logic.
02

Authenticate

Identity · tenant · policy

Resolve identity, tenant and permissions before model invocation. Propagate a correlation ID so every retrieval, model call, tool action and audit record can be traced end-to-end.
03

Validate API contract

FastAPI · schema · limits

FastAPI validates the request shape, payload size, allowed tools, rate limits and service-level constraints. Bad requests fail here — not halfway through an expensive agent run.
typed request + identity + correlation id
B
BACKOFFICE
Bedrock + agent orchestration + security + operations
hover nodes for detail
04

Classify intent

Router · task · risk

Classify the request by capability, risk and latency class: direct answer, RAG, structured extraction, tool-use agent, workflow action or human-review task.
05

Pre-inference guard

Guardrails · policy

Apply input policies before retrieval or inference: PII handling, prompt-attack checks, restricted topics, tenant boundaries and explicit tool permissions.
06

Plan retrieval

RAG · GraphRAG · filters

Decide which context sources are required. Generate or refine retrieval queries, apply metadata filters, choose semantic / hybrid / graph retrieval and define the evidence budget.
07

Fetch enterprise context

KB · vectors · S3 · APIs

Retrieve authorised chunks, entities, records and live API data. Preserve source IDs and provenance so the final answer and tool decisions can be evaluated and audited.
08

Assemble context

Prompt · memory · evidence

Combine system policy, task instructions, retrieved evidence, conversation memory and tool schemas into a bounded context package. Compress or rank evidence when token budgets are tight.
09

Select model

Quality × cost × latency

Choose a Bedrock model or inference profile by capability, cost, latency, geography and current availability. Frontier models handle hard reasoning; cheaper models handle routine work.
10

Reason with Bedrock

Converse · InvokeModel

Invoke the selected model through Bedrock's runtime boundary. Stream where useful, enforce token/time budgets and keep provider-specific response details behind the Backoffice adapter.
11

Agent plan

State · steps · tool choice

For agentic tasks, convert model output into an explicit plan/state transition. The runtime decides whether the next step is another inference call, retrieval, a tool action or a human checkpoint.
12

Resolve tools

MCP · Gateway · schemas

Discover only the tools authorised for this tenant and task. MCP / Gateway contracts expose typed inputs, outputs and failure modes so tool use remains inspectable and testable.
13

Approval gate

Human-in-the-loop

High-impact actions — writes, external sends, financial or destructive operations — stop at an approval gate. Read-only and low-risk actions can continue autonomously.
14

Execute action

API · DB · SaaS · workflow

Execute the tool call with least-privilege credentials, idempotency keys, timeout/retry policy and structured error handling. Return machine-readable results to the agent state.
15

Post-inference guard

Safety · grounding · format

Validate the candidate response: safety policy, grounding requirements, citations/provenance, schema correctness and any domain-specific assertions before it leaves the platform.
16

Evaluate + observe

Trace · quality · cost · latency

Record the full trace: retrieval quality, model and token usage, tool results, latency, cost, failures, guardrail decisions and offline/online evaluation scores.
17

Persist useful state

Memory · cache · audit

Persist only the state worth keeping: session memory, approved outputs, cache entries, audit events and feedback. Apply retention and tenant isolation rules to every stored artefact.
Bedrock model buffet behind one contract
Frontier
Claude / OpenAI-class reasoning
Balanced
Production agent + RAG workloads
Economy
Extraction · classification · routing
Fallback
Alternate model / region / provider
retrieval · policy · memory · tools · eval evidence
C
CONTEXT
Portable enterprise truth — independent of the chosen model
hover nodes for detail

Identity + permissions

IAM · tenant roles · secrets · KMS · approval policy

Controls who can retrieve which sources, invoke which models and execute which tools. This boundary should be deterministic even when the model is not.

Enterprise knowledge

S3 · documents · DBs · websites · SaaS APIs

The authoritative content and live systems the application is allowed to use. Sources remain independent of whichever foundation model happens to serve a request.

Retrieval indexes

Embeddings · OpenSearch · pgvector · graph

Semantic, lexical and graph representations of enterprise knowledge, including metadata filters, source lineage and refresh timestamps.

Agent + MCP registry

Tool schemas · scopes · endpoints · versions

The typed contract for everything an agent can do. Tool discovery is filtered by tenant, user, task and risk rather than exposing a global toolbox to every model call.

Memory + state

Session · workflow · summaries · checkpoints

Durable state lets an agent resume safely, prevents repeated work and separates conversational context from operational workflow state.

Evaluation + governance

Golden sets · policies · audit · feedback · budgets

Defines what good looks like and whether the system is improving. Quality, safety, latency and cost are platform metrics, not anecdotes from a demo.
Happy-path sequence
01Request
02Auth
04Route
06Retrieve
08Assemble
09Select
10Reason
11Plan
12Tool
13Approve
14Act
15Guard
16Observe
17Persist
Fast failure

Invalid input, missing permissions and blocked requests fail before costly inference.

Recoverable execution

Retries, model fallbacks, idempotent tools and checkpoints turn failures into states, not mysteries.

Measurable production

Every answer and action carries evidence: sources, trace, quality, latency, cost and policy decisions.

How I would start

One production loop, then scale.

The fastest way to de-risk an enterprise AI build is to prove one thin, real path through the stack and harden it before multiplying agents and use cases.

  1. 01

    Map the production path

    Confirm the user workflow, knowledge sources, Bedrock model/agent boundary, retrieval path, security controls, deployment target and measurable acceptance criteria.

  2. 02

    Ship one vertical slice

    Build one real end-to-end path: ingest → retrieve → reason → tool action → API response → trace/evaluation, with a human review gate where risk requires it.

  3. 03

    Harden the system

    Add evals, failure modes, retries, IAM boundaries, monitoring, latency/cost budgets, container deployment and runbook-level operational evidence.

  4. 04

    Scale the pattern

    Turn the first production slice into reusable agent, retrieval and API components that the wider engineering team can own and extend.

The architecture instinct

Keep the agent clever. Keep the system boring.

The model can be probabilistic. Identity, permissions, retrieval boundaries, schemas, deployment, logs, cost ceilings and rollback paths should not be.

Grounding

Retrieval quality, source provenance, chunking, embeddings and evaluation before prompt theatre.

Agent control

Typed tools, explicit state, bounded autonomy, approval gates and recoverable execution paths.

Service boundary

FastAPI contracts, testable components and clean integration into existing engineering workflows.

Operations

IAM, observability, latency/cost budgets, incident evidence and a runbook the client can own.

Questions I would ask

Five questions that reveal the real job.

  1. 01

    Is Bedrock being used primarily for model access, Knowledge Bases, Agents/AgentCore, Guardrails, or a custom orchestration layer?

  2. 02

    What is already live today: a prototype, an internal production service, or a customer-facing workload?

  3. 03

    Which retrieval stack is in place — OpenSearch, pgvector or another vector store — and where is evaluation currently weakest?

  4. 04

    Is the target runtime ECS, EKS or mixed serverless/container infrastructure, and who owns the platform layer?

  5. 05

    What would make the first 30 days an obvious success for the end client?

Bottom line

Strong fit for the work that turns AI into a production system.

The overlap is strongest around agentic architecture, RAG, MCP, Python/FastAPI, production engineering and enterprise delivery. The next useful conversation is the client architecture itself: what is live, what is fragile, and what must ship first.

Full CV Contact Mat
Roll the dice