This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What if you could turn a research question into a structured report without hiring a research assistant, juggling multiple AI tools, or depending entirely on a proprietary AI API?

That question inspired AI Research Studio — an open-source, multi-agent AI research application built around open-weight models, local inference, and a deployable web experience.

Instead of treating AI as a single chatbot that answers a question and stops, AI Research Studio approaches research as a collaborative workflow. Specialized agents help search for information, analyze findings, write a report, and critique the result.

The idea is simple: make useful AI-powered research accessible to independent developers, students, creators, and small businesses — without making a closed AI service the only way the application can work.

What I Built

AI Research Studio is a multi-agent research workspace that turns a topic into a structured research report.

Imagine you're a student investigating a new technology, a developer evaluating a framework, or a solo founder researching a market. You may have the question, but finding reliable information, organizing it, and turning it into something useful can take hours.

🤖 AI Research Studio brings those steps into one workflow.

🔎 Four specialized agents, one research workflow

1. Search Agent — Find the signal

Searches for relevant web information using tools such as Tavily and web-content extraction. The goal is to collect material that can inform the research.

2. Reader Agent — Turn information into insight

Analyzes retrieved content, identifies important findings, and helps separate useful information from the surrounding noise.

3. Writer Agent — Build the report

Organizes the findings into a readable, structured research document rather than leaving the user with a collection of disconnected AI responses.

4. Critic Agent — Challenge the first draft

Reviews the generated report and helps improve its clarity, relevance, and quality.

Together, these agents create a research pipeline that is more deliberate than a single prompt-and-response interaction.

🎯 Who could use it — and who might pay for it?

AI Research Studio is designed around a real problem: research is valuable, but the process is time-consuming.

Potential users include:

• Students and independent learners researching unfamiliar topics.
• Developers evaluating technologies, libraries, and tools.
• Content creators preparing research-backed outlines.
• Freelancers and consultants exploring markets and organizing background research.
• Solo founders and small teams investigating competitors, trends, and business ideas.

As a side hustle, the project could evolve into a hosted research assistant, a paid premium workspace, or a customizable research tool for small teams. Potential paid features include saved research histories, richer exports, configurable agent workflows, and team workspaces.

These are possible future business models, not existing paid features. The core project is intended to remain open for experimentation and community contributions.

Demo

🚀 Try the live application:

https://atlas-ai-research-studio.onrender.com/

Open the app, enter a research topic, and explore the research workflow and generated output.

The project is hosted on Render so people can try the application through a browser instead of first installing a Python environment and configuring a local model.

Note: the hosted experience depends on the deployment configuration and availability of its connected services.

Code

💻 Explore the source code on GitHub:

https://github.com/PriyankV25/ai-research-studio

The repository is the foundation for an open-source research assistant that developers can inspect, run, customize, and extend.

I want other builders to be able to experiment with the agent workflow, try different models, add tools, and make the application their own — not just consume a black-box AI product.

How I Built It

The central technical decision was to build around open-weight AI and a multi-agent architecture, rather than making the project dependent on one closed, proprietary model endpoint.

🦙 Ollama: Open-weight AI at the core

Ollama is the local model runtime that makes the project's open-weight approach possible.

Instead of assuming that every developer must send every prompt to a hosted AI provider, the application supports configuring a compatible model through Ollama. This creates a path toward running inference on a developer's own machine and experimenting with open-weight models.

The intended local setup uses a model such as Google's Gemma family, provided the selected model is available through Ollama and supports the application's required capabilities.

A local configuration can look like this:

LLM_PROVIDER=ollama
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_MODEL=gemma3:4b

The model name is an example; the model must be downloaded through Ollama, and the application must be configured to use it.

For example:

ollama pull gemma3:4b
ollama list

The application then uses the configured local model for compatible agent operations. Actual compatibility depends on the model, its tool-calling capabilities, and the implementation of the agent workflow.

