About the Project

Inspiration

Starting a small business is often far more complicated than people expect, especially for first-time entrepreneurs, immigrants, and family-owned businesses navigating city requirements for the first time. In Glendale, California, many local business owners struggle to understand permits, licensing requirements, inspections, timelines, and startup costs because the information is fragmented across different city and state systems.

We wanted to build a platform that simplifies this process into a guided, AI-powered experience. Instead of forcing users to search through confusing government websites, Incrementum helps entrepreneurs understand exactly what they need to launch their business through personalized step-by-step guidance.

Our goal was to create something that feels approachable, modern, and genuinely useful for local communities.

What It Does

Incrementum is a lightweight multi-agent AI platform that helps entrepreneurs identify the permits, requirements, timelines, and next steps needed to launch a business in Glendale, California.

Users complete a structured questionnaire about their business idea, storefront status, food service requirements, employees, signage, and other operational details. The platform then generates:

required permits and licenses
estimated startup timelines
estimated costs
personalized launch checklists
ordered next steps
plain-English explanations of requirements

The system is designed to reduce confusion and make entrepreneurship more accessible for everyone.

How We Built It

Incrementum was built using a React + Vite frontend and a FastAPI backend organized around a lightweight multi-agent architecture.

Frontend

The frontend was built using:

React
Vite
TypeScript
Tailwind CSS
React Router
Clerk Authentication

The frontend handles:

questionnaire intake
Google sign-in
protected dashboard routing
roadmap rendering
localStorage persistence for user intake data

Clerk was integrated for secure Google authentication and protected dashboard access.

Backend

The backend was built using:

FastAPI
Python
Pydantic
Uvicorn

The backend exposes a /generate-roadmap endpoint that processes questionnaire data and generates a personalized business launch roadmap.

Multi-Agent System

We structured the backend into specialized “agent” modules that each handle a focused responsibility in the pipeline:

IntakeAgent → validates and normalizes user questionnaire data
PermitAgent → determines required permits using rule-based logic
TimelineAgent → estimates costs and launch timelines
ExplanationAgent → generates plain-English explanations and summaries
RoadmapAgent → orchestrates all agents and assembles the final roadmap response

The agents currently run in-process through FastAPI, but the architecture was intentionally designed to support migration to true distributed agents in the future using Fetch.ai uAgents.

AI Integration

We prepared the system for Gemini API integration to support:

smarter explanations
multilingual guidance
adaptive business recommendations
more conversational outputs

The current MVP uses deterministic fallback summaries to maintain reliability during development.

Challenges We Ran Into

One of the biggest challenges was balancing ambition with hackathon time constraints. We originally planned a much larger platform with analytics, marketing tools, social features, and deeper AI automation, but quickly realized that focusing on a single polished workflow would create a much stronger MVP.

Another challenge was designing the system architecture in a way that felt modular and scalable without over-engineering the project. We wanted the platform to feel like a true AI agent system while still remaining reliable enough to demo live during a hackathon.

We also had to carefully coordinate frontend and backend development simultaneously:

building questionnaire flows
handling authentication
designing API contracts
structuring agent pipelines
and generating dynamic roadmap responses

Finally, making the generated outputs feel useful and believable without relying entirely on large language models required thoughtful rule-based logic and system design.

What We Learned

Through building Incrementum, we learned:

how to design lightweight multi-agent systems
how to structure scalable FastAPI backends
how to coordinate React frontend workflows with AI pipelines
how to integrate authentication into a protected dashboard flow
how to balance AI-generated content with deterministic business logic

Most importantly, we learned that successful hackathon projects are less about building the largest system possible and more about creating a polished experience that solves a real problem clearly and effectively.