What Are Agent Frameworks and Tooling?

Agent frameworks and tooling are the developer infrastructure that makes it possible to build, deploy, and connect AI agents. If agent harnesses are the autonomous actors in the economy, frameworks and tooling are the construction materials: the SDKs, protocols, platforms, and developer environments that builders use to create those actors.

Think of the gold rush analogy: the companies selling picks and shovels often profit more reliably than the miners themselves. In agentic commerce, the frameworks and tooling layer plays exactly this role. Every agent needs to be built with something, deployed somewhere, and connected to the rest of the stack. The companies providing those capabilities sit at a uniquely durable position in the value chain.

This category is the largest in the agentic commerce market map, with 36 companies spanning protocol-level infrastructure, platform-level tooling, coding agents that build other software, and specialized frameworks for specific use cases. The breadth reflects a fundamental truth: building agents is hard, and builders need help at every layer of the stack, from the communication protocols agents use to talk to each other, to the IDEs where developers write the code, to the deployment platforms where agents run in production.

Understanding this landscape is essential for anyone building in the agent economy. The framework you choose determines your agent's capabilities, its integration options, and increasingly, which commerce protocols and payment rails it can access.

Protocol-Level Infrastructure: MCP, A2A, and AXTP

At the foundation of the agent tooling stack sit the communication protocols: the standards that define how agents discover tools, talk to each other, and establish trust.

MCP (Model Context Protocol), created by Anthropic, has become the standard for connecting AI agents to external tools and data sources. MCP defines a universal interface: a tool provider implements an MCP server describing its capabilities, and any MCP-compatible agent can discover and use those tools without custom integration code. The impact is transformative: MCP turns every API, database, and service into a potential tool for any AI agent. Phantom has built an MCP server for Solana wallet operations, Cloudflare supports MCP for edge-deployed tools, and Qwen ships with native MCP support.

A2A (Agent-to-Agent protocol), developed by Google, handles the horizontal coordination between agents. While MCP connects agents to tools (a vertical relationship), A2A connects agents to other agents (a horizontal relationship). A2A defines Agent Cards: machine-readable descriptions of an agent's capabilities, pricing, and terms of service. When one agent needs to delegate a task to another, A2A provides the discovery, negotiation, and coordination infrastructure. The protocol supports synchronous and asynchronous workflows, streaming results, and multi-agent orchestration.

AXTP (Agent Transfer Protocol) focuses on secure agent-to-agent communication with cryptographic attestation. While A2A handles coordination, AXTP handles trust, ensuring that messages between agents have not been tampered with and that both parties can verify each other's identity and authorization. In commerce scenarios where money is changing hands between autonomous systems, this cryptographic trust layer is not optional.

Platform-Level Infrastructure: thirdweb, Cloudflare, and Blockrun

Above the protocol layer sit the platforms: companies providing the runtime environments, SDKs, and managed services that abstract away infrastructure complexity for agent developers.

thirdweb has positioned itself as a comprehensive Web3 development platform that increasingly serves agent builders. It provides wallet infrastructure, smart contract deployment, and payment processing tools that agents can use programmatically. For developers building commerce agents that need to interact with blockchain-based payment rails, thirdweb abstracts the complexity of multi-chain deployment, gas management, and contract interaction into clean SDK calls. The platform appears across multiple categories in the market map (Agent Frameworks & Tooling, Payment Processors, and Wallets & Tooling), reflecting its broad utility.

Cloudflare brings something unique to the agent tooling stack: a global edge network optimized for agent workloads. As a founding member of the x402 Foundation, Cloudflare has integrated machine payment support directly into its edge infrastructure. This means any website or API deployed on Cloudflare can accept agent payments with minimal code changes. Beyond payments, Cloudflare provides Workers for agent logic execution, Durable Objects for stateful agent sessions, and AI inference at the edge, forming a complete runtime environment for agents that need low-latency, globally distributed execution.

Blockrun focuses on blockchain-native agent deployment, providing infrastructure specifically designed for agents that need to interact with on-chain systems. Rather than forcing developers to manage node connections, RPC endpoints, and transaction signing manually, Blockrun abstracts these into a deployment platform where agents can be built and launched with blockchain interactions as first-class primitives.

Coding Agents: Building Software That Builds Software

One of the most distinctive subcategories within Agent Frameworks & Tooling is coding agents: AI-powered development environments that help developers build software, including building other agents. This creates a powerful recursive loop: coding agents are both tools in the framework category and potential users of every other category in the market map.

