Auto Nexus

User Input
UI
Unstructured Graph Representation
Structured and Optimized Graph Representation
Country Node Insight: Final Import Option
Business Plan Root Node
Raw Materials Insight: Composition & Dependencies

Inspiration

In today’s fast-paced business world, turning an idea into a viable venture involves navigating complex decisions sourcing materials, evaluating global markets, understanding regulations, and aligning with strategic goals like profitability or sustainability. Most entrepreneurs struggle not due to a lack of vision, but because of fragmented, unstructured planning tools that don’t adapt to their priorities. Our inspiration stems from solving this gap: What if we could empower anyone to build a robust, tailored business plan using intelligent agents and real-time data, all through a simple input? By combining open-source LLMs, autonomous decision agents, agentic workflows and an interactive knowledge graph, we aim to make structured, data-backed business planning accessible, explainable, and adaptive—for everyone from solopreneurs to global operators.

What it does

Our platform takes a simple business idea and transforms it into a fully structured, data-driven, and interactive business plan.

Users provide two inputs: Product context - the product that the user wises to produce. Business Priorities – Key focus areas like profitability, eco-friendliness, or scalability. Location – Target location for setting up the business. Once submitted, here’s what happens: Input is stored via API into a MySQL database. A central MCP server connects to an open-source LLM to interpret the input and build a curated business strategy.

The LLM: Identifies required raw materials. Plans import and assembly sequences. Spawns a hierarchical agent system for each material, simulating expert consultants for countries, costs, logistics, and feasibility. Leverages web tools (e.g., Twilio, DuckDuckGo) and specific data sources (e.g., PDFs, CSVs, Kaggle) to inform each agent’s decisions. Each agent collaborates in a tree structure: Autonomous agents analyze costs, risks, and logistics at micro and macro levels. Aggregator agents compare options across countries and optimize for the user’s initial priorities. The best option is selected, but alternatives and justifications are preserved for transparency. The entire process is stored in a Neo4j graph database, allowing: Interactive UI visualization of decision trees. Node-level inspection showing cost, reasoning, and next-best options. Dynamic plan recomputation when users change key decisions.

Ultimately, the user receives: A detailed, visualized business plan.

How we built it

We built a modular, AI-driven architecture that transforms user inputs into a fully structured business plan through a layered pipeline of intelligent agents, decision trees, and visual representation.

Frontend & API Layer We created a simple UI that collects two types of user input: business priorities and venture descriptions. Inputs are sent via FAST API and stored in a MongoDB database for persistence and validation.

MCP Server & Agent Framework The core of the system is an MCP (Multi-Agent Control Protocol) server, designed to manage and orchestrate AI agents. The server invokes an open-source LLM (via Claude Sonnet 4) to interpret the business idea and break it down into actionable components like raw materials and import needs. Based on these components, the LLM spawns autonomous agents in a hierarchical tree structure.

Agent Behavior & Coordination Top-level aggregator agents assign countries for sourcing each raw material. For each country, expert consultant agents are created to evaluate cost, taxes, logistics, and geopolitical factors. These agents use external tools (e.g., DuckDuckGo for search) and custom pipelines to pull data from PDFs, CSVs, APIs, and Kaggle datasets.

Data Flow & Decision Encoding Each agent returns a structured JSON output, adhering to a common schema. Intermediate agent outputs are first stored in MongoDB to facilitate quick access and iterative updates. Once finalized, all outputs are transferred into Neo4j, forming a graph-based decision tree.

Visualization Layer The UI visualizes the agent decision tree using interactive graph components. Users can hover over nodes to view decisions, rationales, and alternatives and even change decisions, triggering re-evaluation and updating the full business plan dynamically. Reactivity & Scoring System Every agent decision is scored based on the user’s original business priorities (e.g., profitability vs sustainability). A change in one node propagates updates downstream—ensuring the entire business plan stays consistent with user goals.

Challenges we ran into

Agent Orchestration in MCP Server One of the core challenges was integrating multiple autonomous AI agents within the MCP server and orchestrating their execution flow. Each agent had distinct responsibilities, yet their outputs were interdependent requiring us to design a scalable, modular framework for task delegation and result aggregation.

Managing Inter-Agent Dependencies Creating a hierarchy where parent agents could dynamically spawn children, track their outputs, and make informed decisions based on them proved complex. We had to ensure that downstream agents could operate asynchronously yet in coordination with upstream logic.

Standardizing JSON Output for Aggregation Each agent’s output had to be structured in a standardized JSON schema to be aggregated and passed up the chain. Designing a universal response schema that could accommodate various decision types and data sources was critical to prevent data loss or misinterpretation.

Preprocessing and Structuring Data for Agent Use Before agents could begin their tasks, we needed a robust data processing layer to ingest and clean raw data from PDFs, CSVs, APIs, and scraped web content. Ensuring data quality, relevance, and formatting consistency was a time-consuming but essential step.

Transition from MongoDB to Graph-Based Storage Initially, we stored intermediate and final agent outputs in MongoDB for flexibility. However, representing the hierarchical relationships and agent decision flow required us to later transition to a graph database (like Neo4j) to enable real-time visualizations and node-level interactions in the UI.

Accomplishments that we're proud of

Built a Fully Functional Multi-Agent Framework We successfully implemented a dynamic multi-agent system where each agent operates autonomously, collaborates contextually, and makes decisions based on real-world data—structured through a clear parent-child hierarchy.

Seamless Integration with Open-Source LLM and Tools Our architecture integrates with open-source LLMs using LangChain and custom tools, enabling agents to fetch and process external data from APIs, search engines, PDFs, and CSVs with minimal latency.

Real-Time, Graph-Based Decision Visualization We designed an interactive UI powered by Neo4j that lets users explore each decision point in a visually intuitive tree. Users can see the reasoning behind each choice, compare with alternatives, and dynamically switch paths to regenerate the business plan.

Prioritization-Driven Decision Making By tying every decision back to user-defined priorities like profitability or sustainability, we enabled context-aware optimization throughout the entire planning process.

Automated Data Ingestion and Processing Pipeline We built a preprocessing layer capable of converting semi-structured inputs from diverse sources (e.g., Kaggle, PDF reports) into usable, agent-readable formats ensuring the system is data-rich and scalable.

Dynamic Recalculation on User Interaction One of the most powerful features is our ability to recalculate downstream decisions in real time when a user overrides any node bringing true interactivity and explainability to automated planning.

What we learned

Agent Collaboration is Not Trivial Getting AI agents to communicate effectively especially when their decisions depend on each other taught us a lot about dependency management, asynchronous task flows, and result aggregation in multi-agent systems.

LLMs Need Strong Context Anchoring Without clear system prompts and structured input formatting, open-source LLMs tend to drift. Defining guardrails and limiting their scope helped improve accuracy and task relevance.

Graph Databases Unlock Powerful Visualizations Using Neo4j allowed us to not only store relationships meaningfully but also deliver intuitive, node-based interactions in the frontend that would have been complex with relational databases.

What's next for Auto Nexus

Agent Memory and Iterative Reasoning We plan to implement long-term memory for agents so they can retain context across decisions, learn from previous interactions, and iterate on strategies without starting from scratch each time.

Mobile & Voice Interface Support We want to make Auto Nexus more accessible by launching a mobile-friendly version and integrating with voice assistants, allowing entrepreneurs to build businesses on-the-go.