Agentic AI Architecture for Enterprise Systems
I design and evaluate agentic AI systems for enterprises — multi-agent orchestration, Model Context Protocol (MCP) integrations, agentic RAG, and on-device architectures — as a generative AI consultant grounded in applied research, not vendor slideware. Based in Sri Lanka, available for remote engagements with enterprises in the US, UK, and Australia.
What I Design
- Planning and orchestration — multi-agent handoff logic, task decomposition, and deciding when an agent should defer to a human or a deterministic system instead of acting on its own.
- Tool access via Model Context Protocol (MCP) — connecting agents to internal databases, APIs, and tools without exposing raw credentials.
- Agentic RAG — retrieval that can re-query, verify, and route to a specialized sub-agent, rather than a single-shot lookup.
- Guardrails — permission scopes, approval gates, and human-in-the-loop checkpoints before an agent takes an irreversible action.
Where Agents Are the Right Tool (and Where They're Not)
Good fit
Multi-step tasks with ambiguous inputs, tool use across several systems, and work that benefits from self-correction — re-querying, verifying, or escalating when the first attempt falls short.
Poor fit
Deterministic processes with a fixed set of steps, and high-stakes actions — financial, safety, legal — that need a guaranteed, auditable decision path rather than autonomous judgment.
Reference Architecture
The specific tools change by engagement, but the layers I design against stay the same:
Request & Policy Layer
User or system request intake, identity, and authorization — what this caller is allowed to ask for before an agent gets involved.
Orchestration Layer
Planning, task decomposition, and multi-agent handoff logic — deciding what needs to happen, in what order, and which agent (or human) owns each step.
Tool & Data Layer
Model Context Protocol (MCP) servers, internal APIs, and databases — the agent discovers what it can touch and calls it without exposing raw credentials.
Retrieval & Model Layer
Agentic RAG over a vector store, plus the local or hosted language model generating and verifying each step.
Evaluation & Observability Layer
Tracing, groundedness checks, audit logs, and human review before anything ships to production.
Reliability & Safety
- Permission scopes limiting what each tool call can touch
- Approval gates before irreversible actions — sends, deletes, financial transactions
- Timeouts and budget controls to prevent runaway agent loops
- Audit logs for every tool call and decision
- Defenses against prompt injection at the tool and data boundary
- Rollback and escalation paths when an agent gets it wrong
Architecture Choices
Single agent vs. multi-agent
Start single-agent unless the task genuinely requires specialized sub-agents — multi-agent orchestration adds coordination overhead that only pays off when the division of labor is real.
Hosted vs. on-device inference
Data sensitivity and latency requirements should drive this choice, not a default preference for either side.
Agentic RAG vs. standard RAG
Use agentic RAG when retrieval genuinely needs to be re-queried, verified, or routed — not as an automatic upgrade over a working single-pass retrieval pipeline.
Framework choice
Evaluate lock-in before committing to one orchestration framework — the right tool depends on the team maintaining it as much as the problem being solved.
Selected Work
EdgeTal — On-Device Agentic RAG for Privacy-Preserving Talent Discovery
An agentic RAG system that runs entirely on-device — local vector retrieval, a quantized language model, and an orchestration layer that plans multi-step talent-discovery queries without a single byte of candidate data leaving the device. 0.88 mAP in retrieval matching, 3.2 second average end-to-end query latency on commodity hardware. Presented at EICON 2026 (ESOFT International Conference), Kandy — awarded Best Poster Presenter.
Read the full case study →The same architectural patterns — multi-agent orchestration, Model Context Protocol (MCP) tool integration, and agentic RAG — carry over into client engagements through Agentic AI & Retrieval Systems and Enterprise AI Integration & Multi-Agent Systems.
Two areas get deeper, dedicated treatment: Agentic AI Security & Governance (scoped permissions, approval gates, containment) and MCP Integration & Security (production-grade Model Context Protocol server design and session scoping).
How I Evaluate Agentic Systems
A demo that works once is not the same as a system ready for production. Before anything ships, I check:
- Task success rate on a held-out test set
- Groundedness checks against retrieved sources
- Data leakage testing — does the agent expose data it shouldn't
- Latency and cost per query
- Replay testing against past failure cases
- Human review before production rollout
Frequently Asked Questions
What does an Agentic AI Architect do?
An Agentic AI Architect designs systems where AI agents plan, call tools, and act across multiple steps rather than answering a single prompt. That means defining orchestration logic, tool access through protocols like Model Context Protocol (MCP), retrieval strategy, and the guardrails that decide when an agent acts autonomously versus when it defers to a human.
How is agentic AI architecture different from a standard generative AI integration?
A standard GenAI integration calls a model once and returns its output. Agentic architecture adds a decision loop: the system can re-query, verify its own retrieval, call external tools, or route to a specialized sub-agent when the first attempt isn't good enough, with explicit stopping conditions.
When should a business use autonomous agents instead of a simple script or chatbot?
Agents earn their complexity when a task has ambiguous inputs, requires tool use across multiple systems, or benefits from self-correction. A fixed, auditable workflow is usually the better choice for deterministic processes or high-stakes actions that need a guaranteed decision path.
What is Model Context Protocol (MCP) and why does it matter for agent architecture?
Model Context Protocol (MCP) is an open standard for connecting AI agents to external tools, databases, and APIs without exposing raw credentials. It lets an agent discover what it's allowed to touch and call it safely, which is the difference between a demo and a production-ready integration.
How do you evaluate whether an agentic AI prototype is ready for production?
Task success rate on a held-out test set, groundedness checks against retrieved sources, data leakage testing, latency and cost per query, and replay testing against past failure cases. A prototype that passes a demo but hasn't been evaluated this way isn't production-ready yet.
Engagement Types
- Architecture advisory and review
- Agentic system prototyping and MCP implementation
- Production build and deployment support
- Applied research partnership