What is an AI agent?

So, Google Cloud NEXT has wrapped and this year it was all about Agentic AI and the move towards an autonomous cloud. The conference itself was divided in to two sections, the first was the opening Keynote which was intended for executives and non-technical audiences and showcased products developed by Google that implement Agentic AI and all the things that businesses will use these products for that will make the public hate all forms of AI even more. The second was the Developers Keynote and it was about how these systems are structured and how they can be implemented. This is the one that we are interested in, as it not only gives us a sense of what we can build with these things but also how we can go about building them.

What Is Agentic AI (Actually)?

To get everyone on the same page: Agentic AI moves beyond conversation into action. These are LLM-powered systems that plan, reason, and execute multi-step workflows with minimal human oversight. While tools like OpenClaw have popularized this, it's important to remember they are semi-autonomous; they lack "free will" and operate strictly within the parameters we define.
Broadly, these agents fall into three buckets:

• Simple Reflex Agents: Basic "if/then" logic based on current conditions.
• Goal-Based Agents: Proactive systems working toward a specific objective.
• Learning Agents: Systems that refine their performance based on feedback.

The Shift from "Build" to "Communicate"

Google Cloud NEXT was flooded with low-code tools designed to help anyone spin up these agents. While those are great for the "democratization" of AI (for better or worse), we’re looking past the shiny UI.
The real breakthrough for developers isn't the builder it's the Developer Kit and the new Agent-to-Agent (A2A) Protocol. This protocol is the connective tissue that finally allows these autonomous systems to talk, negotiate, and work with one another.

What is A2A

The A2A (Agent-to-Agent) Protocol is the "universal translator" that AI desperately needed. Introduced by Google and now governed by the Linux Foundation, it moves us away from siloed, custom-coded API integrations and toward a standardized messaging format. Whether an agent is built on LangChain, CrewAI, or BeeAI, A2A allows them to collaborate without exposing their internal proprietary logic.

The Model: Orchestrators vs. Workers

A2A operates on a secure, asynchronous client-server model

• A2A Client (The Orchestrator): Receives the high-level prompt, packages it into a structured "Task," and delegates it.
• A2A Server (The Worker): A specialized agent with an HTTPS endpoint that listens for tasks, executes logic, and returns results.

The Three Phases of A2A

1. Discovery: The "Agent Card"

Before agents work together, they "exchange business cards." An Agent Card is a JSON metadata file (hosted at /.well-known/agent.json) that acts as a resume. It lists the agent’s name, skills, supported modalities (text, files), and security requirements, allowing orchestrators to scout the right tool for the job.

2. Authentication: The Handshake

A2A relies on existing standards like OAuth 2.0, OpenID Connect, and mTLS.

• The Flow: Credentials pass through the HTTP Authorization header.
• The Catch: The spec treats token acquisition as an "out-of-band" process. Translation: The protocol tells you how to show your ID, but not necessarily how to get it (a gap that feels like a recipe for implementation headaches).

3. Communication: Tasks & Artifacts

Once authenticated, agents talk via JSON-RPC 2.0. Unlike simple chat messages, A2A is built around Tasks:

• Lifecycle: Tasks have unique IDs and states (e.g., submitted, working, completed).
• Modes: Supports Synchronous (quick replies) and Asynchronous (long-running tasks via Server-Sent Events or Webhooks).
• The Result: Every completed task produces an Artifact which could be anything from raw code to a structured data file.

What can we do with it?

Now that we have defined Agentic AI and explored Agent-to-Agent (A2A) interactions, the question remains, what can we do with it? As we saw during the opening keynote there are many applications for Agentic AI, autonomous customer service, proactive IT incident resolution, automated supply chain management but there was one that was overlooked, disinformation moderation in social media. There is an old adage: “A lie can travel around the world while the truth is still lacing up its boots.” In the age of AI-generated misinformation, that lie doesn't just travel; it mutates. Traditional moderation (human or AI) is often too slow. By the time a post is flagged, it has already been shared thousands of times across nested networks. The question isn’t just how to prevent misinformation, but how to contain it once it’s in the wild.

Enter the "Slopster"

Instead of viewing misinformation as prey to be hunted, think of it as organic waste polluting a digital ecosystem. In nature, detritivores like snails and lobsters clean up the environment by consuming decaying matter. In our social media ecosystem, we need the Slopster: an A2A-powered (Agent-to-Agent) scavenger designed to "eat" (flag) AI-generated "slop." The Slopster evaluates post through a three-stage cycle:

1. Metadata Scanning

The Slopster crawls the network looking for the digital fingerprints left by AI image generators. It compares suspicious files against a comprehensive database of known AI-generated signatures and patterns to identify synthetic content at the source.

2. Contextual Evaluation

Identification is only half the battle. If the Slopster finds an AI-generated image, it evaluates the intent of the post

• Malicious Intent: If the image is being presented as legitimate, real-world evidence for the purpose of disinformation, it is flagged.
• Benign Intent: If the image is clearly labeled, artistic, or harmless, the Slopster ignores it and moves on to the next scan.

3. The A2A Multiplier

A single Slopster doesn't have to struggle alone. If an agent discovers a high concentration of AI "slop" indicating a potential bot farm it uses the A2A protocol to call for reinforcements. This allows a swarm of agents to descend on the source, neutralizing large-scale disinformation campaigns in real-time.

Note: Keen eye readers will have noticed that the Slopster only examines images for possible signs of AI and not text. This is a deliberate design choice. By bypassing the linguistic complexities of NLP (Natural Language Processing) and focusing strictly on visual metadata and context, the Slopster remains computationally lean. This allows for high-speed processing without the overhead required to evaluate the nuances of human speech.

Scaling the Defense

This is where the protocol shines. A "Primary Slopster" can send a JSON manifest of its findings to "Assisting Slopsters." These agents then swarm the offending network, tracing shares and identifying the artificial accounts used to boost the post. When enough Slopsters begin "feeding" (a Slopster feeding frenzy) on a single account or collection of accounts, the system triggers a high-priority alert for a human moderator who can then remove the accounts.

From Concept to Code

Of course, building a Slopster requires more than just a clever name. It needs:

1. A Global Library of known AI image signatures.
2. Network Traversal Algorithms to map how a post spreads.
3. The A2A Backbone to ensure these agents can trade data quickly without getting bogged down in custom API hell and the API that powers the social network needs to support the kind of access required by the agents.

The Slopster is a excellent example of why the A2A protocol matters: it transforms isolated AI tools into a collaborative defense force.

Conclusion

We’ve cut through the Cloud NEXT marketing noise to define what Agentic AI actually is, dissected the A2A protocol’s "business card" discovery system, and imagined a future where the Slopster cleans up our digital waste. A2A isn't just another Google announcement; it’s the first real attempt at a "universal translator" for the autonomous cloud. Whether it becomes the industry standard or just another abandoned project remains to be seen, but the potential for collaborative, cross-platform agents is finally on the table.

Ready to Build?

If you're tired of the theory and ready to get your hands dirty check out these resources.

• The Deep Dive: Check out Google’s official A2A Overview and Protocol Documentation.
• The Code: Head over to the A2A Developer Kit and grab the SDK for your favorite language (or JavaScript).

Stay tuned to see what else we’re cooking up here at The Puttering Dev.