DEV Community

Naimul Karim
Naimul Karim

Posted on

AI Agentic Workflow Explained: A Quick Tour of Harness, Tools, Skills, MCP, and Memory

#agents #ai #architecture #llm

AI applications are moving beyond simple chat experiences.

The next generation of AI systems are AI agents — systems that can understand goals, reason about problems, use external tools, access enterprise data, and complete multi-step workflows.

However, an AI agent is not just a Large Language Model (LLM) with a prompt.

A production AI agent is a combination of multiple components working together:

AI Agent
   |
   +-- Model
   |
   +-- Harness
   |
   +-- Tools
   |
   +-- MCP Integrations
   |
   +-- AGENTS.md
   |
   +-- Skills
   |
   +-- Memory
Enter fullscreen mode Exit fullscreen mode

The model provides intelligence and reasoning.

The surrounding infrastructure provides the ability to take action reliably.

Understanding the AI Agent Workflow

A typical AI agent execution flow looks like this:

                    User Request
                         |
                         v
                  Agent Harness
                         |
        +----------------+----------------+
        |                                 |
        v                                 v
 Load Always-On Context          Understand Task
        |                                 |
        |                                 v
        |                         Select Relevant Skills
        |                                 |
        |                                 v
        +------------------------ Load Skill Context
                         |
                         v
                 Retrieve Memory
                         |
                         v
              Discover Tools via MCP
                         |
                         v
                  Agent Reasoning
                         |
                         v
                  Execute Actions
                         |
                         v
              Observe Tool Results
                         |
                         v
              Update Context/Memory
                         |
                         v
                  Task Completed
Enter fullscreen mode Exit fullscreen mode

At the core of this workflow is a continuous loop:

Reason → Act → Observe → Repeat
Enter fullscreen mode Exit fullscreen mode

The model decides what should happen next.

The agent infrastructure makes those decisions actionable.

1. Agent Harness: The Runtime Behind the Agent

The AI Agent Harness is the execution layer that surrounds the model.

It manages:

  • Task execution
  • Context assembly
  • Tool access
  • Skill loading
  • Memory retrieval
  • Security policies
  • Observability

A useful analogy:

The model is the brain. The harness is the environment that allows the brain to interact with the world.

For example:

User request:

"Find customers who have not logged in for 90 days and send them a reminder email."

The model reasons:

"I need customer activity data and an email capability."

The harness handles:

  1. Loading relevant capabilities
  2. Accessing customer data
  3. Generating email content
  4. Applying approval rules
  5. Sending the communication

The harness connects reasoning with execution.

2. Tools: Giving Agents the Ability to Act

Tools provide agents with the ability to interact with external systems.

Examples:

  • APIs
  • Databases
  • Search engines
  • Code execution environments
  • File systems
  • Business applications

Without tools, an LLM can only provide recommendations.

With tools, an agent can perform actions.

Example:

The model decides:

"I need customer information.
I will query the database."
Enter fullscreen mode Exit fullscreen mode

The harness executes:

SELECT *
FROM customers
WHERE last_login < CURRENT_DATE - INTERVAL '90 days';
Enter fullscreen mode Exit fullscreen mode

The result is returned to the model.

This creates the agent loop:

Reason → Tool Call → Result → Reason Again
Enter fullscreen mode Exit fullscreen mode

3. Model Context Protocol (MCP): Standardizing Tool Connections

As agents become more capable, they need access to many external systems.

Managing custom integrations for every application does not scale.

This is where Model Context Protocol (MCP) becomes important.

MCP provides a standard way for AI applications to connect with external tools and data sources.

Without MCP:

Agent

 ├── Custom Database Connector
 ├── Custom File Connector
 ├── Custom API Connector
 └── Custom Search Connector
Enter fullscreen mode Exit fullscreen mode

With MCP:

Agent

       |
  MCP Client

       |
 -------------------------
 |          |             |
Database   Files        APIs
MCP        MCP          MCP
Server     Server       Server
Enter fullscreen mode Exit fullscreen mode

An MCP server can expose capabilities:

search_customers()

get_customer_orders()

update_customer_record()
Enter fullscreen mode Exit fullscreen mode

MCP separates:

  • Agent reasoning
  • Tool implementation
  • Enterprise system access

4. AGENTS.md: The Agent's Always-Loaded Instructions

As agent systems grow, context management becomes critical.

Not every instruction should be loaded for every task.

AGENTS.md provides the agent with its always-available operating instructions.

It defines the baseline rules for how an agent should work.

Typical contents include:

  • Project conventions
  • Coding standards
  • Security rules
  • Repository guidelines
  • Environment instructions
  • Common workflows

Example:

project/

├── AGENTS.md
├── src/
├── tests/
└── skills/
Enter fullscreen mode Exit fullscreen mode

Example AGENTS.md:

# Agent Instructions

## Project Rules

