Cover_Page
Our_Moto
What_we_do
Login_Page
LaunchPad
Workflow_Designer
Specialist_Deployed_Agents
Connections
History_of_Flows

AgentForge

Build your AI team. Connect real models. Orchestrate intelligent agents.

Inspiration

AI tools are becoming increasingly capable, but most of them still work as isolated assistants. A developer might use one tool for coding, another for research, another for data analysis, and manually move information between them.

The current workflow often looks like this:

User
 |
 +--> Coding AI
 |
 +--> Research AI
 |
 +--> Data Analysis AI
 |
 +--> Creative AI
 |
 +--> Manually combine everything

We wanted to explore what happens when these capabilities are brought together as a coordinated team instead.

That idea led to AgentForge: an installable multi-agent workspace where users can create specialized AI agents, connect them to real model providers, and orchestrate them to solve complex tasks together.

                     User Goal
                        |
                        v
                  AgentForge
                        |
          +-------------+-------------+
          |             |             |
          v             v             v
     Research Agent  Code Agent   Data Agent
          |             |             |
          +-------------+-------------+
                        |
                        v
                  Final Result

Our goal was to make multi-agent systems practical and usable rather than just experimental.

Instead of hardcoding a single workflow, AgentForge allows users to decide which agents exist, what they specialize in, which models power them, and how they collaborate.

What it does

AgentForge allows users to build and run teams of specialized AI agents from a single workspace.

Users can create agents for tasks such as:

Coding        -> Development and debugging
Research      -> Information gathering
Reasoning     -> Complex problem solving
Data Analysis -> Data understanding and insights
Python        -> Python-based tasks
SQL           -> Database tasks
Creative      -> Content and idea generation
Custom        -> User-defined capabilities

Each agent can be connected to live AI models through OpenRouter or NVIDIA NIM, meaning AgentForge uses real model responses rather than simulated or predefined outputs.

Launchpad

The Launchpad allows a user to describe a goal and start a multi-agent execution.

AgentForge automatically identifies suitable agents based on their capabilities and coordinates them to complete the task.

Describe Goal
     |
     v
Analyze Task
     |
     v
Match Agent Capabilities
     |
     v
Build Agent Team
     |
     v
Execute Agents
     |
     v
Persist Results
     |
     v
Final Output

For more control, users can create custom workflows and manually decide which agents participate and whether they execute sequentially or in parallel.

Sequential Workflow

Research Agent
      |
      v
Reasoning Agent
      |
      v
Code Agent
      |
      v
Review Agent
      |
      v
Final Output

Parallel Workflow

                 User Task
                     |
        +------------+------------+
        |            |            |
        v            v            v
    Research       Data         Code
     Agent         Agent        Agent
        |            |            |
        +------------+------------+
                     |
                     v
               Combine Results
                     |
                     v
                Final Output

Every execution is stored so users can inspect previous runs, outputs, and agent traces.

Long-running tasks execute in the background, allowing users to navigate through the application without losing their progress.

AgentForge can also render complete HTML generated by agents inside a sandboxed live preview, making it possible to immediately inspect generated interfaces and prototypes.

How we built it

AgentForge follows a full-stack architecture with separate frontend, backend, database, authentication, security, and AI provider layers.

Architecture

                     User
                      |
                      v
              Next.js Frontend
                      |
                      v
               FastAPI Backend
                      |
          +-----------+-----------+
          |           |           |
          v           v           v
     Agent Logic   Supabase    Provider Router
                      |              |
              +-------+-------+      |
              |               |      |
              v               v      v
         PostgreSQL        Auth    OpenRouter
              |                    NVIDIA NIM
              v
        Supabase Vault

The backend is built using FastAPI, Python, Pydantic v2, asyncio, and SQLAlchemy.

FastAPI manages the APIs and orchestration logic, while asyncio enables multiple agents and provider requests to run efficiently.

The frontend is built with Next.js 15, TypeScript, Tailwind CSS, shadcn/ui, and Framer Motion.

It provides the interface for:

Agents       -> Create specialist AI agents
Connections  -> Configure model providers
Launchpad    -> Automatically build AI teams
Workflows    -> Design custom orchestration
Run History  -> Inspect previous executions
Live Output  -> View generated results

We use Supabase Postgres as the persistent database and Supabase Auth for authentication.

Every agent, workflow, provider route, execution, and statistic is scoped to the authenticated user.

Provider credentials are securely stored using Supabase Vault.

The browser never receives decrypted API keys or database credentials.

Provider Security Flow

User adds API key
      |
      v
Frontend
      |
      v
FastAPI Backend
      |
      v
Supabase Vault
      |
      v
Store Vault Reference
      |
      v
Agent Execution
      |
      v
OpenRouter / NVIDIA NIM

For AI inference, AgentForge uses OpenAI-compatible asynchronous clients connected to OpenRouter and NVIDIA NIM.

This allows different agents to use different models depending on their responsibilities.

We also built AgentForge as an installable Progressive Web App, allowing the workspace to behave more like a standalone application while still being accessible through the browser.

