← Back to Homepage

Sometimes the best solutions come from scratching your own itch. Robokeytags started as a simple internal utility at Robokeys, but evolved into something I believe could transform how we all work with code generation and AI.

The Beginning: A Codegen Problem

Like many developers, I was tired of writing boilerplate. So I built internal code generators using tools like Plop and custom scripts. But I kept hitting the same wall:

You could use markers like <!-- INSERT HERE -->, but every tool had its own syntax. Spring Boot generators used one pattern, our custom tools used another, and frontend scaffolding used something else entirely. It was chaos.

The First Insight: Universal Structure Markers

That's when I created the first version of what would become Robokeytags, to use at Robokeys. I used puzzle piece emoji (🧩) because:

• They're visual and hard to miss
• They represent how code pieces fit together
• They work in any language's comments
• They're just Unicode – no special tooling needed

The 🧩 tags became our universal language for code structure:

Suddenly, ALL our tools could understand the same structure. Plop knew where to insert. Our custom generators knew what to preserve. It was like giving all our tools the same map.

The Second Insight: Human Context Matters

As the system grew, we realized we needed a way to add human context that tools would respect but not process. Enter the 📌 (pin) tags:

These weren't instructions for tools – they were notes for humans. But crucially, tools knew to preserve them.

The Game Changer: AI Enters the Picture

Then came the AI coding boom. Suddenly, I'm working with Claude, GPT-4, and other assistants. And I realized: they had the same problem my code generators did, but worse.

AI assistants are incredibly powerful but have the memory of a goldfish. Every conversation starts fresh. They can't remember:

• What patterns they detected last time
• Which code sections they're uncertain about
• What they learned about your codebase

The Third Insight: AI Needs Persistent Memory

That's when I added the 🤖 (robot) tags – and everything clicked:

These tags let AI build understanding across sessions. It's like giving AI a notebook that doesn't disappear when you close the chat.

Imagine:

• A security-focused AI leaves notes about potential vulnerabilities
• A performance AI marks possible bottlenecks
• A refactoring AI suggests patterns
• A documentation AI identifies missing explanations
• Each agent builds on the others' insights

It's not just memory – it's asynchronous AI collaboration.

Why This Matters

What started as a simple codegen utility revealed a fundamental truth: all our tools need to speak the same language about code structure.

Whether it's:

• Plop generating components
• Spring Boot CLI scaffolding controllers
• AI assistants refactoring code
• Linters checking standards
• Humans understanding intent

They all need to understand what's structural (🧩), what's human context (📌), and what's machine memory (🤖).

But How Is This Different from API Protocols like MCP?

That’s a fair question for anyone familiar with the AI tooling space. Protocols like MCP are vital for a future of interoperable tools, but they solve a different problem. MCP is the language of explicit instruction—it’s for when you have a known workflow where one agent needs to tell another agent what to do via a direct API call.

RoboKeyTags is the language of shared state. It enables implicit, uncoupled collaboration where agents don’t need to know about each other at all. They simply observe and modify a shared environment—the code itself. While MCP is essential for the workflows of today, RoboKeyTags is designed for the emergent, autonomous, and multi-agent workflows of tomorrow. They are two sides of the same collaborative coin.

RoboKeyTags vs. Protocol Standards: A Practical Comparison

The world of AI-assisted coding is moving fast, with emerging standards seeking to define how tools and agents share context. Anthropic’s MCP (Model Context Protocol) is currently the most visible standard in this space; Google's A2A is another prominent example. These aim to let AI agents and tools exchange structured, machine-readable context for more portable and interoperable workflows.

However, MCP and A2A are not the only approaches—other organizations and communities are experimenting with formats and protocols for code structure and AI collaboration.

Robokeytags takes a different approach:

Instead of enforcing a formal protocol or rigid workflow, robokeytags implements a “blackboard” model:

Context, structure, and AI agent findings are embedded directly in your codebase, using simple, universal emoji markers within standard comments.

This makes robokeytags language-agnostic, instantly usable, and open—no vendor lock-in, no special tooling required, and no dependency on an emerging ecosystem or protocol.

