focus on isolated tasks or simple fast engineering. This approach has allowed us to build interesting applications with a single command, but we are starting to reach the limit. Simple information falls short when we deal with complex AI tasks that require multiple layers or business systems that must contribute information gradually. The race towards AGI can be seen as the measurement of parameters of existing models, coupled with the development of architecture, or the interaction of multiple models. Although scaling is expensive and limited to the capabilities of existing models, and success is unpredictable and possible at any time, the orchestration of multiple models remains the closest approach to building intelligent systems that can perform complex tasks like humans.
Another type of intelligence is the ability of agents to create other agents with minimal intervention, where the AI has the freedom to act based on the request. In this new phase, machine intelligence manages the complex plan, while a human remains in the loop to ensure safety.
Designing Machine-Machine Integration
We need a common way for machines to communicate without customizing human writing for every single connection. This is where the Model Context Protocol (MCP) becomes an important part of the stack. MCP serves as a universal interface for models to interact with existing environments, such as calling tools, downloading APIs, or querying databases. Although this may seem arbitrary, a significant amount of manual work is required by the developer to define an MCP for a model or agent.
Also, a topological framework is important to guide the concept of interaction of agents as part of an autonomous journey. Allowing agents to operate in a dirty open world leads to misidentification and bloat of required work. However, having a graph-based framework can organize the workflow. If we treat models as nodes and their interactions as edges, we can begin to visualize dependencies and data flows throughout the system. We can build on the MCP graph and blueprint to create scheduling agents that work within the framework to generate problem-solving plans by automatically breaking down complex goals into sequential tasks. The agent planner identifies what is needed, the graph-based framework organizes dependencies to avoid blind spots, and generates agents to achieve your goals; let's call them”Vibe Agents“.
Intelligence by Vibe Agents
As we transition from a standalone theory to a complete operating system, we'll need a way to turn high-level “vibe” statements into actionable graphs. The user provides a goal, and the system turns it into a team of agents working together to achieve an outcome. Unlike many multi-agent systems that communicate through free chat, Vibe Agents work within a clear graph where dependencies and action paths are built and visible. This is a problem I've been working to solve as the maintainer of the open source IntelliNode framework (Apache license). It is designed around a scheduler agent that generates a graph plan from the user's intent, then executes it by moving data between agents and collecting the final output.
IntelliNode provides a home for Vibe Agents, allowing them to not exist strictly as static documents but instead function as fluid participants within an ongoing workflow.
Vibe Agents created within IntelliNode represent our first experimental attempt at creating an autonomous layer. In short, we want to create a process where the definition of each task is done with a declarative orchestration, the definition of the desired result. Using this framework, we will allow users to create commands that allow programmed agents to accomplish more complex tasks compared to different simple tasks.
Use case: Private Industry Search-to-content
In a typical workflow, creating a deep dive report or technical article takes a lot of effort to compile search results, analyze data, and draft. Within this framework, the bottleneck in the workflow is that every action taken requires input from other layers.
When using Vibe Agents, we will be able to establish a self-organizing pipeline focused on the use of current live data. If someone asks for a high-level objective, they will provide the following one statement: “Research recent achievements in solid-state batteries from the last 30 days and produce a technical summary with a supporting diagram description”.
How the IntelliNode Framework “Vibe” works
When Architect finds this intent, instead of just generating code, it generates a custom Blueprint on-the-fly:
- Scout (Search Agent): uses google_api_key to perform real-time queries on the Internet.
- Analyst (Text Agent): processes query results and extracts all technical information from raw snippets.
- Creator (Graphic Agent): generates the final report, creates the layout or provides a visual representation of the results.
Instead of writing code and creating an API connection to execute your mission, you assign a mission to the machine and build the specialized team needed to achieve that mission.
Using Using VibeFlow
The following code shows how to handle the transition from natural language to a fully structured search and content pipeline.
1. Set up your site
Set your API keys as environment variables to authenticate Architect and standalone agents.
export OPENAI_API_KEY="your_openai_key"
export GOOGLE_API_KEY="your_google_cloud_key"
export GOOGLE_CSE_ID="your_search_engine_id"
export GEMINI_API_KEY="your_gemini_key"Install IntelliNode:
pip install intelli -q2. Start the Architect
import asyncio
import os
from intelli.flow.vibe import VibeFlow
# Initialize with planner and preferred model settings
vf = VibeFlow(
planner_api_key=os.getenv("OPENAI_API_KEY"),
planner_model="gpt-5.2",
image_model="gemini gemini-3-pro-image-preview"
)3. Define Purpose
“Vibe” is a statement of high quality. The Architect will analyze this and decide what special agents are needed to accomplish the task.
intent = (
"Create a 3-step linear flow for a 'Research-to-Content Factory': "
"1. Search: Perform a web research using ONLY 'google' as provider for solid-state battery breakthroughs in the last 30 days. "
"2. Analyst: Summarize the findings into key technical metrics. "
"3. Creator: Generate an image using 'gemini' showing a futuristic representation of these battery findings."
)
# Build the team and the visual blueprint
flow = await vf.build(intent)4. Do the Work
Signing handles orchestration, data transfer between agents, and automatic saving of all generated images and snapshots.
# Configure output directory and automatic saving
flow.output_dir = "./results"
flow.auto_save_outputs = True
# Execute the autonomous factory
results = await flow.start()
print(f"Results saved to {flow.output_dir}")Agent systems are rapidly changing from “quick tactics” to software design, and the key question is no longer whether multiple agents can work together, but how this collaboration is constrained and replicated in production. Many successful systems use chat agent-like communication, which is very useful for prototyping but difficult to imagine as the workflow becomes complex. Others take a more advanced approach to workflow, such as graph-based processing.
The idea behind Vibe Agents is to synthesize user intent into actionable and trackable graphs, so that the sequence from start to finish is visible. This means much less hand stitching and more work with the blueprints produced by this system.
References
