Automation & Workflows

WebMCP Agent Readiness

Last updated 2026-07-31

What's new

2026-07-31

Decagon is a 24/7 AI customer service agent (AI software that helps customers like a human would) that helps businesses handle support requests quickly and in multiple languages.
Decagon not only handles customer support but also helps businesses make more money by proactively reaching out to customers for things like lease renewals.
Decagon uses a approach called "forward deployment engineering" (sending engineers to work directly with customers) to customize their AI agent for each business and gather feedback to improve their product.
As Decagon has grown quickly (from 50 to 500 people in a year), they've blurred the lines between forward deployment engineers (who work with customers) and product engineers (who build the product), making them one team.

2026-07-25

You can manage AI agents (computer programs that do tasks for you) to boost productivity, using tools like Devon AI (a software platform for managing AI agents).
Set up automations (repeated tasks done by AI agents) and create a software factory (a system that generates software automatically) to work more efficiently.
Keep your production keys (passwords for important systems) secure and separate from your AI agents to prevent mistakes or security issues.
You can control AI agents from your phone, allowing you to work remotely and manage tasks on the go.

2026-07-22

A new tool called the Model Context Protocol (MCP) (a way for AI systems to talk to each other and share information) has made it easier for developers to connect AI agents to external tools and services.
Security issues have arisen with AI agents, such as one that deleted a production database and another that exfiltrated (stole data from) almost 4,000 internal repositories using a malicious VS Code extension (a popular coding program).
To address these security concerns, the company has been experimenting with and investing in ways to secure what AI agents generate, use, and do, including using Python-based hooks (a way to trigger certain actions) to scan for security issues asynchronously (in the background) after an agent writes or modifies a file.

2026-07-16

Primed and Loaded has introduced new open-source tools, Verifiers and Primed RL libraries, to help improve AI models after they're initially trained (post-training).
They've created a global marketplace of data centers with over 10,000 GPUs (powerful computer chips) to support large-scale AI model training.
The company is working on making it easier for anyone to train and customize AI models for their specific needs, not just using existing models.
They've also introduced a new platform called Lab, which combines various tools to make AI research and model training more accessible and efficient.

2026-07-13

Building AI agents (automated tools that perform tasks) alone can lead to reinventing complex software development processes like testing and monitoring from scratch, which can be error-prone.
AI agents can produce seemingly perfect outputs that are actually incorrect or misleading, such as using generic language, making unverified claims, or duplicating old content.
To prevent these issues, it's crucial to implement gates or checks in your AI agent system, like voice contract (ensuring consistent style) and verification trails (backing up claims with evidence).
For solo builders, watching out for near-duplicate content is important to maintain originality and audience engagement.

2026-07-01

**Agentic AI engineer** (AI tools that help create and improve other AI tools, called agents) speeds up the process of building and refining AI agents, reducing the time spent on manual tasks like testing and debugging.
The process involves creating a detailed plan (spec) for the agent, building it, testing it, deploying it, monitoring its performance, diagnosing issues, and making improvements in a continuous loop.
For new agents, the process starts from scratch with a detailed plan, while for existing agents, the focus is on optimization and improvement.
This approach increases the number of agents that can be developed and deployed in a given time, making it a scalable solution for organizations looking to implement AI agents.

2026-06-25

Claude managed agents (AI workers that do tasks for you) can now run on their own schedule and safely use real passwords or API keys (secure codes that let software talk to each other), making them more useful for real work.
These agents act like employees, using your tools like email or Slack (a messaging app for teams) to complete tasks you describe in plain English, without needing you to set up complex workflows.
Claude has improved by allowing agents to run automatically and securely store sensitive information, addressing two major limitations that previously made AI agents feel like just demos or toys.
The service offers different AI models (Opus for complex tasks, Sonnet for everyday work, and Haiku for quick, cheap results) and a simple console (dashboard) to manage agents, view credits, and handle billing.

2026-06-19

An AI second brain helps organize and recall information, like notes or meeting recordings, by using files and folders that both you and AI models (like Claude or Hermes agent) can understand.
There are five levels to building an AI second brain, starting with simple file searches (Level 1) and advancing to autonomous systems (Level 5) that can trace relationships between topics.
The key to an effective AI second brain is designing it with the end in mind, ensuring that the data can be easily accessed and recalled in the future.
Begin with a simple level that fits your needs, and only advance to more complex levels if you have a specific problem to solve.

Key points

What it is

WebMCP (Web Model Context Protocol) is a proposed web standard that turns websites into structured APIs for AI agents, making it easier for them to interact with sites.
It's like a universal connector (e.g., USB-C) for AI agents to use websites, improving accuracy and reducing the need for guesswork.
Unlike regular MCP (a backend protocol from Anthropic), WebMCP is designed for browsers, letting developers expose site tools directly to AI agents.
Early tests show high accuracy (98%) and fewer data-heavy operations (89% fewer) compared to traditional scraping methods.

How to use it

Start by signing up for the WebMCP early preview program to access documentation and implementation details.
Use WebMCP tools to simplify user actions, like automatically filling forms or clicking buttons, by exposing these tools to AI agents.
Define MCP tools and transports (communication mechanisms) and host them on the web, handling authentication natively in the browser.
Create an agent, configure its environment, and give it clear instructions, using progress tracking to maintain context between sessions.