Challenges we ran into

One of the biggest challenges was designing orchestration that could work with different agents and different AI models without tightly coupling the system to one provider.

The orchestration flow looks like this:

User Task
    |
    v
Task Analysis
    |
    v
Agent Matching
    |
    +------------------+
    |                  |
    v                  v
Sequential         Parallel
Execution          Execution
    |                  |
    +--------+---------+
             |
             v
       Model Providers
             |
             v
      Structured Output
             |
             v
        Persistence

Another challenge was handling long-running multi-agent executions.

AI requests can take unpredictable amounts of time, so keeping them tied directly to a browser request would create reliability problems.

We solved this by treating tasks as background executions and persisting their state in the database.

Launch Task
    |
    v
Create Execution Record
    |
    v
Run Agents
    |
    +--> Save Progress
    |
    +--> Save Agent Traces
    |
    +--> Save Outputs
    |
    v
Update Execution Status
    |
    v
Frontend Reads Latest State

Security was another major consideration.

Provider API keys should never be exposed to the frontend. We therefore designed the system so secrets are stored through Supabase Vault and only accessed by the backend when an agent actually needs to make a provider request.

We also had to design a reliable way to restore active executions after navigation or page refresh.

Finally, coordinating sequential and parallel agent execution while keeping outputs structured required careful asynchronous programming and consistent JSON-based communication between agents.

Accomplishments that we're proud of

We are proud that AgentForge is not simply a visual demonstration of a multi-agent system.

It connects to real AI providers and performs actual model calls.

Real User Goal
      |
      v
Real Agent Selection
      |
      v
Real Model APIs
      |
      v
Real Multi-Agent Execution
      |
      v
Persisted Results

We built a flexible architecture where users can create their own agents instead of being limited to a predefined set of assistants.

We also created two levels of orchestration:

Launchpad
Goal -> Auto Agent Matching -> Execute Team

Workflows
Choose Agents -> Choose Order -> Execute Workflow

Another major accomplishment is persistence.

Agent configurations, workflows, provider routes, execution results, statistics, and traces survive navigation and application restarts instead of existing only inside a temporary chat session.

We are also proud of the security architecture.

Authentication, backend-only database access, encrypted provider credentials, and user-scoped resources were treated as fundamental parts of the platform rather than features to be added later.

Overall, we were able to turn the idea of an AI agent team into a functional full-stack workspace that users can configure, run, inspect, and extend.

What we learned

Building AgentForge taught us that multi-agent systems are not only about connecting multiple language models.

The difficult part is everything that happens between them.

                Multi-Agent System
                       |
        +--------------+--------------+
        |              |              |
        v              v              v
  Orchestration      State         Security
        |              |              |
        v              v              v
   Scheduling      Persistence      Secrets
   Dependencies    Run History      Authentication
   Parallelism     Agent Traces     User Isolation

We learned the importance of asynchronous architecture when working with multiple AI providers.

Parallel execution can significantly improve performance, but it also requires careful management of state and results.

We also gained a deeper understanding of authentication, database architecture, secret management, structured model outputs, and persistent background execution.

Most importantly, we learned that good AI orchestration requires giving users both automation and control.

                 AgentForge
                     |
          +----------+----------+
          |                     |
          v                     v
      Automation              Control
          |                     |
          v                     v
       Launchpad             Workflows
          |                     |
          v                     v
   Auto-select Agents     User-select Agents

Automatic agent selection is useful for speed, while manually configurable workflows are important when users need predictable and repeatable processes.

What's next for AgentForge

The next step for AgentForge is to move from agent orchestration toward a more complete environment for building, testing, evaluating, and deploying AI teams.

Smarter Task Decomposition

We plan to introduce smarter task decomposition so a complex objective can automatically be divided into smaller tasks and assigned to the most suitable agents.

                  Complex Goal
                       |
                       v
                 Planning Agent
                       |
          +------------+------------+
          |            |            |
          v            v            v
      Research      Analysis      Coding
          |            |            |
          v            v            v
     Research Agent Data Agent   Code Agent
          |            |            |
          +------------+------------+
                       |
                       v
                  Review Agent
                       |
                       v
                  Final Result

Agent-to-Agent Review

We also want agents to review, critique, and improve each other's outputs.

Code Agent
    |
    v
Review Agent
    |
    v
Problems Found?
   /       \
 Yes       No
  |         |
  v         v
Improve    Final Output
  |
  v
Review Again

Future versions could include:

Reusable workflow templates
Additional model providers
Richer tool integrations
Shared team workspaces
Execution analytics
Cost and token tracking
Improved agent memory
Workflow versioning
Model comparison
Agent evaluation systems
Agent-to-agent feedback loops

The Vision

Ultimately, our goal is for AgentForge to become a workspace where creating an AI team is as straightforward as creating a project.

Define Agents
     |
     v
Connect Models
     |
     v
Describe Objective
     |
     v
Orchestrate Team
     |
     v
Evaluate Results
     |
     v
Improve and Reuse