Claude Code by Anthropic is a terminal-based coding agent that operates directly in the developer's environment, reading codebases, writing code, running tests, and managing git workflows autonomously. For agent developers, Claude Code can scaffold entire agent projects, implement payment integrations, and iterate on complex multi-step agent logic, effectively serving as a force multiplier for building commerce agents.

Cursor has redefined the IDE experience by embedding AI deeply into the code editing workflow. Rather than switching between a chat interface and an editor, Cursor provides AI-assisted coding directly in the editor with full codebase context. For agent development, this means faster iteration on agent logic, better code quality through AI-assisted review, and the ability to refactor complex agent systems with confidence.

Devin by Cognition Labs represents the most autonomous end of the coding agent spectrum, acting as a fully autonomous software engineer that can plan, implement, test, and debug entire features. Windsurf, OpenHands, and Cline offer similar capabilities with different approaches to autonomy and user control. GitHub Copilot brings AI coding assistance to the largest developer platform in the world, while Codex CLI by OpenAI provides terminal-based coding capabilities. Replit Agent integrates AI development directly into a cloud IDE with instant deployment.

Goose by Block (formerly Square) brings an interesting commerce perspective: it is a coding agent built by a payments company, reflecting the convergence of developer tooling and financial infrastructure. Droyd and twit.sh round out the category with specialized approaches to AI-assisted development.

Specialized Frameworks for Specific Use Cases

Beyond the broad platform players and coding agents, a growing number of frameworks target specific niches in the agent economy.

Bankr provides a framework specifically designed for building financial agents: agents that interact with DeFi protocols, manage portfolios, execute trades, and handle complex financial workflows. Rather than building generic agent infrastructure that happens to work for finance, Bankr starts from financial use cases and builds tooling that understands concepts like slippage, gas optimization, MEV protection, and regulatory compliance natively.

Starkbot Cloud offers a managed platform for deploying agents on StarkNet, providing infrastructure for agents that need to operate within the StarkNet ecosystem's zero-knowledge proof architecture. This specialization matters because agents operating on different blockchain architectures face fundamentally different constraints and opportunities.

RevaPay AI bridges the gap between agent frameworks and payment infrastructure, providing tooling specifically for building agents that process payments. Rather than requiring developers to separately integrate a framework (for agent logic) and a payment processor (for transactions), RevaPay AI combines both into a unified developer experience.

Beep, Fluid, and Frames each address different aspects of agent development, ranging from agent communication patterns to workflow orchestration to user interface generation for agent interactions. Conway Research focuses on the research side, providing tools for analyzing and improving agent behavior in production.

Security and Trust Tooling

As agents gain more autonomy and handle more money, the tooling for securing them becomes critical. Several companies in the Agent Frameworks & Tooling category focus specifically on making agents safer and more trustworthy.

Quick Intel provides real-time security analysis for blockchain interactions, helping agents verify that smart contracts they interact with are not malicious before executing transactions. For commerce agents that autonomously interact with on-chain protocols, this kind of pre-transaction security check is essential; an agent that sends funds to a malicious contract cannot undo the transaction.

t54.ai operates at the intersection of identity and tooling, providing infrastructure for building agents with verifiable identity and trust scores. This matters for the frameworks category because trust is not just a feature; it is a prerequisite for agents that handle money. Framework-level trust tooling means that agent builders can add identity verification and reputation management without building it from scratch.

Corbits provides tools for building and deploying agents with built-in compliance and audit capabilities. For enterprise agent deployments where regulatory requirements mandate transaction logging, access controls, and audit trails, compliance tooling at the framework level is far more efficient than bolting it on after the fact.

Visa's presence in the Agent Frameworks & Tooling category reflects the payments giant's strategy of providing developer tools that embed Visa's payment capabilities directly into agent frameworks. Through its Intelligent Commerce initiative, Visa offers APIs and SDKs that let agent developers integrate card payments, tokenization, and fraud detection into their agents, bringing traditional payment infrastructure into the agent tooling ecosystem.

Orchestration and Workflow Platforms

Building a single agent is one thing. Orchestrating multiple agents into coherent workflows is another challenge entirely. Several frameworks in this category specifically address multi-agent coordination.

