OctaForge

Main Page
Agent Working

Inspiration

Building applications with AI today is powerful, but it often feels like a black box. You provide a prompt, and code appears, but you do not see how decisions are made or how different parts of the system come together.

We wanted to explore a different approach: what if building with AI felt like working with a real engineering team? A team where different specialists discuss ideas, challenge each other, and collaborate to produce a better result.

OctaForge was built around this idea of making AI-driven development more transparent, interactive, and human-like.

What it does

OctaForge turns a simple prompt into a complete full-stack application by simulating a team of AI agents, each with a specific role.

A planning agent designs the project structure A backend agent generates APIs and server logic A frontend agent builds the user interface A security agent reviews the generated code An orchestrator coordinates the entire process

The system follows a structured multi-step pipeline:

Analyze and refine the user’s prompt Generate a concise technical brief Let agents discuss and critique the approach Combine their input into a clear plan Generate backend and frontend code Run a security review Produce testing statistics Finalize files and setup instructions

All of this is streamed live to the interface so users can observe the full development process in real time.

How we built it

OctaForge is designed as a multi-process system:

A Tauri-based desktop application handles the user interface and system integration A Python FastAPI sidecar acts as the orchestrator and manages agent execution Ollama runs local language models for most of the generation Claude (Haiku) is used for fast and accurate requirement analysis in the first step

The frontend is built with React, using Zustand for state management and Tailwind for styling. Communication between the frontend and backend happens through HTTP and server-sent events (SSE), allowing us to stream updates as the system progresses.

One important design decision was to avoid using EventSource for streaming, as it automatically reconnects and caused duplicate builds. Instead, we used fetch with ReadableStream and AbortController to maintain full control over the connection.

We also optimized performance by running the agent discussion phase in parallel using asyncio, while keeping later stages sequential to preserve dependencies between outputs.

What makes it unique

OctaForge treats AI as a team rather than a single tool. Each agent has a distinct role and contributes independently before the system reaches a final decision.

The platform also focuses heavily on transparency. Instead of hiding the process, it exposes intermediate steps such as agent feedback, decisions, and generated code.

Another key aspect is that most of the system runs locally using Ollama. This reduces reliance on cloud services and allows faster and more private execution.

Finally, the interface is designed to make the process engaging and understandable, showing progress, system activity, and results as they happen.

Challenges we ran into

One of the main challenges was building a reliable streaming system. Early versions used EventSource, which caused automatic reconnections and triggered duplicate executions. Switching to a manual streaming approach solved this issue.

Another challenge was latency. Multiple sequential model calls made the system slow. We addressed this by parallelizing the agent discussion phase, significantly reducing total runtime.

We also had to refine how agents communicated. Initial outputs were too generic, so we introduced structured prompts and personality-driven responses to make interactions more meaningful.

Managing state across multiple stages was another complexity, since each step depends on outputs from previous ones. This required careful design of the orchestration logic.

What we learned

This project helped us understand how to design and coordinate multi-agent AI systems. We learned how to build real-time streaming architectures and how to balance local and cloud-based models.

We also saw how important user experience is when working with AI. Making the process visible and interactive can significantly improve how people understand and trust the system.

What’s next

We plan to expand support for additional frameworks and languages, improve testing and deployment capabilities, and introduce a plugin system for custom agents.

We are also interested in enabling collaborative sessions where multiple users can interact with the system together.