The AI Standards Are Here. Build Your Future on the Right Foundation.

Picture this. You’re about to sign for a new AI tool. The demo was slick. The salesperson swears it’ll transform your firm. Then six months later a better model ships, a sharper competitor launches, and the thing you bought is a dead end. You’re locked in. You’re starting over. Again.

Every professional services owner I talk to is living some version of this. The tech is moving faster than anyone can evaluate it. So the real question isn’t “which AI tool should I buy?” It’s “what do I build on so I’m not rebuilding every quarter?”

Good news. As of right now, a small set of open standards has stabilized. They’re the foundation. Get these right and the frontier models can keep racing ahead without breaking what you’ve built. Get them wrong and you’re remodeling the house every time the weather changes.

Let me walk you through the foundation, and the practical path to actually use it.

Start With the Lego Block

If you read my last piece, you know I’m bullish on “skills.” A skill packages one of your proven business processes, the tech to run it, and the know-how to do it right. You run it with a sentence. No developer required.

Here’s the part that matters for everything below. Skills are open and standardized. They’re the Lego block. Everything else snaps onto them.

That’s not a small detail. It means a skill your team builds today still works when you change AI platforms tomorrow. It works when you schedule it. It works when you hand it to an AI agent. One standard block, reused everywhere. That’s the whole game.

So before you think about agents or platforms or any of the shiny stuff, start with the block. Here’s the path.

Step 1: Use It Yourself

Take one process you run every week. Build it as a skill. Then use it personally for a couple of weeks.

This is the part people skip, and it’s the part that matters most. You’re not automating anything yet. You’re just proving the skill produces the quality you’d accept from your best person. Run it. Tune it. Get it right.

Once it’s solid, you’ve got a reusable asset instead of a clever one-off prompt.

Step 2: Schedule It

Now make it run on its own. Hourly. Daily. Weekly. Whatever fits.

This is where the value starts compounding, because the work happens whether you’re thinking about it or not. A few real examples:

• Market research that lands in your inbox every Monday morning, already structured.
• A watch on a key prospect’s social profile that pings you the moment something changes, so you reach out with perfect timing.
• A quiet automation that moves data between two systems you already pay for, so nobody’s copying and pasting between them anymore.

Same Lego block. You just told it when to run. The skill did the work. You got the output.

Step 3: String Skills Together Into a Workflow

One skill is useful. Skills working together are where it gets serious. And there’s a right way to stack them.

Think in layers, like you’d onboard a sharp new hire.

The base layer connects to your systems of record. Your CRM, your project management, your files. This is where MCP lives, which I’ll come back to.

The next layer up is your business rules. A new employee doesn’t just get handed your CRM. You teach them how your firm uses it. Which fields matter. Which ones you never touch. What goes where, and why. That know-how is its own layer of skills. It’s the difference between a tool that technically works and one that works the way your firm works.

On top of that sit the skills that actually do the job. They lean on the layers below, so they don’t have to reinvent how your systems or your rules work.

Here’s what that looks like in my world. I build a lot of speaking sessions and workshops. The workflow is a chain of skills:

First, brainstorm and research. That’s a feedback loop. A couple of skills research the topic, pressure-test it against my ideal audience, and help me tune it.

Next, crunch it down into a proposed structure and outline for the session.

Then, generate the full markdown spec for the presentation. Every slide. What’s on screen, what custom graphics get made, the speaker notes.

Then the presentation builds itself. The generator calls both Gemini and OpenAI to create custom images, and assembles the deck from a style guide. And here’s the part I love: after the images are generated, the system re-reads every single one to check the text is perfect, there’s no AI goo, the alignment makes sense, and it’s all readable. Fully automated quality control.

That’s a series of skills doing one real job. Notice I’m still in the driver’s seat. I kick it off. I review it. It’s not running on its own yet. That’s the next step.

Step 4: Load Skills Into an Agent

Now we get to agents. An agent is a bundle of skills that functions like a team member.

You talk to it the way you’d talk to a colleague. Slack. Teams. Text message. Whatever communication channel your firm already lives in.

The difference from Step 3 is that the agent runs on its own. It reacts to triggers and stimuli. It does things proactively. And it can hold a goal.