Questflow provides a visual workflow builder for orchestrating multi-agent systems. Rather than writing code to coordinate agent-to-agent interactions, Questflow lets developers design agent workflows visually by connecting agents, defining handoff conditions, managing state, and monitoring execution. This is particularly valuable for commerce workflows that involve multiple agents (a research agent, a comparison agent, a purchasing agent, and a verification agent working together on a single transaction).

OpenServ takes a different approach to orchestration, providing a marketplace where agents can discover and hire other agents for subtasks. This is orchestration through market mechanisms rather than explicit workflow design: an agent that needs a capability it does not have can find and engage another agent that does, with OpenServ handling the discovery, negotiation, and payment coordination.

NEAR brings blockchain-native orchestration to agent workflows, leveraging the NEAR protocol's sharding architecture for high-throughput agent coordination. For agent workflows that need to execute across multiple blockchain networks, NEAR's cross-chain capabilities provide a coordination layer that works across ecosystem boundaries.

ClawHub serves as a registry and deployment platform for agent components, similar to how npm serves as a package registry for JavaScript. Agent developers can publish, discover, and reuse agent components, reducing the need to build everything from scratch and enabling a composable approach to agent development.

The Picks-and-Shovels Analogy: Why This Category Matters

The Agent Frameworks & Tooling category is the largest in the agentic commerce market map for a reason: every other category depends on it.

• Payment processors need frameworks to build their agents.
• Identity providers need tooling to integrate their verification services.
• Commerce platforms need developer environments to create shopping experiences.
• Wallet providers need SDKs that agent developers can call without deep blockchain expertise.

This creates a powerful dynamic. Framework companies do not need to bet on which payment protocol wins, which blockchain dominates, or which agent harness becomes the standard. They need to make it easy to build agents, and builders will come regardless of which specific stack they choose.

The analogy to the early web is instructive. In the 1990s and 2000s, the companies that built web frameworks (Rails, Django, Spring), developer tools (IDEs, debuggers, profilers), and infrastructure platforms (AWS, Heroku) created enormous value, often more than the individual websites and applications built on top of them. The same dynamic is playing out in agent commerce.

The 36 companies in this category span every layer of the developer experience: protocols for agent communication, platforms for agent deployment, IDEs for agent development, and specialized frameworks for specific domains. The diversity reflects the immaturity of the market; there is no dominant full-stack framework yet, so builders must assemble their own stack from multiple tools. As the market matures, expect consolidation: platform players will absorb protocol-level features, and the best specialized frameworks will either become standards or get acquired.

Choosing the Right Framework for Your Agent

For developers entering the agentic commerce space, the framework choice is one of the most consequential decisions you will make. Here is a practical framework for thinking about it.

If your agent primarily needs to use external tools and APIs, start with MCP. It is the most widely adopted standard for agent-to-tool communication, supported by every major model provider, and the ecosystem of MCP servers is growing rapidly. MCP gives your agent access to wallets, databases, APIs, and services through a universal interface.

If your agent needs to coordinate with other agents, add A2A. Agent-to-agent coordination is fundamentally different from tool use; it involves negotiation, delegation, and asynchronous workflows. A2A provides the primitives for these interactions. If trust between agents is critical (as it always is in commerce), layer AXTP on top for cryptographic attestation.

If you are building on blockchain payment rails, consider thirdweb for multi-chain compatibility or Blockrun for blockchain-native deployment. These platforms abstract the complexity of on-chain interactions, letting you focus on agent logic rather than transaction mechanics.

If you are building a financial agent, look at Bankr or Starkbot Cloud for domain-specific tooling that understands financial primitives natively. If you need enterprise-grade compliance, Corbits provides framework-level audit and compliance capabilities.

For the development environment itself, Claude Code, Cursor, and Devin each represent different points on the autonomy spectrum. Claude Code excels in terminal-based workflows with deep codebase understanding. Cursor provides the best integrated editor experience. Devin offers the highest level of autonomy for entire feature implementation. Many teams use multiple coding agents for different tasks.

The build-vs-buy decision is also critical. Assembling a custom stack from individual protocols and libraries gives you maximum flexibility but requires significant engineering investment. Using a platform like thirdweb or Cloudflare gives you faster time-to-market but ties you to that platform's capabilities and limitations. There is no universally right answer; the choice depends on your team's expertise, your timeline, and how specialized your agent's requirements are.

Key Companies Building the Agent Tooling Layer

The 36 companies in the Agent Frameworks & Tooling category can be grouped into four tiers based on their role in the stack.

