Fusion agents and apps: the first real shape of practical AGI

AI is starting to feel different. Not just smarter, but more like something you can point at a complex problem and trust to do real work end to end. Two emerging ideas are driving that shift: multi-agent "fusion" systems and agents that can build full applications on the fly.

Together, they hint at what the first practical version of AGI might look like. Not a single magical model that wakes up one day, but a system that can reason, plan, coordinate, use tools, and deliver finished outputs people can actually use.

From smarter models to smarter systems

For years, AI progress has mostly been framed in terms of models: bigger parameter counts, better benchmarks, fewer hallucinations, faster inference, stronger reasoning. That all matters—but it’s only part of the story.

What’s changing now is the focus on the system wrapped around the model. Think of the model as the brain. The real leap comes from building the body around that brain: agents, tools, infrastructure, and workflows that turn raw intelligence into useful work.

This is where two directions are starting to converge:

• Abacus-style agents that don’t just answer questions, but generate interactive apps, diagrams, and dashboards inside your workflow.

• Fusion agents that coordinate a swarm of models—some powerful, some cheap—to break down and complete complex tasks in parallel.

Why “just text” isn’t enough anymore

Most AI tools still treat text as the final product. You ask a question, you get a paragraph. Maybe some code, maybe a static diagram, but it’s all basically content.

Abacus flips that idea. Instead of stopping at an explanation, the AI builds the interface you actually need to understand, explore, or act on the answer.

Agents that build apps, not just answers

With Abacus-style agents, the output isn’t just a response—it’s an application embedded directly in the conversation. A few examples make this clear.

Explaining systems with interactive 3D models

Ask the agent to explain how data centers work and to use 3.js, and it doesn’t just describe racks and cooling systems. It generates a fully interactive 3D model of a data center right inside the interface.

You can rotate it, zoom in, and toggle layers like compute, storage, networking, cooling, power, and airflow. Click on components to see details such as server utilization, storage capacity, or power draw.

The key shift: the AI isn’t just telling you the answer. It’s building the tool you need to explore and really understand the system.

From architecture advice to real diagrams

In another demo, the agent is asked to analyze the system design of services like Instagram, Gmail, YouTube, Uber, and Amazon, then create diagrams using Lucidchart.

The agent researches each service, pulls architecture details, and generates professional diagrams: services, databases, caching layers, queues, and infrastructure components laid out like a real systems design document. The user can then edit those diagrams directly.

Again, the output is not a frozen image. It’s a living artifact inside a working environment.

Visual thinking for research and analytics

The same pattern shows up in research and analytics tasks:

• For a request on swarm intelligence in biology and multi-agent algorithms, the agent researches the topic and creates interactive Excalidraw diagrams. It maps concepts like ant colony optimization, particle swarm optimization, bee behavior, flocking rules, and stigmergy to their computational counterparts.

• For product analytics, the agent connects to tools like Amplitude, analyzes real user behavior, and builds interactive charts. You can switch chart types, explore funnels, compare revenue across platforms, and inspect retention trends—while the AI acts like an analyst who’s also building the dashboard as they go.

In all these cases, the AI isn’t just generating content. It’s creating structured visual thinking tools tailored to the task.

AI that controls infrastructure, not just documents

Abacus also points to another critical layer: infrastructure control. In one example, the user asks the system to host an open-source language model (Qwen 2.5 with 0.5B parameters) and provide a website to chat with it.

The agent then:

• Checks available resources

• Extracts model weights

• Creates the environment and installs dependencies

• Configures Nginx

• Deploys the service

• Tests it internally and externally

• Returns a working public URL

This is real DevOps work, automated. The AI isn’t just writing a deployment guide—it’s actually setting up, configuring, and exposing a live service.

When you combine this with app generation, you get a system that can research a topic, build an interface, wire it to real data or models, and deploy it for others to use.

What fusion agents are and why they matter

On the other side, Fusion agents tackle a different but equally important problem: coordination. Instead of throwing a big task at one model in a single pass, Fusion-style systems use a planner plus a swarm of worker agents.

The pattern looks like this:

• A strong planning model (for example, a top-tier closed model) breaks a complex task into smaller subtasks, assigns them, and oversees quality.

• Multiple worker agents, often using cheaper models like DeepSeek Flash, Gemma, or Kimmi, execute those subtasks in parallel.

• The planner then reviews, reconciles, and fuses all the partial results into one coherent final output.

This has two big advantages:

