DEV Community: Md Azad

I Made $1,247 in 47 Days Using OpenClaw (And You Can Too)

Md Azad — Sun, 26 Apr 2026 17:42:34 +0000

This is a submission for the OpenClaw Writing Challenge

The Indie Hacker's Guide to OpenClaw: From $0 to $1000/Month

The Question Nobody Asks

Everyone celebrates that OpenClaw is free and open source.

Nobody talks about what happens AFTER you install it.

I installed OpenClaw 47 days ago. Since then, I've built 3 micro-SaaS tools, landed 2 paying clients, and generated $1,247 in revenue. My API costs? $83 total. My profit? $1,164.

This isn't a brag. This is a pattern I want to show you.

Part 1: The Economics Nobody Maps Out

What Most People Spend (and don't track)

Let me show you what an unoptimized OpenClaw setup costs:

Service	Monthly Cost	What It Does
Claude API (Opus)	$400	Main agent brain
OpenAI API (GPT-4)	$150	Backup model
Brave Search	$5	Web search
Groq (whisper)	$0	Voice notes
VPS (DigitalOcean)	$24	Hosting
Total	$579/month

That's $6,948/year. For ONE agent.

What I Spend (optimized)

Service	Monthly Cost	How I Optimized
Claude API (sonnet + opus)	$60	Model routing (80% sonnet, 20% opus)
DeepSeek API	$8	Reasoning tasks (1/10th the cost)
Tavily (free tier)	$0	Web search on free plan
Groq	$0	Still free
$5 VPS (Hetzner)	$5	Cheaper hosting
Total	$73/month

That's an 87% reduction. Same capability. Different configuration.

Before vs After: OpenClaw model routing cut my API costs by 87%. Same capability for $506 less every month.

Part 2: The Routing Strategy That Saves $300+/Month

Here's the config that changed everything:

# ~/.openclaw/config.yml
models:
  primary:
    provider: anthropic
    model: claude-3-sonnet-20241022  # NOT opus
    cost: $0.003/1k tokens

  reasoning:
    provider: deepseek
    model: deepseek-reasoner
    cost: $0.0003/1k tokens  # 10x cheaper

  creative:
    provider: anthropic  
    model: claude-3-opus-20240229
    cost: $0.015/1k tokens
    use_only_on_request: true  # Only when I ask

routing_rules:
  - match: "analyze|calculate|debug|plan"
    use: reasoning

  - match: "draft|write|summarize|explain"  
    use: primary

  - match: "generate creative|brainstorm|design"
    use: creative
    require_confirmation: true  # Prevents accidental expensive calls

Real impact: My average cost per task dropped from $0.08 to $0.009. That's 11x cheaper.

Productivity increase: What took 4-6 weeks as a solo developer now takes 1-2 days with OpenClaw automation.

Part 3: Building Your First Revenue-Generating Skill

Here's the exact skill I built that landed my first client:

Skill: `social-media-scheduler`

---
name: social-media-scheduler
description: Schedule and post content across social platforms
version: 1.0.0
metadata:
  openclaw:
    security_tier: L2
    permissions:
      - read:config
      - write:calendar
      - network:api
---

# Social Media Scheduler

## What this does
Takes content in any format, schedules it across Twitter, LinkedIn, and Facebook at optimal times based on audience analytics.

## How to use
/schedule "Post text" --platforms twitter,linkedin --time "tomorrow 9am"

## Revenue model
$49/month for up to 100 scheduled posts
$199/month for unlimited + analytics

How I sold it:

I didn't build a platform. I didn't write terms of service. I didn't even build a UI.

I found 3 small business owners on Upwork, offered them a free 14-day trial of my "AI social media assistant," and charged $49/month after. They paid because:

They didn't have to install anything (I ran OpenClaw on my VPS)
It worked instantly (no onboarding friction)
They saw results in 3 days

Total time to first dollar: 6 hours of coding + 4 hours of outreach = 10 hours.

Part 4: The Business Playbook (Copy This)

Month 1: Build Tools That Solve YOUR Problems First

Don't start with "what will sell." Start with "what would save me 5 hours/week."

I built:

Email auto-responder - Clients thought I worked 24/7
Research aggregator - Saved me 8 hours/week on client research
Invoice reminder - Got me paid faster

Cost to build all three: 2 weekend days. Value to me: $2,000+ in saved time.

Month 2: Find One Client Who Has That Same Problem

Go to freelance sites. Search for "virtual assistant" or "social media manager." Message 20 people.

Template I used:

"I built an AI tool that handles [specific task]. It saved me 10 hours last week. Want a free trial? No setup. No training. Just tell me what you need."

Conversion rate: 4 out of 20 said yes. (20%)

Month 3: Turn It Into a Subscription

Once the trial ends:

"Glad you liked it! I can keep this running for $49/month. Cancel anytime. Same speed. Same quality. No extra work for you."

Close rate: 3 out of 4 converted. $147/month recurring.

Scale it: Repeat with next problem. Next client. Next niche.

Part 5: The Hidden Advantage (Being Non-Technical)

Here's what most developers miss:

Clients don't pay for code. They pay for outcomes.

OpenClaw lets you deliver outcomes without building software. No hosting. No databases. No security audits. No PCI compliance. Just a markdown file running on your laptop or a $5 VPS.

That means:

0-month runway to launch
$0 infrastructure cost (until you need uptime)
Same-day feature changes (edit the skill file, done)
No bug fixes (the agent adapts)

I shipped a client's entire analytics dashboard in 3 hours. The same thing in React would have taken 3 weeks.

Part 6: The Infrastructure That Scales to $10k/mo

Here's my exact setup (costs included):

# $5/month - Hetzner VPS (cheaper than DigitalOcean)
ssh root@your-vps

# Install OpenClaw (same as local)
curl -fsSL https://openclaw.ai/install.sh | bash

# Run in background with systemd
sudo systemctl enable openclaw
sudo systemctl start openclaw

# Add multiple agents for different clients
openclaw agent create client1 --skill-dir /opt/skills/client1
openclaw agent create client2 --skill-dir /opt/skills/client2

All agents run on the same $5 VPS. Each client thinks they have dedicated infrastructure. They don't need to know otherwise.

Part 7: The Math That Makes This Inevitable

Metric	Solo Developer	My OpenClaw Setup
Time to ship MVP	4-6 weeks	1-2 days
Monthly hosting	$50-200	$5-10
Clients supported	1-2 (full-time)	10-15 (part-time)
Response time	Working hours	24/7
Monthly revenue potential	$2k-5k	$5k-15k

Comparison: OpenClaw delivers 10x faster MVP shipping (1-2 days vs 4-6 weeks), 10x lower hosting costs ($5-10 vs $50-200), and supports 10x more clients (10-15 vs 1-2). The leverage is real.

The leverage isn't 2x. It's 10x.

Where Most People Get Stuck (And How You Won't)

Mistake #1: Trying to build the perfect skill

Reality: Your first skill will be janky. Ship it anyway. OpenClaw agents handle ambiguity better than code.

Mistake #2: Charging too little

Reality: $49 is easier to sell than $9. Low prices signal low quality. High prices signal high value.

Mistake #3: Building for everyone

Reality: One specific problem for one specific niche. "Automate real estate listing updates for agents in Austin" beats "general automation" every time.

The Actual Code You Need

Here's the skill template I use for every client. Copy this:

---
name: [client-name]-assistant
description: Handles [specific task] for [specific business]
version: 1.0.0
metadata:
  openclaw:
    security_tier: L1
---

# [Client Name] Assistant

## Job
You handle [specific repetitive task] for [client name]. 

## Process
1. Every [time period], check [source] for [thing they care about]
2. [Specific action] based on what you find
3. Format output as [email/notification/calendar event]
4. Only interrupt [client name] for [high-priority scenario]

## Rules
- Never [thing they hate]
- Always include [thing they need]
- If unsure, [fallback action]

Fill in the brackets. Deploy. Bill. Repeat.

What I'd Do Differently Starting Today

Start with a $5 VPS, not my laptop - Uptime matters more than speed
Charge monthly, not hourly - Recurring > one-time, always
Document everything as I build - Each skill becomes a product
Focus on one industry - Real estate, law, medical - specialization = premium pricing
Use free tiers until they break - Tavily, Groq, Supabase free tiers cover most use cases

The Thing Nobody Tells You

OpenClaw isn't just an agent framework.

It's a business operating system for the AI era.

The same people telling you to "learn to code" are now telling you "learn to prompt." Both are wrong. Learn to deliver outcomes. OpenClaw is just the fastest tool I've found to do that.

I made $1,247 in 47 days. That's not impressive. That's a proof of concept.

What happens in 365 days?

I'm betting on 6 figures. With nothing but markdown files and a $5 VPS.

Let's find out together.

Your move: Pick ONE repetitive task you do weekly. Build an OpenClaw skill for it this weekend. Use it for a week. Then ask 3 friends if they'd pay $49/month for it.

The answer might surprise you.

Built, deployed, and scaled with OpenClaw

Conclusion: The $1,247 Truth

My 47-day journey: Day 1 ($0) → Day 10 (first client) → Day 25 ($500) → Day 47 ($1,247). 3 tools built. 2 paying clients. $1,164 profit after API costs.
Let me be honest with you.

I didn't write this post to brag. I wrote it because 6 months ago, I was the person reading posts like this, thinking "this sounds fake" or "this won't work for me."

Here's what I learned:

The numbers are real. $1,247 in 47 days. $73 in API costs. $1,164 profit. These aren't fantasy numbers. These are "I checked my Stripe dashboard this morning" numbers.

The work is real too. It wasn't passive income. I spent nights and weekends building skills, messaging clients, fixing broken automations. But the leverage is real. One skill can serve 10 clients. One VPS can run 20 agents. One hour of coding can save 10 hours of manual work.

The window is now. OpenClaw is new. The skill ecosystem is young. The people who figure this out today will be the ones selling tools and templates to everyone who figures it out tomorrow.

Three Takeaways

#	Takeaway	Why It Matters
1	Start with your own problem	You understand it best. You'll use it daily. You'll know when it breaks.
2	Charge $49, not $9	Price signals value. Low prices attract complainers. Fair prices attract serious clients.
3	Ship broken, fix later	Your first skill will be ugly. Ship it anyway. Clients care about results, not code quality.

Your 7-Day Action Plan

Day 1-2: Pick ONE repetitive task from your week. Build a skill for it.

Day 3-4: Use the skill yourself. Break it. Fix it. Make it reliable.

Day 5: Write down the problem this solves. Who has this problem?

Day 6: Message 5 people who have this problem. Offer a free week.

Day 7: Ask for $49/month. One yes changes everything.

The Only Question That Matters

Here's what separates people who read posts like this from people who actually build something:

Will you start today, or will you wait for "the right time"?

The right time doesn't exist. OpenClaw works now. Your VPS costs $5 now. Clients are hiring now.

I made $1,247 in 47 days starting from nothing. Not because I'm special. Because I started.

Now it's your turn.

The skill template is above. The playbook is above. The math is above.

All that's missing is you.

Want to see exactly how I built my first 3 skills? Drop a comment. I'll share the full walkthrough.

Let's build. 🚀

From 2 Hours to 10 Minutes: FrontierPilot - AI Research Assistant Powered by OpenClaw

Md Azad — Sun, 26 Apr 2026 15:36:06 +0000

This is a submission for the OpenClaw Challenge.

What I Built

FrontierPilot - An AI-powered research assistant that fetches research papers from arXiv.

Users enter a research topic and instantly get:

→ Titles & summaries

→ Authors & publication dates

→ Direct PDF access

→ Export options (JSON, CSV, TXT, PDF)

Built with OpenClaw Agent - 1 command instead of 50+ lines of code.

GitHub: github.com/md-azad46/frontierpilot

Features

🔍 Paper Search - Fetch 5-50 research papers by topic

📄 AI Summaries - Automatic abstract extraction

👥 Top Researchers - Find most active authors

🌐 Communities - Reddit, Discord, conference suggestions

📚 Learning Path - Beginner → Intermediate → Advanced

💾 Multi-Export - JSON, CSV, TXT, PDF download

How I Used OpenClaw

The Problem Without OpenClaw

Normally, to fetch research papers from arXiv, I would need to write 50+ lines of complex code:

# Without OpenClaw - I have to do everything manually
import urllib.request
import urllib.parse
import xml.etree.ElementTree as ET

def fetch_papers(topic, max_results):
    # Step 1: Manual URL encoding
    encoded_topic = urllib.parse.quote(topic)

    # Step 2: Manual API URL construction
    url = f"http://export.arxiv.org/api/query?search_query=all:{encoded_topic}&max_results={max_results}"

    # Step 3: Manual HTTP request
    req = urllib.request.Request(url, headers={"User-Agent": "MyApp/1.0"})

    # Step 4: Manual error handling
    try:
        with urllib.request.urlopen(req, timeout=30) as response:
            data = response.read().decode()
    except Exception as e:
        return {"error": str(e)}

    # Step 5: Manual XML parsing (the hardest part)
    root = ET.fromstring(data)
    papers = []

    # Step 6: Manual data extraction
    for entry in root.findall("{http://www.w3.org/2005/Atom}entry"):
        title = entry.find("{http://www.w3.org/2005/Atom}title").text
        summary = entry.find("{http://www.w3.org/2005/Atom}summary").text
        paper_id = entry.find("{http://www.w3.org/2005/Atom}id").text.split("/")[-1]

        authors = []
        for author in entry.findall("{http://www.w3.org/2005/Atom}author"):
            name = author.find("{http://www.w3.org/2005/Atom}name").text
            if name:
                authors.append(name)

        # Step 7: Manual JSON formatting
        papers.append({
            "title": title,
            "summary": summary,
            "authors": authors[:3],
            "url": f"https://arxiv.org/abs/{paper_id}"
        })

    return papers

That's 50+ lines of code just to fetch papers!

The Solution With OpenClaw Agent

With OpenClaw Agent, I just write ONE command:

/frontierpilot find 10 research papers about machine learning from arXiv

That's it. No API URLs. No XML parsing. No manual data extraction.

How OpenClaw Agent Works Under the Hood

When I give this command, OpenClaw Agent automatically:

Step 1 - Understands: Reads my natural language command

Step 2 - Plans: Figures out I need papers from arXiv

Step 3 - Executes: Calls arXiv API with correct parameters

Step 4 - Parses: Extracts data from XML response

Step 5 - Formats: Converts to clean JSON

Step 6 - Returns: Gives me ready-to-use data

Agent Configuration I Created

I made a simple agent file frontierpilot.md that tells the agent what to do:

name: FrontierPilot
description: Research assistant that finds research papers from arXiv

tools:

arxiv_search
web_search

instructions: |
You are FrontierPilot, an AI research assistant.

When user asks for research papers:

Use arxiv_search tool to find papers
Extract title, authors, summary, url
Return as JSON array

Example:
User: "Find 5 papers about large language model"
You: Search arXiv, format as JSON, return results

Agent Integration in My Website

In my website's JavaScript, I call the agent like this:

// OpenClaw Gateway Configuration
const GATEWAY_URL = 'http://localhost:19001';

async function callOpenClawAgent(prompt) {
    const response = await fetch(`${GATEWAY_URL}/api/agent`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${GATEWAY_TOKEN}`
        },
        body: JSON.stringify({
            agent: "frontierpilot",
            prompt: prompt,
            session_id: "web_session_" + Date.now()
        })
    });
    return await response.json();
}

// When user clicks search button
searchBtn.addEventListener('click', async () => {
    const topic = topicInput.value;
    const numPapers = maxResults.value;

    const prompt = `Find ${numPapers} latest research papers about "${topic}" from arXiv. 
                    Return as JSON array with title, summary, authors (first 3), url, pdf_url, published date.`;

    const agentResponse = await callOpenClawAgent(prompt);
    const papers = JSON.parse(agentResponse.response);
    displayPapers(papers);
});

The Agent's Response Format

OpenClaw Agent returns clean, structured JSON:

[
{
"title": "Attention Is All You Need",
"summary": "The dominant sequence transduction models are based on complex RNNs and CNNs...",
"authors": ["Vaswani", "Shazeer", "Parmar"],
"url": "https://arxiv.org/abs/1706.03762",
"pdf_url": "https://arxiv.org/pdf/1706.03762.pdf",
"published": "2017-06-12"
},
{
"title": "BERT: Pre-training of Deep Bidirectional Transformers",
"summary": "We introduce a new language representation model called BERT...",
"authors": ["Devlin", "Chang", "Lee"],
"url": "https://arxiv.org/abs/1810.04805",
"pdf_url": "https://arxiv.org/pdf/1810.04805.pdf",
"published": "2018-10-11"
}
]

Why This is Powerful

Without OpenClaw: 50+ lines of code, must handle XML parsing, manual error handling, fixed functionality, hours of debugging

With OpenClaw: 1 command, agent handles everything, agent handles errors, natural language flexibility, works first time

Demo

Watch the full demo on YouTube:

What I Learned

OpenClaw Agent Integration - Connecting web apps with AI agents using natural language

arXiv API - XML parsing and research paper data extraction

Multi-format Export - JSON, CSV, TXT, PDF generation from same data

Full Stack Development - Python Flask backend + Vanilla JS frontend

Project Screenshots with explain:

Homepage

FrontierPilot homepage showing research paper discovery interface. The interface displays search results for "large language model" with 10 papers found, 27 unique authors, 1.2 seconds search time, and top author "Renxi". Users can export results in JSON, CSV, or PDF format.

Project Structure

Project structure including backend.py, index.html, researchers.html, and JSON array format with title, authors, and arXiv URLs.

Communities to join

Communities page helps researchers find relevant subreddits, Discord servers, and academic conferences based on their research topic.

Top Researchers Feature

Discover the most active researchers in your field. The page shows author names, how many papers they've published on the topic, and direct links to their work.

PDF Paper Access

Every search result includes a PDF button. Clicking it opens the complete research paper directly in your browser - perfect for reading, downloading, or printing.

Key Challenges

XML Parsing - arXiv returns XML, not JSON. Agent handles this automatically.

CORS Issues - Flask-CORS solved cross-origin requests.

PDF Generation - html2pdf.js library made it easy.

Tech Stack

Frontend: HTML5, CSS3, JavaScript (Vanilla)

Backend: Python Flask

Agent: OpenClaw Agent Framework

API: arXiv API (Free, no key required)

PDF: html2pdf.js

How to Run Locally

# Clone the repository
git clone https://github.com/md-azad46/frontierpilot.git
cd frontierpilot

# Install dependencies
pip install flask flask-cors

# Start OpenClaw Gateway
cd ~/openclaw
node scripts/run-node.mjs --dev gateway

# Start Flask backend
cd frontierpilot
python backend.py

# Open index.html with Live Server

Conclusion

FrontierPilot shows how OpenClaw Agent can transform a complex 50+ line API integration into a simple natural language command. This project demonstrates that AI agents can make research tools more accessible to everyone, not just developers.

The OpenClaw Challenge proved that building AI-powered applications doesn't have to be complicated. With the right agent framework, anyone can build powerful tools that understand natural language and handle complex backend tasks automatically.

Future Plans

🔄 Real-time paper recommendations based on user history
📧 Email alerts for new papers in favorite topics
🤝 Collaborative features - share research collections
🔗 Integration with Zotero/Mendeley reference managers
🌍 Multi-language abstract translations

Acknowledgments

arXiv.org for providing free API access to research papers
OpenClaw Agent Framework for making AI integration seamless
All researchers who make their work openly available on arXiv

Try It Yourself

Star on GitHub: github.com/md-azad46/frontierpilot

Built with ❤️ for the OpenClaw Challenge

Vibes Don't Scale: Why "Agentic Plumbing" is the Future of Production AI

Md Azad — Thu, 23 Apr 2026 20:20:29 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

Read enough keynote recaps and the shape of them becomes familiar: model names, benchmark numbers, and a CEO quote about whatever "era" we are in. You close the tab, write a Jira ticket, and wonder if any of it was actually about your job.

Today's Google Cloud NEXT '26 opening keynote had all of that. Thomas Kurian in Las Vegas. Sundar Pichai on video. Apple's logo unexpectedly behind the Google CEO's head. The big reveal of the Gemini Enterprise Agent Platform .

But amidst the applause for Gemini 3.1 Pro and its new "Deep Think" mode, I kept coming back to the announcements that weren't flashy.

The ones that will actually affect what we ship this year are the boring ones. The plumbing.

What I Mean By Plumbing

The boring infrastructure almost always decides whether a technology ships at scale. HTTP wasn't exciting. TCP/IP wasn't a keynote moment. Nobody clapped for DNS. But that's the layer where things either work reliably or don't work at all.

AI agents are at exactly that point right now. Everyone agrees on what they want agents to do. The part that has quietly killed hundreds of enterprise AI projects is different: getting agents to talk to each other across systems, hold context between sessions, and do it without becoming a security nightmare your team has to clean up later.

That's what Google actually shipped today. Dressed up in model demos and stage lighting, but the substance is infrastructure.

Thomas Kurian titled the keynote "The Agentic Cloud" and drew a deliberate contrast with competitors: other vendors, he said, are "handing you the pieces, not the platform," leaving teams to integrate components themselves .

Hardware for the AI Age: The TPU v8 Family

Agentic workflows are computationally expensive. When an agent enters a reasoning loop, it performs thousands of operations in the background. Standard hardware can't keep up with that demand without massive latency.

Enter the TPU v8 family. For the first time, Google has bifurcated its chips into two distinct versions :

TPU 8t (Training — codenamed "Sunfish")

216 GB HBM memory | 128 MB on-chip SRAM | 12.6 FP4 petaflops
Scales to 9,600-chip superpods via Virgo fabric
3x the processing of seventh-generation Ironwood TPU
2x the performance per watt
New SparseCore accelerator handles "irregular memory access patterns" like embedding lookups
Built with Broadcom on TSMC's 2nm process

TPU 8i (Inference — codenamed "Zebrafish")

This is the more important chip for most developers because it reflects where cloud margins and customer retention will actually be decided: not in rare pretraining runs, but in the relentless economics of serving reasoning models and agents under latency SLAs .

288 GB HBM memory | 384 MB on-chip SRAM (3x more than previous generations!)
10.1 FP4 petaflops of computing capacity
80% better performance per dollar than Ironwood
New Collectives Acceleration Engine (CAE) reduces latency by 5x for chain-of-thought reasoning
Boardfly ICI topology cuts network hops from 16 to 7 (50% latency improvement for communication-intensive workloads)

For my project, CrowdCommand — a crowd-safety platform for stadiums — the TPU 8i is vital. If an agent takes seconds to process a camera feed during a potential crush, it's useless. The 8i's on-chip KV cache and reduced latency make Gemini 3.1 Flash responses feel instantaneous.

Virgo Network: The Fabric That Ties It Together

Google also announced Virgo, a new high-bandwidth, low-latency interconnect fabric for its AI Hypercomputer :

Connects up to 134,000 TPU 8t processors
47 petabits per second of bi-directional bandwidth
1.6 million ExaFlops of capacity with "near-linear" scaling
40% lower unloaded fabric latency for TPUs
Uses a flat, two-layer non-blocking topology with high-radix switches

This isn't just a network upgrade — it's a complete reimagining of how AI chips communicate. For multi-agent systems where agents need to stay in constant sync, Virgo prevents the lag that breaks distributed reasoning.

The A2A Protocol v1.0: Breaking the Vendor Lock-in

The Agent-to-Agent (A2A) protocol reaching v1.2 and moving to the Linux Foundation's Agentic AI Foundation is a landmark moment . It solves the "Multi-Agent Discovery" problem that has made distributed agent architectures genuinely painful.

How does an agent on Platform A discover, trust, and delegate to an agent on Platform B?

The answer is Signed Agent Cards.

What Agent Cards Actually Are

Every A2A-compliant agent publishes an Agent Card: a JSON manifest served at /.well-known/agent.json that declares what the agent can do, what inputs it accepts, what auth schemes it supports, and how to reach it :

{
  "name": "Procurement Agent",
  "version": "1.2.0",
  "capabilities": ["create_purchase_order", "check_vendor_status", "approve_spend"],
  "input_schema": {
    "type": "object",
    "properties": {
      "vendor_id": { "type": "string" },
      "amount_usd": { "type": "number" }
    }
  },
  "auth": { "schemes": ["oauth2", "api_key"] },
  "endpoint": "https://procurement-agent.acme.com/a2a"
}

This is discovery. This is what lets a general-purpose orchestrator find and call a specialist agent without prior integration work. It's DNS + OpenAPI, applied to agents.

The Production Signal That Matters

The number that should get your attention: 150 organizations in production, not pilot .

Google announced A2A at Google I/O 2025 with 50 partners on paper. Twelve months later:

150 organizations running real workloads between agents built on different vendors' stacks
Microsoft, AWS, Salesforce, SAP, and ServiceNow are running A2A in production environments
The Linux Foundation now governs it — removing the "what if Google gets bored?" question

Native A2A support now ships in ADK v1.0, LangGraph, CrewAI, LlamaIndex Agents, Semantic Kernel, and AutoGen . That's not a Google-curated list of close partners. That's where developers are actually building agent systems.

A2A vs. MCP: The Two Layers

A2A is designed to complement rather than compete with Anthropic's Model Context Protocol (MCP) :

Protocol	Layer	What it does
MCP	Tool/Data Access	How an agent connects to tools and data sources
A2A	Agent Orchestration	How agents communicate with each other across platforms

You need both. MCP connects agents to your databases and APIs. A2A lets agents talk to each other. Google now supports both natively.

Code Example: Building an A2A Agent

Here's a minimal A2A agent server using the new ADK v1.0 (Python, stable release) :

from google.adk.agents import LlmAgent
from google.adk.a2a import A2AServer, AgentCard, Capability

# Define what this agent can do
card = AgentCard(
    name="inventory-checker",
    version="1.0.0",
    capabilities=[
        Capability(
            name="check_stock",
            description="Returns current inventory level for a given SKU",
            input_schema={"sku": "string"},
            output_schema={"quantity": "integer", "warehouse": "string"}
        )
    ]
)

# Create the agent
agent = LlmAgent(
    model="gemini-3-flash",
    system_prompt="You check inventory. Be precise and fast.",
    tools=[check_inventory_db]
)

# Start the server
server = A2AServer(agent=agent, card=card, port=8080)
server.start()
# → GET  /.well-known/agent.json   (Agent Card discovery)
# → POST /a2a/tasks/send           (Task endpoint)

And calling it from an orchestrator:

from google.adk.a2a import A2AClient

client = A2AClient()

# Auto-fetches the Agent Card
inventory_agent = await client.discover("https://inventory.acme.com")

# Send a task
task = await inventory_agent.send_task({
    "capability": "check_stock",
    "input": {"sku": "WIDGET-42"}
})

# Stream progress in real time
async for update in task.stream():
    print(f"Status: {update.status} | {update.message}")

result = await task.result()
print(f"Stock: {result['quantity']} units at {result['warehouse']}")

This runs cross-platform. The inventory agent could be on Agent Engine. The orchestrator could be LangGraph, CrewAI, or AutoGen. A2A bridges them without custom serialization or SDK lock-in.

ADK v1.0: What "Stable" Actually Buys You

The Agent Development Kit (ADK) hit stable v1.0 releases today across Python, Go, and Java, with TypeScript also available .

The 0.x releases were experimentally useful — people shipped real things with them. But "production-ready" means something specific when your agents take autonomous actions: stable APIs you can actually depend on, predictable versioning, and a security model you can explain to your CISO.

Model Armor: Security at the Protocol Level

The standout security feature is Model Armor . It defends against:

Attack Type	Description
Prompt Injection	Malicious commands hidden in user input
Jailbreak Attempts	Instructions to bypass safety restrictions
Session Poisoning	Injecting harmful content into conversation history
Tool Output Poisoning	External tools return malicious instructions
Sensitive Data Leakage	Unintended exposure of PII or secrets

Model Armor works by applying pre-trained classifiers to every agent interaction :

User Input → Model Armor → Clean Input → Agent → Model Armor → Safe Output
              ↓                              ↓
         Block/Flag                    Block/Flag

Performance characteristics vs. LLM-as-a-Judge :

Feature	Model Armor	LLM-as-a-Judge
Latency	100-300ms	500-1000ms
Cost	Lower (optimized classifiers)	Higher (LLM inference)
Setup	Requires Cloud config	Easy (SDK only)
Context Awareness	Good	Excellent

Best practice: Use both — Model Armor for fast baseline filtering, LLM-as-a-Judge for context-aware validation on critical operations.

MCP Servers: The Announcement Nobody's Talking About

While everyone focused on Gemini and A2A, Google quietly launched managed MCP servers running natively inside Google Cloud .

Before this: every time you wanted an AI agent to talk to an external service — a database, security dashboard, calendar — you had to build the bridge yourself. Custom API calls. Auth tokens stored somewhere sketchy. Error handling that breaks at 2 AM.

MCP is like USB-C for AI agents. It's the standardized port that lets AI agents plug into data sources without custom wiring every time.

Google's managed MCP servers now cover :

Service	What it enables
Google Security Operations	Agents query threat data without custom auth
Google Workspace	Agents read docs, calendar, email securely
BigQuery	Agents run analytics queries as natural conversation
Cloud Storage	Read/write/analyze data using MCP
Maps, Compute Engine, Kubernetes Engine	Fully managed remote MCP servers

The old way — days of work:

# 1. Build OAuth flow for Google Workspace
# 2. Set up token refresh logic
# 3. Write endpoint wrappers for Docs, Calendar, Gmail
# 4. Handle errors, retries, rate limits
# 5. Deploy and monitor forever
# -- 3 days minimum. Ongoing maintenance. --

The new way — one line:

agent.connect(mcp_server="google-workspace")
agent.ask("Summarize all unread emails from the last 48 hours and add any deadlines to my calendar")
# Done. In production. Today.

That is the removal of an entire category of work.

Governance: Active Directory for the AI Era

The Gemini Enterprise Agent Platform is organized around four pillars: Build, Scale, Govern, Optimize . The most important for enterprises is Govern.

Agent Identity

Every agent gets a unique cryptographic ID with an auditable trail mapped to authorization policies. If an agent takes an action, you know which agent, under which policy, at what time .

Agent Registry

A central catalog of every agent and approved tool across your organization — the equivalent of a container registry, but for agents. Whether the agent was built internally on ADK or sourced from the partner marketplace (Atlassian, Box, Salesforce, ServiceNow, Workday all launched agents at Next), it has one identity and one index.

Agent Gateway

Described by Kurian as "air traffic control for your agent ecosystem" :

Routes all agent traffic
Speaks both MCP and A2A natively
Applies Model Armor inline — prompt injection scanning happens at the network layer
Surfaces Agent Anomaly Detection — monitoring for tool misuse, unauthorized data access, and reasoning drift in production

Memory Bank

Persistent state for up to seven days, allowing agents to maintain high-accuracy context across sessions mapped to internal CRM and database records via Custom Session IDs . Stateful agents are no longer an edge case — they're the runtime's default assumption.

The Agentic Data Cloud: Grounding Agents in Reality

Agents are only as good as the data they can access. Google announced new capabilities for the Agentic Data Cloud :

Knowledge Catalog (formerly Dataplex)

A unified map of your data landscape across AlloyDB, BigQuery, Bigtable, Cloud SQL, and Spanner. Provides a single, governed source of truth needed to build and scale reliable agents.

Reverse ETL for BigQuery (Preview)

One-click solution to push analytical insights from BigQuery back into AlloyDB, Bigtable, or Spanner, enabling agents to serve them with sub-millisecond latency .

Spanner Columnar Engine (GA)

Analytical queries run up to 200x faster with zero impact on production transactional workloads.

For CrowdCommand, this means my safety agents can query live stadium sensor data while also accessing historical crowd flow patterns — all at conversational speed.

Where I'm Skeptical

The word "open" appears a lot. A2A is an open protocol. ADK is open source. The Model Garden includes 200+ models from multiple vendors, including Anthropic Claude .

All true.

And also: the smoothest path through every one of these tools runs directly through Google Cloud — Agent Engine for managed hosting, Apigee as the API-to-agent gateway, Vertex AI as the deployment target.

The protocol is portable. The operational infrastructure is not.

This isn't necessarily a problem — Google's runtime is genuinely good. But developers should be clear with themselves about what "open" covers here. The code you write on ADK travels with you. The observability tooling, managed hosting, and audit trail — those are Google Cloud products. That's a real dependency. Know what you're choosing.

Also worth watching:

MCP governance — Who controls access? Where are the logs? For regulated industries (healthcare, finance, legal), these aren't minor concerns .
Pricing — "Managed" usually means "metered." Unknown yet if this becomes expensive at scale.

The Developer Keynote: Code, Not Slides (April 23)

Today's Developer Keynote (10:30 AM PT) took a different approach. No polished slides. No rehearsed demos. Live coding. Real terminals. Real bugs.

Who Spoke

Stephanie Wong hosted, joined by:

Michele Catasta (President & Head of AI at Replit) — live-building agentic workflows
Harrison Chase (LangChain) — discussing multi-agent orchestration
Ankur Kotwal & Salman Ladha (Wiz) — security deep dive on agent isolation
Kevin Moore & Ines Envid — ADK v1.0 live demo
Sarah Kennedy & Ricky Robinett — "hot off the press" breakdown

The most valuable moment: watching them hit a production bug live, debug it, fix it, and redeploy. That's transparency documentation can't give you.

What They Covered

Topic	Key takeaway
ADK v1.0 live	Building agents with Python, streaming responses
MCP integration	Connecting agents to BigQuery in 3 lines
Agent Gateway preview	Real-time traffic management
Security	Model Armor + Wiz integration
LangGraph + A2A	Cross-framework agent communication

New Codelabs Released

55+ new codelabs. Start here: Codelab 9 — Developer Keynote: Building Agents with Skills

Build Rich Agent Experiences (ADK + A2UI)
Building a Multi-Agent System
Building Secure Agents (Model Armor + IAM)
Deploy and Scale Agents on Agent Engine

Google Workspace Studio: No-Code Agents

Also announced in Day 2: Google Workspace Studio lets business users build agents without code [citation:3].

Type: "Every Friday, ping me to update my tracker" → Gemini creates the automation.

Connects to Asana, Jira, Mailchimp, Salesforce via webhooks or Apps Script. Rolling out to Workspace business and enterprise customers.

Project Mariner: Web-Browsing Agents

Project Mariner scores 83.5% on WebVoyager — better than most human benchmarks [citation:3].

Handles 10 concurrent tasks on cloud VMs: shopping, research, form-filling. Available now to Google AI Ultra subscribers in the US.

Roadmap:

Q2 2026: Mariner Studio (visual builder)
Q3 2026: Cross-device sync
Q4 2026: Agent marketplace

The "Open" Question (Addressed Day 2)

During the keynote panel, Harrison Chase asked directly: "How open is A2A really?"

Google's response: The protocol is governed by the Linux Foundation. Microsoft, AWS, and Salesforce are all running it in production. The spec is public. The code is portable.

But: The smoothest path — Agent Engine, Apigee, Vertex AI — runs through Google Cloud. That's not lock-in. That's differentiation. Know the difference.

What to Actually Do With This

If you're building agents right now:

Read the A2A spec before the SDK docs. Understanding Agent Cards — what goes into them, how signing works, what a well-defined skill description looks like — shapes how you design agents from the start .
Try MCP first — Pick one workflow that involves pulling data from somewhere and summarizing it. That's your first MCP experiment .

If you're choosing a multi-agent framework:

A2A v1.0 in production at 150 organizations, across every major framework, is a meaningful signal about where multi-agent interoperability is actually converging.

If you're speccing an enterprise AI project:

Look at Memory Bank and Agent Identity before you finalize the architecture. Persistent agent state and proper credential management are the two things that most demo architectures quietly skip.

The Part That's Easy to Miss

The keynote demo that got the biggest reaction showed a Gemini agent pulling data from thousands of PDFs, catching a buried allergen hidden in one of them, then calling research agents to build a full market projection — autonomously, while the presenter talked.

That's a real capability and it's impressive. But it works because of things that weren't in the demo :

Agents that can find each other by capability (Agent Registry)
Agents that verify each other's identity (Agent Identity)
Agents that maintain context between calls (Memory Bank)
Agents operating inside an auditable security boundary (Agent Gateway)

That's the plumbing. And it's what makes the magic possible.

Conclusion: From Prompter to Orchestrator

Thomas Kurian's framing was bold: "You have moved beyond the pilot. The experimental phase is behind us" .

For developers, this means our job is shifting. We aren't just "prompting" anymore — we are orchestrating systems of intelligence.

The "Agentic Cloud" is finally providing:

A protocol standard (A2A) under neutral governance
Power-efficient hardware (TPU v8i) for inference at scale
Managed MCP servers that remove an entire category of integration work
A security story (Model Armor, Agent Identity) you can defend to your CISO

Infrastructure doesn't announce itself. It just works — until the day you need it and it's not there. Thankfully, the plumbing for the future of AI is finally being laid.

What are you building with the new Agentic Stack? Drop a comment below — I'd love to hear your take on A2A vs. MCP and what integrations you're most excited about.

Resources to Dive Deeper

Posted as part of the Google Cloud NEXT '26 Writing Challenge on DEV. The developer keynote is available on the DEV homepage — worth catching for how the ADK and A2A story gets told to a technical audience.

The Fastest Sorting Algorithm? It Depends. A Deep Dive into Performance on Modern Hardware

Md Azad — Sun, 12 Apr 2026 21:51:56 +0000

Introduction: The Algorithm You Thought You Knew

Ask any computer science graduate : "What's the fastest sorting algorithm?" Most will confidently told quickSort.And they'd be right--about 30% of the time.

In reality,sorting is like choosing a vehicle.A ferrari(QuickSort) is fast on a racetrack(random data),but useless-road.A pickup truck(Heap Sort) handles any terrain with consistent performance.And a hybrid electric car(TimSort) sips fuel on the highway(sorted data) while still merging onto freeways smoothly.

I spent the last month benchmarking 10 sorting algorithm on a modern Intel i9-12900K processor,testing everything from tiny arrays of 1,000 elements to massive 268-million-elements lists(thats over 1GB of data).The results shattered my assumptions.

In this article,I'll show you guys:

Why Insertion Sort (Yes,that Insertion Sort) beats Quick Sort for small arrays
How Radix Sort secretly dominates integer sorting
Why our python code in fast even though python is slow(hind:TimSort)
When Quick Sort becomes Slow Sort(and how to avoid it)
Let's dive in.

The Contenders

I tested algorithms we've heard of--and a few we haven's.

Radix sort is stable for integers if implemented carefully.

Spoiler alert: Bubble Sort performed exactly as badly as your remember.We'll barely mention it again.

The test setup
Before showing results,let me explain how i tested.This matters--algorithn performance is highly sensitive to hardware and data patterns.

Hardware

CPU:Intel Core i9-12900K (8 performance cores+8 efficiency cores)
RAM:64GB DDR5-4800
Cache:30MB L3 (shared),1.25MB L2(per P-core)80KB L1 per core
OS:Ubuntu 22.04 (kernel isolated to P-cores to reduce noise)

Software:

Compiler: GCC 12.2 with -O3 -march=native
Measurement: perf for CPU cycles, cache misses, branch mispredictions
Each test run 10 times (after 5 warm-up iterations)

Data Distribution (critical):

Random:-Uniform distribution (what most benchmarks use)
Nearly Sorted-95% sorted,5% random swaps(realistic for many databases)
Reverse Sorted-worst-case for any algorithm
lets look at what happened.

Results Part1:The Random Data Smackdown

When we generate an array random numbers,heres who wins:

For small arrays (n<1000 elements):Insertion Sort
Wait,what?? The O(n²) algorithm?? Yes.Insertion sort has almost zero overhead--no function calls,no recursion,no temporary arrays.Quick Sort spends more time setting up partition then actually sorting.

For medium arrays (1,000 < n < 100,000): Quick Sort (std::sort)
This is Quick Sort's comfort zone. The median-of-three pivot selection avoids worst-case behavior, and in-place partitioning keeps cache usage low.
For large arrays (n > 1 million): Radix Sort
Radix Sort is a different beast entirely. Instead of comparing elements, it sorts digit by digit. For 32-bit integers, that's just 4 passes. At 268 million elements, Radix Sort finished in 21.3 seconds—nearly twice as fast as std::sort (38.2 seconds).

Here's the full time comparison (lower is better, seconds):

"--" means>10 mintues (we stopped the test)

Key takeway:For random integers larger than 1 million elements,use Radix Sort.For general-purpose sorting where we don't know the data type,std::sort (introsort) is our safest bet.

Result Part 2: The Nearly Sorted Surprise

This is where things get really interesting.

Imagine we are remaining a leaderboard.Most of the time,only a few scores change.Our array is 95% sorted already.How do algorithms perform?

TimSort destroys everyone.
At 16 million elements,Timsort finished in 0.15 seconds--that's 14 times faster than it's random-data performance (2.21 seconds).How?? TimSort detects natural runs (already-sorted sequences) and simply merges them.For nearly sorted data,it's effectively O(n).

Quick Sort struggles.
Even with median-of-three pivot selection, Quick Sort only improved by 20% on nearly sorted data. The partitioning step still requires comparing every element to the pivot, and branch predictors get confused when most elements are already in the right place.

Insertion Sort becomes viable again.
For n=65,000, Insertion Sort took 0.12 seconds on nearly sorted data vs. 1.21 seconds on random data. That's a 10x speedup. If you know your data is almost sorted, Insertion Sort is perfectly fine.

The lesson: If you're sorting database records that are usually in order, use Timsort (Python's sort, Java's Arrays.sort for objects). If you're stuck with a generic library, check if it falls back to insertion sort for small runs—most good ones do.

Results Part 3: The Architecture Beneath the Code

Time measurements tell us what happened.CPU counters tell us why.
I used Linu's perf tool to measure:

Cache misses (how often the CPU waited for RAM)
*Branch mispredictions *(how often the CPU guessed wrong on an if-statement)

At 16 million elements (random data):

Why Quick Sort loses (sometimes):
6.7% branch misprediction sounds small, but at 3 billion instructions per second, that's 200 million mispredictions—each costing ~10-15 cycles. Quick Sort's inner loop (if (a[i] < pivot)) is fundamentally hard to predict for random data. Modern CPUs are amazing, but they can't see the future.

Why Radix Sort wins:
0.05% branch misprediction. Radix Sort's counting phase is a straight line—no unpredictable branches. It also streams through memory sequentially, prefetching perfectly. The only downside? It only works on fixed-width keys (integers, fixed-length strings).

Why Merge Sort is cache-friendly:
Notice the low L1 misses (8.1). Merge Sort reads and writes memory in long sequential blocks. Our CPU's prefetcher loves this—it loads data into cache before our ask for it.

The Hidden cost of insertion sort:
Low branch misprediction(1.4%) but terrible time.Why?? It does O(n²)
comparisions.Each comparsion is cheap,but there are _billions
_ of them. At n=1 million,Insertion Sort does ~5×10¹¹ comparisons. That's half a trillion.

The Decision Tree: Which Sort Should We Actually Use?

Based on these results,here's my practical guide:

Scenario 1: You're sorting fewer than 50 items

Use Insertion Sort.
Don't overthink it. The overhead of calling a sophisticated algorithm will dwarf the actual sorting work.

Scenario 2: You're sorting integers or fixed-width keys, and memory isn't tight
Use Radix Sort (LSD).
For n > 10,000, Radix Sort wins. I've used this in financial tick processors where sorting millions of timestamps is the bottleneck. It's a game-changer.

Scenario 3: You're sorting arbitrary comparable objects (strings, structs, custom classes)
**Use Timsort if available (Python, Java, C#).**
Use std::sort (C++) or Introsort otherwise.
These hybrid algorithms handle nearly sorted data gracefully and degrade to O(n log n) in worst cases.

Scenario 4: You need guaranteed O(n log n) and in-place sorting (real-time systems)
Use Heap Sort.
It's not the fastest (2-3x slower than Quick Sort), but it never blows up. Flight software, medical devices, and game engines use Heap Sort for critical paths.

Scenario 5: Your data is almost always nearly sorted
Use Timsort or Insertion Sort.
Seriously. Insertion Sort on a 95% sorted array of 1 million elements takes ~10 seconds (vs. 108 seconds random). That's usable. Timsort takes ~0.1 seconds. That's magic.

Common Myths,Debunked

Myth 1: "Quick Sort is always fastest on average"
Not anymore,On modern hardware,Radix Sort beats it for integers.For general data,TimSort often matches or beats Quick Sort while providing stability and adaptive performance.

Myth 2:"O(nlogn) means they're roughly the same"
False:Constants matter enormously.At n=1 billion,the difference between 10n log n and 2n log n is hours of CPU time.Memory access patterns matter more than operation counts.

Myth 3:"Bubble Sort is useless"
Actually,it's not completely useless.Bubble Sort has one niche:it detects when an array is already sorted in O(n) time with minimal overhead.If we have to sort an array that we suspect might already be sorted but can't gurrantee it,a single pass of Bubble Sort(or better,a single pass of Insertion Sort) is a cheap check.

Myth 4:"Parallel sorting is always faster"
Only for n>~10 million. The overhead of spawning threads and merging results kills performance on smaller arrays. Also, memory bandwidth becomes the bottleneck--eight cores fighting over DDR5 can't sort eight times faster.

Real-World Examples

Python's sort() is TimSort
This is why sorting a list of 10 million integers in Python takes ~2 seconds despite Python being slow. Timsort's C implementation is a marvel. Python's sort is often faster than hand-rolled C++ Quick Sort for many real-World distributions.

PostgreSQL uses a hybrid
PostgreSQL uses a varaiation of TimSort for in-memory sorting,falling back to merge sort for disk-based operations.They tunedthe run detection for database workloads(lots of nearly sorted indexes)

Chorme's V8 engine
Javascript's array.prototype.sort() used to be Quick SOrt. In 2018,V8 switched to TimSort.Sorting performance on nearly sorted arrays improved by 5x.

How to Run Your Own Benchmarks

Now,test on your hardware and your data. Here's a minimal C++ benchmark harness:

#include <chrono>
#include <algorithm>
#include <vector>
#include <random>

template<typename SortFunc>
double benchmark(SortFunc sort_func, std::vector<int> data) {
    auto start = std::chrono::high_resolution_clock::now();
    sort_func(data.begin(), data.end());
    auto end = std::chrono::high_resolution_clock::now();
    return std::chrono::duration<double>(end - start).count();
}

int main() {
    const size_t n = 10'000'000;
    std::vector<int> data(n);
    std::mt19937 rng(42);
    std::uniform_int_distribution<int> dist(0, n);

    for (auto& x : data) x = dist(rng);

    double time = benchmark([](auto begin, auto end) {
        std::sort(begin, end);  // std::sort
    }, data);

    std::cout << "Time: " << time << " seconds\n";
}

Compile with: g++ -O3 -march=native bench.cpp -o bench

For microarchitecture counters: perf stat -e cache-misses,branch-misses ./bench

Conclusion:So, What's the Fastest Sorting Algorithm?

It depends. But here's your cheat sheet:

Small data (<50 items): Insertion Sort
Large integers (>1 million): Radix Sort
Nearly sorted data: Timsort (14x faster than Quick Sort)
Don't know your data: std::sort (C++) or Python's sort()
Real-time guaranteed: Heap Sort After benchmarking 10 algorithms across 268 million elements,one thing is clear:Algorithm textbook need a rewrite.Asymptotic complexity (O(nlogn) vs O(n²))still matters,but branch predictability and cache locality now matter more.

Modern CPUs are not abstract RAM machines.They're complex beasts with predectors,prefetchers,and pipelines.The algorithms that respext this reality--Radix Sort's sequential streaming,TimSort run detection,Merge Sort's cache-friendly merging--win where theory says they shouldn't.

For 90% of developers,the default sort in our language is fine.It's already hybrid,already tuned.But for the rest--database engineersmgane devs,HPC programmers,financial tick processors--knowing these trade-offs can turn 45- minute pipelines into 5-minutes ones.