• Protocol tier: MCP (Anthropic), A2A (Google), and AXTP provide the communication standards that all other tooling builds on. These are the open protocols that define how agents discover, communicate, and trust each other.

• Platform tier: thirdweb, Cloudflare, and Blockrun provide managed infrastructure for agent deployment and execution. Visa provides enterprise payment integration tooling. NEAR offers blockchain-native coordination. These platforms abstract infrastructure complexity, letting developers focus on agent logic.

• Development tier: Claude Code (Anthropic), Cursor, Devin (Cognition Labs), Windsurf, OpenHands, Cline, Goose (Block), Codex CLI (OpenAI), GitHub Copilot, Replit Agent, Droyd, and twit.sh provide the IDEs and coding agents where agent development actually happens. This is the largest subcategory, reflecting the intense competition in AI-assisted development.

• Specialized tier: Bankr (financial agents), Starkbot Cloud (StarkNet agents), RevaPay AI (payment agents), Beep, Fluid, Frames, Dexter, Conway Research, Quick Intel (security), t54.ai (identity), Corbits (compliance), OpenServ (orchestration marketplace), Questflow (workflow orchestration), ClawHub (component registry), and Daydreams provide domain-specific tooling for particular use cases.

The breadth of this category is both its strength and its challenge. Developers have an extraordinary range of options, but navigating 36 companies across four tiers requires a clear understanding of what you are building and where you need the most help.

The Build-vs-Buy Decision in Agent Development

One of the most important decisions for agent builders is how much to build from scratch versus how much to leverage existing frameworks and platforms. This decision has different implications at each layer of the stack.

At the protocol layer, the answer is almost always adopt, not build. MCP and A2A are open standards with broad adoption; reimplementing them provides no advantage and creates compatibility problems. Use the official SDKs and build on the established protocols.

At the platform layer, the decision is more nuanced. Using thirdweb or Cloudflare gets you to market faster, but you inherit their abstractions and limitations. Building directly on blockchain RPCs and compute providers gives you more control but requires more engineering. The right choice depends on how much customization you need and whether the platform's abstractions match your use case.

At the development tooling layer, most teams benefit from using established coding agents (Claude Code, Cursor, or Devin) rather than building internal tooling. The rate of improvement in these tools far exceeds what any individual team could achieve, and the productivity gains from AI-assisted development compound over time.

At the specialized layer, the build-vs-buy decision is most case-specific. If you are building a DeFi agent, Bankr's financial primitives may save months of development. If you are building a general-purpose commerce agent, you may need to assemble your own specialized tooling from lower-level components.

The key insight is that the agent economy rewards composability. The most successful agent builders are not the ones who build everything from scratch; they are the ones who assemble the right combination of protocols, platforms, and tools for their specific use case, and then focus their custom development on the unique logic that differentiates their agent.

The Future of Agent Frameworks and Tooling

The agent tooling landscape is evolving rapidly, and several trends will shape its next phase.

1. Consolidation is inevitable. Thirty-six companies in a single category is a sign of early-market fragmentation, not sustainable diversity. Expect platform players to absorb protocol-level features (Cloudflare adding native A2A support, thirdweb integrating AXTP), coding agents to expand into deployment platforms (Replit Agent already combines development and hosting), and specialized frameworks to be acquired by or merge with broader platforms.

2. The line between coding agents and agent frameworks will blur. Today, Claude Code helps you write the code for an agent. Tomorrow, it may directly deploy and manage agents in production. The distinction between "tool that helps you build agents" and "platform that runs agents" is already collapsing.

3. Interoperability will become table stakes. Frameworks that only work with one model provider, one blockchain, or one payment protocol will lose to frameworks that work with many. The winning platforms will be the ones that make it easy to swap out components: change your model provider without rewriting your agent logic, switch payment rails without rebuilding your commerce flow.

4. Security and compliance tooling will move from specialized add-on to core feature. As agents handle more money and operate in more regulated environments, every framework will need built-in support for transaction monitoring, compliance reporting, and security auditing. Companies like Quick Intel, t54.ai, and Corbits are building capabilities that will eventually be expected features of every major framework.

For builders entering the space today, the practical advice is: start with the protocol layer (MCP + A2A), choose one platform that matches your deployment model (thirdweb for blockchain-heavy, Cloudflare for web-heavy), pick a coding agent that fits your workflow, and add specialized tooling only when your specific use case demands it. Build composably, swap freely, and expect the landscape to look very different in twelve months.