Goal-based behavior is the part that feels like the future. An example: give an agent the standing goal of keeping your pipeline warm. It watches for signals. A prospect changes jobs. A target account raises funding. A contract’s renewal date is approaching. The agent notices, drafts the right outreach, and drops it in your queue for a quick yes. You didn’t ask. It was watching, because that’s the goal you gave it.

That’s a team member, not a tool. And it’s built from the same Lego blocks you started with in Step 1.

The Most Important Part: Who Builds the Skill

Here’s the thing most firms get backwards.

The person who builds the skill should be the expert in the business process. Not the tech geek.

The salesperson who knows how to land an incredible proposal. The finance lead who knows exactly which metrics actually matter. They’re the ones who should be building these. The tech folks support the process, and that’s valuable. But the expertise has to come from the person who owns the work.

This is why it’s affordable now and why it’s yours to own. Your edge isn’t the AI. It’s your methodology, encoded by the people who actually understand it.

Now, The Foundation

Everything above runs on a handful of open standards. This is the foundation, and it’s why I’m telling you to pay attention now.

How it all works: tools connect to your agent through ACP, the agent runs your skills, MCP connects to your systems, and A2A connects your agents to other agents.

Skills are the first standard, the Lego block we’ve been talking about. Here are the other three. We’ll keep it light, but you need to know the names, because every system you evaluate should support all of them.

MCP: How Your Agent Talks to Your Systems

The Model Context Protocol is how an agent connects to your systems of record. Your CRM. Your project management. Your data. Your files.

Think of it as one standard plug that fits every tool. Before MCP, every connection was a custom integration. Now it’s a standard. The tools your firm already uses are starting to ship native support.

MCP: one standard plug that connects your agent to Pipedrive, Asana, Outlook, and your files.

Here’s a pattern worth noticing. MCP started as a developer thing. So did the coding tools it grew up in. Then it escaped the developer world and became a general standard used for things way beyond code. Keep that pattern in mind, because the next one is doing the same thing.

ACP: How Your Tools Call Your Agents

The Agent Client Protocol is how the tools you already work in call out to an agent.

This one’s earlier in its journey, and yes, it started on the developer side too. Coding platforms used it first, so a developer could call an agent to look something up in a reference doc without leaving their editor. Now it’s spreading. Obsidian, the advanced note-taking app that’s becoming a memory solution, can call agents through it. So can a growing list of editors and tools.

The direction is clear. ACP is becoming the standard for how we humans, inside the tools we already use, reach out and put an agent to work.

A2A: How Your Agents Talk to Each Other

Agent2Agent is the open standard for how agents talk to each other. How they discover one another. How they figure out what another agent can do and how to work with it.

Each agent publishes a kind of digital business card that says who it is and what it’s capable of. Other agents read it and know how to collaborate. Your sales agent can hand off to a finance agent. Your agent can work with a partner’s agent. No custom wiring.

A2A: agents discover and work with each other through standardized agent cards.

This is the newest of the four, but it’s the one that turns a pile of individual agents into a team that actually coordinates.

The Takeaway: Demand All Four

So here’s the bottom line for every owner reading this.

Any system you’re considering buying, and anything you’re considering building, needs to support all of these standards. Skills. MCP. ACP. A2A.

The frontier models and new tech are going to keep hitting us at an absurd pace. That’s not slowing down. You can’t bet your firm on guessing which model or which vendor wins. That’s a losing game, and you’ll be remodeling forever.

But these four standards have stabilized enough to build on. They’re the foundation that survives the churn above them. A skill you build today still works when the next model ships. An MCP connection still works when you switch platforms. That’s the whole point of a standard.

So when the next slick demo lands on your desk, ask one question before anything else: does it support the open standards? If the answer is no, you’re being sold a dead end. If the answer is yes, you’re building on rock instead of sand.

The tech will keep changing. Make sure your foundation doesn’t have to.

Take Action

Get practical, real-world AI insights. Connect with me on LinkedIn: https://www.linkedin.com/in/alexbratton

Dive into free AI courses to accelerate your journey: https://go.aiwhy.io/calendar

About the Author

Alex Bratton is the author of Practical AI for Leaders and Billion Dollar Apps, an adjunct professor of computer science, and the CEO & Chief Geek of Lextech, an Apple enterprise partner that applies cutting-edge tech to drive employee efficiency for teams through tech-powered experiences people love.

Alex is an applied technologist who leads Lextech’s AIWhy efforts to bring practical AI to the mid-market: https://aiwhy.io