Why this matters: the model is not merely a feature added to an otherwise unrelated app. Open-weight inference creates an alternative way to power the research workflow, gives developers greater control over model selection, and makes local experimentation possible.

For this submission, the important distinction is between a model being open-weight and a model being locally executed: Gemma is an open-weight model family, while Ollama provides a convenient way to run supported models locally.

⚙️ Multi-agent orchestration

The application separates research into specialized responsibilities:

• Search for information.
• Read and analyze retrieved content.
• Write a structured report.
• Critique the result.

LangChain provides LLM and tool integrations, while the workflow's orchestration connects the individual stages. This modular approach makes it easier to experiment with different model configurations and extend the research process.

🌐 Research tools

The research workflow can use:

• Tavily for web search.
• BeautifulSoup for extracting useful content from HTML pages.

These tools provide information for the agents to analyze. They complement the language model rather than replacing it.

🖥️ Web application

The project combines a Python and Flask backend with an HTML, CSS, and JavaScript frontend. The goal is to make a multi-agent workflow approachable through a browser rather than requiring users to interact with scripts or command-line prompts.

☁️ Render: From local experiment to accessible application

Render hosts the web application and makes the interface available through a public URL.

This is particularly important for a side-hustle project: an idea is much easier to evaluate when someone can open it, try it, and understand its value without recreating the entire development environment.

The hosted deployment can use a cloud-compatible LLM configuration, while Ollama remains an option for local inference. Running Ollama on a developer's computer does not automatically make that model available to a remote Render service; remote inference requires a separately reachable model endpoint.

🎨 Gamma: Communicating the idea

Gamma supports the presentation side of the project by helping communicate the product concept, workflow, and value proposition in a visual format.

For a research product, communication matters alongside implementation: users need to understand what the agents do, why the workflow is useful, and how the open-source model approach fits into the design.

Technology summary

Why Does Open Innovation Matter?

Open innovation is not just a licensing choice for AI Research Studio. It changes who can experiment with the product and how it can evolve.

1. AI should be adaptable, not locked to one provider

A research application should not have to be permanently tied to one model provider. An open-weight approach creates room to experiment with different models and runtimes as capabilities, hardware, and project needs change.

2. Local inference expands developer control

With Ollama, developers can experiment with supported models on their own hardware. Depending on the selected setup, this can reduce reliance on external LLM inference APIs and provide more control over where prompts are processed.

It does not automatically make the entire workflow offline or private: web search and other external tools can still send data to third-party services.

3. Open source lowers the barrier to building

A developer can inspect the workflow, modify agent responsibilities, replace a model, add a research tool, or build a new interface. They do not need permission from a proprietary platform to experiment with the application's architecture.

4. A side hustle can start small and grow

A solo developer can begin with a focused research tool, share it with a community, and evolve it based on feedback. Open-source development makes that path more accessible by allowing others to contribute improvements instead of requiring every feature to come from one person.

My takeaway: the most interesting AI applications will not all be giant models or expensive platforms. Some will be focused, useful tools built by individuals who combine open models, thoughtful workflows, and accessible interfaces.

AI Research Studio is my attempt to explore that possibility.

Prize Categories

🦙 Best Use of Gemma

AI Research Studio is designed to support local inference through Ollama, creating a path for Google's open-weight Gemma models to power the research agents.

The Gemma configuration should be verified against the final tested model and deployment before submission. Local model support and the use of a particular Gemma model should be demonstrated rather than assumed.

☁️ Best Use of Render

Render hosts the project's web interface and backend, turning the research workflow into an accessible browser-based experience.

This supports the project's goal of making an open-source AI application easy to try and evaluate without requiring each visitor to set up the full development environment.

⭐ GitHub: https://github.com/PriyankV25/ai-research-studio

🚀 Live Demo: https://atlas-ai-research-studio.onrender.com/

Let's make AI research more accessible — one open-source experiment at a time.