Building AI agents used to be the domain of specialized engineers who could navigate complex APIs and manage brittle integrations. That’s changing fast.
Why visual programming matters for AI
Most AI development today happens in code editors, where developers string together API calls and manage data flows through scripts. You write code to make an LLM API call, process the response, maybe call another service, and chain these operations together. It works, but it’s slow and opaque. When something breaks, you’re hunting through logs trying to figure out what went wrong three steps back in your chain.
Visual programming environments take a completely different approach. Instead of writing code, you drag and drop components that represent different operations and connect them with connectors that show how data flows between them. Think of it like wiring together components on a circuit board, except each component represents an AI operation like a call to an LLM API or processing data.
This isn’t a new concept in software development, but it’s particularly powerful for AI workflows because these systems often involve complex chains of operations that are hard to visualize in traditional code.
Rivet’s approach to visual AI
Rivet, launched in 2023, applies visual programming specifically to AI agent development. Instead of writing scripts to manage AI workflows, developers build them by connecting nodes in a graphical interface. Each node represents a specific operation: construct a prompt; process a json response; make a tool call; call can external service.
The visual approach makes debugging intuitive because you can see exactly where your workflow breaks down. When an AI agent behaves unexpectedly, you’re not digging through stack traces. You’re looking at a flowchart that shows you precisely which node produced unexpected output.
The project has attracted nearly 4,000 GitHub stars, but more importantly, it’s solving a real problem. Developers report building AI agents in days instead of weeks. The visual interface eliminates much of the cognitive overhead that comes with managing complex AI workflows in traditional code.
What makes Rivet different
In a crowded field of AI development tools including LangGraph and Gumloop, Rivet is particularly powerful for complex agent development. Here’s why:
First, Rivet is completely model-agnostic. Unlike platforms that lock you into specific AI providers or cloud services, Rivet works with any LLM from any major providers like Anthropic, Google or OpenAI etc. This means developers can choose the best model for each specific task without being constrained by their development environment.
Second, the platform’s real-time workflow tracking capability sets it apart. Developers can watch their AI agents think and act in real-time, seeing data flow through each node and understanding exactly how decisions are made. This level of visibility is crucial for debugging and developing complex multi-step, multi-agent behaviors.
But perhaps most importantly, Rivet’s ability to nest graphs within graphs enables unprecedented modularity in AI development. Complex workflows can be broken down into reusable components that can be combined and recombined. As the Rivet team explains, this allows developers to “build AI software comparable to a complex lego project that’d take months to make in a matter of days, one brick at a time.”
This modularity shines when prototyping new AI products that require quick iteration loops and extensive prompt chaining. The visual interface makes it easy to experiment with different approaches, tweak individual components, and rapidly test new ideas without getting bogged down in code refactoring.
Rivet also has a robust plugin marketplace, allowing authors to extend the functionality of Rivet, such as adding new nodes that you can use in graphs. Users can utilize existing plugins like Anthropic, HuggingFace, or MongoDB, or add their own custom plugins – letting developers build in functionality from their favorite tools or databases.
Finally, being open source gives Rivet a significant advantage over proprietary alternatives. Developers get a cost-free solution while being able to contribute to and extend the platform. This creates a virtuous cycle where the community improves the tool for everyone.
The integration nightmare
But even with better development tools, AI agents face a fundamental challenge: connecting to the services they need to be useful. Today, every integration is custom work. Your agent needs to read from Google Drive, post to Slack, and update GitHub? That’s three different APIs, three authentication systems, three sets of documentation to master.
This is where most AI projects get stuck. The AI part is relatively straightforward now. The integration work is still a mess. Enter Model Context Protocol.
Understanding Model Context Protocol (MCP)
The Model Context Protocol, or MCP, is a standardized way for AI systems to securely connect to and interact with data sources and tools. Think of it as a universal translator that lets AI agents communicate with different services using a common language, regardless of the underlying implementation.
At its core, MCP defines a client-server architecture where AI applications (clients) can discover and use capabilities exposed by MCP servers. These servers act as bridges between the AI system and services like databases, file systems, web APIs, or business applications.
The protocol standardizes a wide array of key operations like discovery (where AI agents can query what data sources and tools are available on a given server), tool execution (where agents can use the external MCP server to perform actions like reading files, sending messages, or updating records), and prompt templates (where servers can provide reusable, tested prompts that work well with their specific services).
What makes MCP powerful is that it handles the complex parts of integrations automatically. Authentication, data formatting, error handling, and rate limiting are all managed by the MCP server provider (with communication facilitated via the protocol), so AI developers don’t have to implement these features from scratch for every service they want to connect to.
Anthropic created MCP to solve the exact problem plaguing AI development: every integration requires custom work. Instead of building separate connectors for each data or service source, developers can now build against a standard protocol. As Anthropic explained, “As the ecosystem matures, AI systems will maintain context as they move between different tools and datasets, replacing today’s fragmented integrations with a more sustainable architecture.”
The concept mirrors how HTTP made the web work by giving every website a common protocol. MCP aims to do the same thing for AI agents and services.
OpenAI recently announced they’re adopting MCP too, which signals this isn’t just an Anthropic experiment. When the two biggest AI companies agree on a standard, it usually means something important is happening.
Rivet integrates MCP support
To that end, Rivet is announcing MCP support that transforms how developers build AI agents with integrations. The integration introduces three new node types that handle the complexity of connecting to MCP-compatible services: Discovery, Tool Call, and Get Prompt.
The MCP Discovery Node enables developers to query MCP servers and discover what tools and prompts are available. This means agents can dynamically find capabilities they need rather than requiring hardcoded connections to specific services.
The MCP Tool Call Node executes functions on MCP servers, allowing agents to perform actions across external services. Whether it’s reading a file from Google Drive, posting a message to Slack, or creating an issue in GitHub, these operations become simple node connections in the visual interface.
The MCP Get Prompt Node fetches reusable prompt templates from MCP servers. This creates a standardized way for teams to share and reuse proven prompts across different AI workflows, promoting consistency and best practices.
All three nodes are built using the official MCP SDK, ensuring compatibility with the growing ecosystem of MCP-compatible services. The implementation supports the core MCP request methods that compliant servers use: tools/list, prompts/list, prompts/get, and tool execution.
What this integration enables
The practical impact is dramatic. Workflows that previously required weeks of custom integration work can now be built in hours. A customer service agent that needs to check order status in one system, update tickets in another, and send notifications through a third platform becomes a matter of connecting visual nodes rather than writing integration code.
Developers can now build agents that seamlessly interact with the official GitHub, Slack, Google Drive, and Notion MCP servers without any custom API work. As more companies adopt MCP, this library of available integrations will grow exponentially.
The visual nature of Rivet makes these integrations particularly powerful. Developers can see the entire agent workflow at a glance, understand how data flows between external services, and debug integration issues by examining the visual graph rather than parsing log files.
The vision for agentic protocols
Anthropic’s broader vision for MCP extends beyond individual integrations. They describe it as laying “the foundational architecture of a free AI market by making data and services universally accessible – and connecting them – in an AI-friendly way.”
This isn’t just about making current development easier. It’s about creating the infrastructure for what the Rivet team calls “an Internet of Agents” where autonomous systems can discover and interact with services across the web in a standardized way.
The implications go beyond developer productivity. As Anthropic noted, this represents a shift “from manually triggered machine-to-machine calls to autonomous agent-to-agent communication” where “open protocols become essential.”
Why this moment matters
We’re at an inflection point. AI agents are moving beyond simple chatbots toward systems that need to take meaningful actions across multiple services. A procurement agent analyzing vendor proposals and generating purchase orders. A content agent researching topics and scheduling social media posts. These multi-step workflows require reliable integrations with business software.
The timing isn’t accidental. Companies are starting to think about supporting MCP servers because they see the demand coming. Early adopters who build agent-friendly interfaces now will have an advantage when businesses start expecting their software to work seamlessly with AI agents.
Rivet’s MCP integration positions developers to take advantage of this shift immediately. As the ecosystem of MCP-compatible services grows, Rivet users will be able to connect to new capabilities without waiting for custom integration work.
What becomes possible
The combination of visual development and standardized integrations opens up new possibilities that were previously impractical. Developers can build agents that monitor GitHub repositories and automatically update project status in Slack when issues are resolved. Or analyze customer support patterns across multiple platforms and generate response templates with relevant documentation pulled from knowledge bases.
Complex business workflows become accessible to a much broader range of developers. A workflow that coordinates between CRM systems, project management tools, and communication platforms no longer requires deep API expertise. It becomes a visual exercise in connecting standardized components.
The key insight is accessibility. These aren’t just more powerful tools for elite engineering teams. They’re making sophisticated AI development accessible to anyone who can think through a workflow logically and connect visual nodes.
The bigger picture
This represents a fundamental shift in how we think about software development. Instead of AI as an add-on feature, we’re building infrastructure that assumes AI agents will be primary users of software services.
Rivet’s MCP integration is part of a larger transformation where business software becomes inherently agent-accessible. Companies that build MCP servers for their services are preparing for a future where AI agents are common clients, not exceptional cases.
That creates new opportunities everywhere. Developers get more powerful building blocks. Software companies get new ways for customers to interact with their platforms. And businesses get AI capabilities they can actually implement without massive engineering investments.
The path forward
Visual programming tools like Rivet won’t replace traditional coding, but they’re making AI development more accessible to more people. Standard protocols like MCP won’t solve every integration problem, but they’re eliminating the most common ones.
Rivet’s MCP integration represents both tools working together to solve real problems. The visual interface makes complex agent workflows manageable. The standardized protocol makes external integrations practical.
The transformation is already underway. The tools exist. The standards are emerging. And developers who embrace visual, standardized approaches to AI development will have a significant advantage in building agents that actually deliver value.
The future of AI development isn’t just about better models. It’s about better ways to connect those models to the world of real software and real business problems. That future is being built today, one visual node at a time.
Ironclad is not a law firm, and this post does not constitute or contain legal advice. To evaluate the accuracy, sufficiency, or reliability of the ideas and guidance reflected here, or the applicability of these materials to your business, you should consult with a licensed attorney. Use of and access to any of the resources contained within Ironclad’s site do not create an attorney-client relationship between the user and Ironclad.
