Building an MCP server over an existing internal API - SkilBrill

AI Agent Development Training Building an MCP server over an existing internal API

AI Agent Development Training

0% Completed

M1 — What Makes Something an Agent

Agent versus workflow: the decision that saves you a rebuild

The reasoning loop: observe, plan, act, then observe again

Why unbounded loops are the default failure of first agents

State: what the agent knows between steps and where it is held

Tools as the only way an agent touches the real world

Where agents fail and a deterministic workflow would have succeeded

M2 — Tool Design and Function Calling

Defining tools with schemas a model can actually choose between

Naming and describing tools so selection is reliable

Validating arguments before execution and rejecting the rest

Idempotency, retries and what happens when a tool half-succeeds

Returning results the model can read without being misled

Sandboxing dangerous actions behind a human confirmation

M3 — Planning, Control and Termination

Planning strategies: fixed plan, replan every step, or plan once

Step limits, token budgets and time budgets as hard stops

Loop detection: recognising the agent is repeating itself

Subgoals and decomposition for long-running tasks

When to hand back to a person instead of guessing again

Recording the plan so a human can audit what was intended

M4 — Memory and Context Management

Working memory versus long-term memory and what belongs in each

Conversation history, summarisation and truncation that hurts

Persistent memory: notes, facts and the retrieval that serves them

Contamination: how one bad observation poisons later steps

Scoping memory per user, per task and per tenant

Forgetting on purpose: retention, redaction and deletion

M5 — Multi-Agent Orchestration

When one agent should be three, and when that is a mistake

Roles: planner, researcher, critic, executor and the boundaries

Message passing, shared state and handoff contracts

Supervisor patterns and hierarchical control

Contention, duplicated work and deadlock between agents

Cost control when several models are calling each other

M6 — Protocol, Integration and Context Servers

The Model Context Protocol and why a standard tool layer matters

Building an MCP server over an existing internal API

Resources, prompts and tools as protocol primitives

Authentication and permission boundaries on a context server

Connecting agents to documents, databases and ticketing systems

Versioning a server that several agents depend on

M7 — Reliability, Evaluation and Observability

Evaluating task success instead of grading a single response

Building an agent test set with expected tool sequences

Traces: which step decided the outcome and why

Guardrails on inputs, outputs and tool permissions

Cost, latency and token burn per completed task

Shadow running an agent beside the existing process

M8 — Capstone

Choose a task and justify an agent over a deterministic workflow

Design the tools with validated schemas and a dangerous-action gate

Build the reasoning loop with step, token and time budgets

Add memory with scoping, summarisation and a redaction policy

Expose the internal API through a Model Context Protocol server

Ship with a trace dashboard, eval suite, approval gate and runbook

Announcements Course Info