Persistence and transparency are core: any human, tool, or AI can read or write to the shared “blackboard” at any time, even across different tools and environments.

By contrast, MCP is designed for formal agent-to-agent communication and workflow orchestration—enabling deep integration, but typically requiring buy-in, protocol alignment, and dedicated infrastructure.

Robokeytags complements protocol-based standards like MCP by providing a lightweight, persistent, and visible context layer:

It works immediately in any codebase and can bridge gaps where protocol adoption is incomplete or impractical.

It ensures context isn’t lost, regardless of the tools or agents in play.

If/when MCP or other protocol standards become widely adopted, robokeytags can serve as a persistent “backplane” or fallback for visibility and auditability.

These protocol-driven approaches are vital for the future, but they aren't the only way. RoboKeyTags takes a different, more immediate, and practical approach by focusing on the code itself.

Attribute	Protocol Standards (e.g., MCP, A2A)	RoboKeyTags
Primary Goal	Formal, real-time agent-to-agent communication.	Persistent, human- & machine-readable context in code.
Mechanism	API calls over a network protocol.	Universal markers (🧩🤖📌) in code comments.
Key Paradigm	Explicit Instruction (Agent A tells Agent B).	Shared State (Agents observe the code's state).
Dependency	Requires buy-in, infrastructure & protocol alignment.	None. Works instantly wherever Unicode comments work.
Best For	Orchestrating known, structured workflows.	Emergent collaboration, AI memory & human visibility.

In summary:

Robokeytags is ideal if you need a practical, open, and persistent way to embed shared context in your code—today. It can coexist with, and even enhance, protocol-driven workflows as the standards landscape matures.

Future-Proofing Your Codebase in a Multi-Protocol World

The world of AI collaboration is new, and it's unlikely that a single communication standard will win out immediately. The future is more likely a mix of coexisting protocols. One team might use agents that speak MCP, while another adopts A2A.

While these standards may one day interoperate directly, it's just as likely that a completely different, specialized agent framework will emerge that understands neither.

This is where RoboKeyTags provides its most critical, long-term value: acting as a durable, protocol-agnostic data layer.

Protocols define how agents talk, which can change year to year. RoboKeyTags define what agents know, embedding that context directly into the most durable asset you have: your source code. By using simple, universal text comments, RoboKeyTags ensure that context can be read by:

• An MCP agent today.
• An A2A agent tomorrow.
• A future tool that hasn't even been invented yet.
• A human developer, five years from now, trying to understand what happened.

This makes RoboKeyTags a powerful hedge against technological churn. It creates a persistent, auditable "archival layer" of context that outlives any specific API or communication trend, ensuring your codebase remains intelligent and understandable for whatever comes next.

The Decision to Open Source

I could have kept Robokeytags as an internal Robokeys tool. But the more I used it, the more I realized this problem is universal. Every developer using code generation or AI faces these same challenges.

The 🤖 tags especially felt too important to keep private. They could fundamentally change how AI assistants work with code – from stateless helpers to tools with real memory and understanding.

One agent's uncertainty becomes another agent's investigation. One agent's pattern detection becomes another's refactoring opportunity. It's like having a persistent AI team discussion embedded in your code.

What's Next

Robokeytags v1.0 is now open source. It's battle-tested from months of internal use at Robokeys. But I believe the community will take it places I never imagined.

RobokeyTags is more than a specification—it's the foundation for an ecosystem of tools. The first one is already here: Puzzlegrep, a CLI tool to search for structured tags across your codebase.

Learn more about Puzzlegrep and start making your code AI-aware today.

Some possibilities I'm excited about:

• IDE plugins that visualize the puzzle structure
• AI assistants that remember everything between sessions
• Linters that understand tool boundaries
• Code review tools that highlight structural changes

Join the Journey

If you're frustrated by:

• Code generators that don't know where to insert
• AI that forgets everything between chats
• The chaos of multiple tool conventions
• Lost context in your codebase

Then Robokeytags might be your answer too.

This started as a simple internal tool. With your help, it could become the standard for how all our tools understand code.