1. Cost: Most of the heavy lifting is done by cheaper models, while the expensive model focuses on planning, oversight, and synthesis.

2. Fit to reality: Complex work in the real world is rarely a straight line. It’s a bundle of subtasks that can often be parallelized and then merged.

How fusion agents handle real work

Fusion agents shine on tasks that naturally split into pieces: code review, bug audits, resume screening, research, and customer feedback analysis.

Parallel bug hunting in large codebases

In one demo, the system is pointed at the freeCodeCamp repository and asked to find accessibility issues across multiple front-end areas.

The planner:

• Maps the repository and identifies distinct UI regions

• Assigns each region to a different worker agent

Each worker then scans its area for issues like missing ARIA attributes, poor keyboard navigation, empty alt text, or broken accessibility patterns. Once they’re done, the planner:

• Merges the findings

• Removes duplicates and conflicts

• Applies conservative fixes

• Produces code diffs, a structured audit, explanations for each change, and notes on what it intentionally left untouched

The end result isn’t just “here are some suggestions.” It’s a set of concrete, reviewable changes and documentation—exactly what a human team would produce.

Automated pull request reviews and follow-up PRs

Another example pushes this idea further. The user asks the system to review the last 10 pull requests, look for bugs, edge cases, weak tests, security issues, and maintainability risks, then modify the code and open follow-up PRs.

The planner:

• Fetches the last 10 PRs

• Assigns each PR to a worker agent for contextual review

Workers then:

• Analyze the changes

• Suggest improvements

• Propose code modifications

The system posts review comments, generates new PRs with fixes, and runs them through CI. Again, the key is that the output is action, not just commentary.

Scaling hiring and research tasks

Fusion agents aren’t limited to code. They work just as well on structured knowledge work.

• Resume screening: A recruiter asks the system to rank 50 resumes for a QA engineer role. The agent first asks clarifying questions about the ideal profile. Then it splits the resumes into batches and sends them to worker agents. Each worker scores candidates against the criteria and returns structured results. The final output is a ranked CSV with masked candidate IDs, links to resumes, scoring breakdowns, and recommendations—a full day of human work compressed into a single workflow.

• Equity research: The agent is asked to analyze the top 50 S&P 500 stocks by market cap and build a 10-stock portfolio for a $10,000 investment. It gathers user preferences, splits the stock universe across worker agents, has them analyze companies in parallel, and then synthesizes a portfolio plus a full research report.

Turning raw feedback into product intelligence

One of the clearest examples of why multi-agent systems matter is app store review analysis. Reading 100 reviews is easy. Extracting the right patterns is hard.

Fusion agents handle this by assigning different lenses to different workers:

• One worker clusters themes and pain points

• Another pulls representative quotes

• Another turns themes into prioritized product recommendations

The planner merges everything into a product intelligence report that’s immediately useful for roadmap decisions. It’s like having a small product insights team running inside a single workflow.

Why this looks like the first real shape of AGI

Earlier systems like Fable gave people a taste of deep reasoning: an AI that could think through complex problems instead of just spitting out polished text. But reasoning alone isn’t enough.

The next step is a system that can:

• Plan work instead of answering in one shot

• Split tasks into subtasks and assign them to specialized agents

• Use tools, APIs, and external services

• Control infrastructure and deploy live systems

• Produce interactive artifacts—apps, diagrams, dashboards, research tools—rather than static text

Fusion agents and Abacus-style app generation are two sides of that same evolution:

• Fusion shows how to break down and coordinate complex work across many agents and models.

• Abacus shows how to turn the results into usable interfaces, visualizations, and deployed services.

Together, they start to look less like a single “smart model” and more like a working AGI system: a coordinated collection of capabilities that can handle end-to-end tasks in the same way a small organization would.

From impressive answers to valuable work

A year ago, much of this still felt experimental. Now we’re seeing agents that can:

• Build interactive learning tools and simulations

• Create professional architecture diagrams

• Analyze real product and user behavior data

• Deploy and expose live language models

• Mine user feedback and turn it into strategy

The shift is clear: AI is moving from impressive answers to valuable work. The real race is no longer just about who has the smartest model—it’s about who can build the most capable system around that intelligence.

If you want to start experimenting with this new wave of agents yourself, you might find it helpful to learn how to go from zero to your first AI agent in minutes, or dive deeper into how modern agent skills and tools are structured in guides like Google’s AI agents intensive on tools and real-world actions.