Watch out for

Treat WebMCP as an enhancement, not a starting point; ensure your website is well-structured and user-friendly first.
Avoid building exclusively for agents; the same site must serve both human users and AI agents effectively.
Be mindful of authentication; WebMCP was created to solve auth issues, so use its browser-native API carefully.
Test thoroughly and report any issues to help the WebMCP standard mature, and avoid overcomplicating your setup.

Tools named

WebMCP (a proposed web standard for turning websites into APIs for AI agents)

Lesson 1: What is WebMCP Agent Readiness and why it matters

WebMCP (Web Model Context Protocol) is a proposed web standard that turns every website into a structured API for AI agents. Think of it as the "USB-C of AI agent interactions"—a common, reliable way for agents to use websites. Unlike regular MCP (a backend protocol from Anthropic that connects AI to server-side tools), WebMCP is a front-end, browser-native protocol. It lets developers expose specific tools like JavaScript functions and HTML forms directly to in-browser AI agents. This means agents can interact with a site’s capabilities as structured, high-performance tools instead of struggling with screenshots and pixel-by-pixel guessing.

Today, most AI agents interact with web pages like "a blindfolded person uses a vending machine"—low accuracy and fragile. WebMCP solves this. Early tests show 98% accuracy and 89% fewer token-heavy operations compared to traditional scraping methods. However, it’s not production-ready yet. Real concerns exist around "prompt injection through tool descriptions" (malicious instructions hidden in tool names) and "data exfiltration through tool chaining" (agents leaking data by combining tools). The standard includes a "human in the loop API with request user interaction" as a safety layer.

Why does this matter for AI development? Because getting an agent from demo to production often takes 3 to 9 months, with teams stuck between evaluation and deployment. The gap exists because current agent-to-web interactions are brittle. WebMCP shrinks that gap by giving agents a predictable, agent-ready environment. Developers are shifting from writing code to supervising agents, and WebMCP is the infrastructure that makes reliable supervision possible. An experimental origin trial starts in Chrome 149, so now is the time to learn it if you’re building agent-powered experiences.

Sources

Lesson 2: How to use WebMCP Agent Readiness: step-by-step

To make your website agent-ready using WebMCP, start by understanding that WebMCP (a browser-native standard co-authored by Google and Microsoft) adds a JavaScript API called `navigator.modelContext`. This lets any website expose structured callable tools directly to AI agents — turning your site into a high-performance API for agents while keeping the user experience simple.

First, sign up for the WebMCP early preview program via the official blog post to get access to documentation, best practices, and implementation details. Once enrolled, you can use WebMCP tools to simplify user actions. For example, instead of a user manually filling forms or clicking buttons, your agent can call these exposed tools directly to complete tasks on their behalf.

The workflow is straightforward. You define MCP tools and transports (the mechanisms for agents to communicate with your site) and host them on the web just like a regular website. The agent can then use these tools without needing separate API keys or OAuth flows for every action — WebMCP handles authentication natively in the browser.

To get started practically: create your agent, then configure the environment (a cloud container with pre-installed packages). Give the agent a clear instruction defining how it should run. Use progress tracking (like a progress.md file) so each new agent session knows what has been done before and where to pick up.

A concrete example: if you have an e-commerce site, you can expose a "checkout" tool. An agent can call it to complete a purchase for the user, reading order details from the page and submitting them automatically. If something breaks, the agent can fix it or you can set a loop to run every 30 minutes to check and maintain functionality.

By making your website agent-ready with WebMCP, you simplify the user's experience by letting agents handle repetitive actions, while giving developers a clean, structured way to expose functionality without custom integration work.

Sources

Lesson 3: Best practices and pitfalls

When making your website agent-ready with WebMCP (a proposed web standard that turns sites into high-performance APIs for AI agents), the biggest pitfall is treating it as a starting point. As Tara Agyemang from Google explains, you should only think about WebMCP after you have a well-structured, user-friendly website in place. Simplify first: ensure your site has clean forms, clear navigation, and sensible HTML structure.

The main best practice is exposing structured tool handles instead of relying on brittle, token-heavy screen-scraping. WebMCP lets you define your site's capabilities as callable JavaScript functions and HTML forms for browser-based AI agents. This avoids the pain of separate API keys and OAuth flows just to automate clicking a button.

A common mistake is ignoring the user experience. The web is bifurcating into a human internet and an agent internet, but the same site must serve both. Human customers want persuasion and beautiful design, while agents need machine-usability. Do not build exclusively for agents.

Another pitfall is rushing without proper testing. Find friction points and bugs early, and report them to help the WebMCP standard mature. Also, avoid overcomplicating your setup — you do not need to spin up a custom runtime to ship a real agent.

Watch for foot-guns around authentication. WebMCP was originally created at Amazon to solve auth issues, so leverage its browser-native API carefully. As Michael Hablich notes, many developers already use MCP servers, but building agent interfaces requires understanding the end-to-end lifecycle: build, optimize, then deploy. Without structure, things get messy fast.

Sources