Skip to main content

Agentic AI standards

· 8 min read
Brad Taniguchi
Brad Taniguchi

I like standards, you should too. Especially when it comes to AI, which is still somewhat a wild west. Having some standardization helps with transferable patterns regardless of what agentic AI tool you are using.

Introduction​

First and foremost I want to define the term "agentic AI", as this post will be entirely targeted around what this term means, and how it's used. I'll also exclusively use the term "AI" to refer to LLM powered AI systems, at least in regards to those used by developers.

info

Agentic AI are AI agents that can perform a task by themselves, autonomously.

Broadly, most AI agents developers use today are "agentic" with different levels of autonomy. Earlier versions of AI would provide suggestions, but aren't able to write code themselves without developer acceptance. However, today with tools such as Cursor and Claude Code, developers can just write a prompt and these AI tools will go off and perform any number of writes/reads/tool-calls/etc. to accomplish the task.

With all these different agents, and ways to define and do things, some standards have come about that help developers define some guardrails and capabilities for these agents to leverage, without defining the same things over for each type of tool.

AI Standards​

I'll go over 3 standards I know of, listed in order of how much they are currently supported by common industry standards to different degrees.

Broadly speaking a lot of tools that don't support these standards, already have some internal form of these standards, hence why these standards came about, there's a similar need for them.

  • MCP (Model Context Protocol) - "MCP (Model Context Protocol) is an open-source standard for connecting AI applications to external systems."
  • AGENTS.md - "A simple, open format for guiding coding agents. Think of AGENTS.md as a README for agents: a dedicated, predictable place to provide the context and instructions to help AI coding agents work on your project."
  • Agent Skills - "A simple, open format for giving agents new capabilities and expertise. Agent Skills are folders of instructions, scripts, and resources that agents can discover and use to do things more accurately and efficiently."

MCP (Model-Context-Protocol)​

MCPs are a standard created by Anthropic back in 2024 (ref), for ways for AI to interact with tool calls. The term "MCP" is both the name of the standard, and the name of the "server" that provides the actual tool the AI agent can interact with. The standard defines how the tool provides information to the AI agent so the AI agent can decide when to use the tool and how to use it.

Examples would include:

MCPs are largely how you currently change how an AI agent interacts with the world beyond the context already given. Day to day you could automate tasks such as creating issues, managing cloud resources, or querying databases all using the same "interface" of the agent.

However, MCPs come with a few core drawbacks:

  • Due to how the standard works, the tool calls each populate the context, so the AI agent will always know about them, and knowing about them takes up the working context or memory that the AI agent can use. This could confuse the agent, or at a minimum increase costs due to more context being used even when not relevant.
  • MCPs largely interact with external APIs, which requires their own auth. The standard has no defined way to handle auth, so each MCP server implementation has to define its own workflow (often API keys) for handling auth.
  • Because of these API keys, there isn't a transferable standard or format for sharing MCP servers, each developer has to set up their own settings.
  • MCPs are largely a core attack vector, as like any tool call they can be used as a way to gather information, or perform prompt injections.
  • How and where you define your MCP servers is also not standardized, so each tool has its own configuration format. Largely using a JSON settings file, but again I don't believe this is standard, and only a convention.

Even with these drawbacks, as a developer it's hard to get away from MCP tools, as even a few core ones can greatly increase productivity. But don't give it write access to the DB!

AGENTS.md​

AGENTS.md is a standard created in 2025 by a "collection of industry efforts", so it's relatively new. But it solves a core/common problem almost all AI coding agents have required. Which is automatically provide some context to all prompts. As stated in the site description, AGENTS.md can be thought of as the README of a project, but for AI agents.

Practically this means defining a file named AGENTS.md in the root of your project, that contains specific sections that the AI agent can read to understand how to work on the project.

Here's a snippet example from the AGENTS.md file, of the blog/site you are reading right now:

<!-- ... -->

File used for AI agents documentation. Each subsection provides examples and descriptions for different common tasks.

## Architecture and Technologies used

Uses Docusaurus@3 for static site generation, React for UI components, Markdown and MDX for content and typescript for any React/node code. Runtime for development is node@24 and deployment is through GitHub pages.

## Folder structure

- `blog` has `md` and `mdx` files for blog posts.
- `src` has all css, React and typescript code.
- `static` has all static assets deployed with the rest of the site.

## Scripts

- `npm run build` - script to build the static website.
<!-- ... -->

I've gotten some mixed signals about what you put into AGENTS.md and what you don't. Practically you shouldn't put too much, as it's always provided to the agent as context every time, so you want to only put in things that are always relevant.

Agent Skills​

Agent skills is a new standard, to the point most AI tools don't support it out of the box, but it's a standard that mixes aspects of both MCP and AGENTS.md together. They primarily allow you to define complex workflows and capabilities within markdown files, but are more lightweight compared to MCP calls.

A skill is defined within a folder structure at the root of a project:

.skills/<skill-name>/

where the skill name of the folder will correspond with the "skill name" in a markdown file named SKILL.md within that folder, so if I had to define a skill named "code-review", I would create the following structure:

.skills/code-review/SKILL.md

Within the SKILL.md file, you define a frontmatter section with the properties name and description, where the name corresponds to the folder name, and the description is a short description of what the skill does. Critically these two properties are the only properties the AI agent "sees" in its context at all times, hence the lightweight nature relative to an MCP server definition.

Within the actual SKILL file you can define whatever you want to give to the agent, when it determines to use the tool call.

So for example here's the skill I have defined within this project to help create boilerplate code for new blog posts:

---
name: create-or-edit-blog-post
description: Use this skill when the user wants to create or update Docusaurus blog posts.
---

# Create New Blog Post Skill

This skill helps create boilerplate for new Docusaurus blog posts.

## Quick Reference

### File Naming Conventions

Blog posts in the `blog/` directory should follow the following naming conventions and folder structure:

- `YYYY/MM-DD-title.md` - Date-prefixed filename
<!-- ... -->

This standard is still new, so I haven't been able to leverage it. Most AI systems have a similar capability, or at a minimum you can just directly reference a file directly for extra context, as almost all AI agents have the ability to read a file and thus add its content to the context.

Conclusion​

So in review, MCPs are the "tool call" standard, and AGENTS and Agent Skills are ways to provide more context either all the time or situational to agents.

Hopefully that sheds some light on AI standards, as I know them and use them.

This post is also the first one I've written specifically to help me review and gather references for things I know about but want to drill down a bit more. Day to day I use these tools multiple times, but writing it down and shipping it out on this blog is one of the main goals I have for this year. So hopefully this won't be the last post like this. As a taste of what I have in mind for the next part, I'll probably write another AI oriented post around how I use AI specifically for this blog itself. Again I don't use it for writing these posts (hopefully you can tell... for better or worse haha), but I do use it elsewhere.

Until next time, keep learning, keep growing and keep asking questions!