- Follow coding standards
- Run tests before committing changes
- Never expose secrets
- Update documentation when required

## Development Workflow

1. Understand the requirement
2. Inspect existing code
3. Implement changes
4. Validate results
5. Provide a summary
Enter fullscreen mode Exit fullscreen mode

Because AGENTS.md is always included in the context, it should contain only essential instructions.

A large AGENTS.md increases context usage and can reduce agent effectiveness.

5. Skills: Dynamic Agent Capabilities

Skills provide specialized knowledge and workflows that are loaded only when relevant.

Unlike AGENTS.md, skills are not always included in the context.

They are selected dynamically based on the task.

Examples:

  • Database migration skill
  • Security review skill
  • Frontend development skill
  • Documentation skill

Example structure:

skills/

├── database-migration/
│   └── SKILL.md
│
├── security-review/
│   └── SKILL.md
│
└── api-development/
    └── SKILL.md
Enter fullscreen mode Exit fullscreen mode

Example SKILL.md:

# Database Migration Skill

## Purpose

Safely modify database schemas.

## Workflow

1. Analyze schema changes
2. Create migration scripts
3. Validate compatibility
4. Run migration tests
5. Review rollback strategy
Enter fullscreen mode Exit fullscreen mode

The harness loads this skill only when a database migration task appears.

AGENTS.md vs Skills: Why Both Matter

A common mistake is putting every instruction into AGENTS.md.

Example:

AGENTS.md

- Coding rules
- Database procedures
- Deployment workflows
- Security reviews
- Testing strategies
- Documentation rules
Enter fullscreen mode Exit fullscreen mode

Over time, this file becomes too large.

The agent receives unnecessary information for every task.

A better approach:

AGENTS.md

Always loaded:
- Core rules
- Project conventions
- Security requirements


Skills

Loaded when needed:
- Database workflows
- Deployment procedures
- Security analysis
- API patterns
Enter fullscreen mode Exit fullscreen mode

The goal is not maximum information.

The goal is the right information at the right time.

6. Memory: Giving Agents Continuity

LLMs are stateless by default.

Without memory, every interaction starts from zero.

Agent memory usually has multiple layers.

Short-Term Memory

Current conversation context.

Example:

User:
"My order arrived damaged."

Agent remembers:

- Order details
- Previous messages
- Current issue
Enter fullscreen mode Exit fullscreen mode

Working Memory

Temporary information needed during execution.

Example:

Research Task:

Files analyzed:

- sales_report.csv
- customer_feedback.json
- product_notes.md
Enter fullscreen mode Exit fullscreen mode

Long-Term Memory

Information retained across sessions.

Example:

{
  "user_preferences": {
    "communication": "email",
    "language": "English"
  }
}
Enter fullscreen mode Exit fullscreen mode

Memory allows agents to become more personalized and effective.

Complete AI Agent Workflow Example

Consider a software engineering agent.

User request:

"Fix the failing payment API tests."

Step 1: Load Agent Instructions

The harness loads:

AGENTS.md

- Coding standards
- Repository rules
- Security policies
Enter fullscreen mode Exit fullscreen mode

Step 2: Load Relevant Skills

The harness identifies the task and loads:

software-engineering-skill/

├── SKILL.md
├── coding-guidelines.md
└── testing-workflow.md
Enter fullscreen mode Exit fullscreen mode

Step 3: Retrieve Memory

The agent recalls:

Previous changes:

- Payment API migration completed
- Database schema updated
- Authentication tests modified
Enter fullscreen mode Exit fullscreen mode

Step 4: Discover Tools Through MCP

The agent accesses:

MCP Servers:

- Git repository
- CI/CD system
- Test runner
- Issue tracker
Enter fullscreen mode Exit fullscreen mode

Step 5: Execute the Task

Actions:

1. Analyze failing tests
2. Inspect source code
3. Modify implementation
4. Run tests
5. Review results
Enter fullscreen mode Exit fullscreen mode

Step 6: Verify and Complete

The harness validates:

  • Tests pass
  • Policies are followed
  • No restricted actions occurred

The agent delivers the result.

Why Agentic Workflows Matter

Building AI agents is no longer only about choosing a powerful model.

Reliable agents require:

Component Purpose
Harness Runs and coordinates the agent
Tools Enable external actions
MCP Standardizes integrations
AGENTS.md Provides always-on instructions
Skills Provide task-specific expertise
Memory Maintains context over time

The model provides intelligence.

The workflow around the model provides capability.

Final Thoughts

The future of AI applications will be built around agentic workflows.

Successful AI agents will combine:

  • Reasoning models
  • Execution harnesses
  • Tool ecosystems
  • MCP-based integrations
  • Dynamic skills
  • Context-aware memory

The biggest shift is moving from:

"How do we prompt the model?"

to:

"How do we design the complete system around the model?"

That is the foundation of modern AI agent engineering.

Enter fullscreen mode Exit fullscreen mode

Top comments (0)