Bratha

Part 7.0 — The Agentic AI Framework

7 min read

This is Part 7 of 7 in the Productivity Enhancement Series

Table of Contents

Why the top of the stack is an agent

Everything below this layer made you more productive. This layer makes a worker productive on your behalf. But the same warning as Part 1.0 applies hardest here: an agent on top of chaos just produces chaos faster. You hand an agent a process that’s already solid, documented in instructions, and pointed at organised knowledge. This article is the mental model for what an AI agent actually is: a pipeline of six stages. Understand the pipeline and the whole “AI agent” buzzword collapses into something concrete you can reason about.

The pipeline

An agent isn’t one thing; it’s a chain. Each stage adds one capability the stage before it lacked, and together they turn a text generator into a worker.

flowchart LR
    A[Model] --> B[Tooling]
    B --> C[Protocol]
    C --> D[Agentic Layer]
    D --> E[Context]
    E --> F[Harness]
    D -. loop .-> D

==Read it as a sentence: a model is given tools, reached through a protocol, run in a loop (the agentic layer), fed context each pass, all hosted inside a harness.== That sentence describes how advanced assistants operate today. Now each stage.

Model: the foundation

The foundation is the LLM: the large language model. On its own it does one thing, predict text, and that sounds limited until you notice the move that changes everything: ==text can be action.== “Send the email,” written as a structured instruction, is just text, but text that a piece of code can read and execute. So the model’s words become the trigger for things happening in the world. The model is the brain; everything after it is how the brain reaches its hands.

Tooling: words become actions

A brain with no hands is a commentator. Tooling (often called function calling) gives the model the ability to execute specific functions: search the web, read a file, query a database, send a message. You define a set of tools, and the model can choose to call one and use the result.

This is the Operating System idea pointed at the agent: the tools you’d build for yourself (the supplement forecaster, the calendar, the email triage) become the tools the agent can operate. ==The model decides what to do; the tools are how it actually does it.==

Protocol: how the model talks to tools

To call a tool, the model and the tool need a shared language: a standardised way to say “here’s the function, here are the arguments, here’s the result.” That standard is a protocol. This is exactly where MCP (the Model Context Protocol) fits: it standardises how models connect to external tools and data, so any tool that speaks MCP can be plugged into any model that speaks MCP.1

The reason a protocol matters is the same reason USB mattered: without a standard, every tool needs a custom integration; with one, tools become plug-and-play. This is what turned “AI that can use one or two hard-coded tools” into “AI you can connect to your whole stack.”

Agentic Layer: the loop

Here’s the stage that earns the word agentic. A single tool call is not an agent; it’s a one-shot. An agent runs in a loop:

The agentic loop

Run (take an action) → Evaluate (did it work? what came back?) → Observe / adjust (decide the next action) → run again.

The model acts, looks at the result, and decides what to do next, repeatedly, until the task is done. This continuous feedback loop is the whole difference between a chatbot that answers once and an agent that works a task to completion. It’s the same shape as the Execute step in your own workflow (do, check, adjust), just running automatically. The loop is why an agent can handle a multi-step job: it doesn’t need the whole plan up front, it figures out the next move from the last result.

Context: better decisions each pass

A loop running blind makes poor choices. The fix is context: dynamic information injected into the model between loop iterations so each decision is better-informed. The current state of the task, the relevant files, what happened last step, your standing preferences.

This is the payoff of the self-improving workflow from Part 3, scaled up. Your skills.md and project instructions are context. Your PARA knowledge and maps, reachable via RAG, are context. The better the context you've built in the lower layers, the better every decision the agent makes. Most of the difference between an agent that’s useful and one that’s useless is not the model; it’s the quality of context it’s given. This is why the whole series came before this article.

Harness: where it all runs

The five stages above describe an agent’s anatomy. The harness is its body and home: the runtime environment that hosts the pipeline, holds its files, gives it compute, and lets you start, schedule, and manage its work. A chat window is the smallest possible harness. A dedicated computer or VPS running an agent 24/7 is the largest.

==The harness is the difference between an agent you talk to and an agent that lives somewhere and works.== Systems that host agentic workflows (whatever the brand) are all, underneath, a harness wrapping this pipeline. That spectrum, from a chat box to a full always-on machine, is important enough to get its own article: Part 7.1.

Part 7 Takeaways

  • An “AI agent” is not one thing; it’s a pipeline: Model → Tooling → Protocol → Agentic Layer → Context → Harness.
  • Model: an LLM whose text becomes action. Tooling: the functions it can execute, your OS tools handed to the agent.
  • Protocol (e.g. MCP) is the standard language between model and tools, turning custom integrations into plug-and-play.
  • Agentic Layer is the loop (run → evaluate → adjust), the thing that makes it an agent and not a one-shot chatbot.
  • Context injected each pass is where your instructions and knowledge pay off. Most of an agent's quality is context quality, not model choice.
  • The Harness is where it runs, from a chat box to an always-on machine (Part 7.1). And an agent on chaos just makes chaos faster, so build the lower layers first.

Your Agentic AI Task List

This week

  • Name one repeatable process you’d hand to an agent. Check honestly that it’s already documented and points at organised knowledge.
  • Connect one real tool to your assistant via a protocol (an MCP connector for your email, calendar, or files) and watch it run a tool call.
  • Give it a small multi-step task and watch the loop: run, check the result, decide the next step.
  • Improve its context: feed it the relevant instructions and knowledge, and notice the jump in decision quality.
  • Read Part 7.1 to decide which level of harness your task actually needs.

Sources & references

Footnotes

  1. The Model Context Protocol (MCP), introduced by Anthropic in late 2024, is an open standard for connecting AI models to external tools and data sources, so a tool built once can be used by any MCP-compatible model. It occupies the “Protocol” stage of the pipeline: the standardised channel through which a model’s tool calls reach real functions. Function calling / tool use is the underlying model capability the protocol coordinates. ↩

Graph View

Backlinks