Inspiration
Most AI products are built around one chatbot. We wanted to explore a different idea: what if using AI felt more like managing a team?
Bullpen was inspired by how real teams divide work between specialists. A researcher gathers information, a writer creates content, and a designer turns that content into visuals.
Instead of relying on one AI model to do everything, Bullpen allows users to create specialized AI agents and assign tasks based on their strengths.
The name Bullpen represents a group of specialists who are ready to step in whenever their skills are needed.
What it does
Bullpen is a platform for creating and managing a personalized AI workforce.
Users can:
- Describe their business and automatically generate a suggested AI team.
- Create agents with unique names, roles, specialties, instructions, tones, and context.
- Choose a Gemini model for each agent.
- Assign tasks to a specific agent.
- Let an orchestrator choose the best agent or group of agents for a task.
- Connect agents so one agent’s output becomes another agent’s input.
- Track the progress and results of each workflow.
- Give agents feedback that can improve future tasks.
- Generate both text and images.
In a multi-agent workflow, each agent completes part of the task and passes its work to the next agent. This allows each specialist to build on the work completed before them.
How we built it
We built the frontend using React and Vite. The application includes pages for onboarding, agent management, advanced settings, task creation, progress tracking, and feedback.
The backend uses Node.js and Express. It handles creating and updating agents, managing tasks, generating teams, improving instructions, and turning feedback into reusable context.
We used the Google Gemini API to:
- Select the best agent for a task.
- Create multi-agent workflows.
- Generate responses from specialized agents.
- Suggest an AI team based on a business description.
- Improve task prompts and agent instructions.
- Recommend context updates based on user feedback.
Agents can depend on one another, so Bullpen makes sure they run in the correct order and prevents circular workflows.
We also used Google Imagen for agents that generate images.
Agent and task data is stored in Upstash Redis, allowing the information to remain available across Vercel’s serverless functions.
The complete application is deployed through Vercel.
Challenges we ran into
One of our biggest challenges was multi-agent orchestration.
Bullpen needed to:
- Understand the user’s task.
- Select the correct agent or agents.
- Determine the order in which the agents should work.
- Pass results between agents.
- Display progress to the user.
Serverless storage was another challenge. Our original in-memory storage worked locally, but data could disappear when Vercel sent requests to different serverless instances.
We solved this by moving agent and task data into Upstash Redis.
We also experienced differences between local Express routing and Vercel’s production routing. Some endpoints initially returned 404 Not Found errors. We fixed this by creating specific serverless entry points for those routes.
Another challenge was model availability. Some Gemini model names that previously worked were not available for newer API keys. We tested the available models and updated Bullpen to use supported alternatives.
Finally, we worked to make a complicated AI system feel simple. Instead of showing users dependency graphs and technical functions, Bullpen presents agents as employees, instructions as responsibilities, and the orchestrator as a manager.
Accomplishments that we're proud of
We are proud that Bullpen is more than a collection of separate chatbots. Its agents can work together through connected workflows and build on one another’s results.
We are especially proud of:
- Building a working multi-agent orchestration system.
- Supporting custom instructions, models, context, and specialties for each agent.
- Automatically creating a suggested team based on a user’s business.
- Allowing feedback to improve an agent’s future behavior.
- Storing agent and task data in a serverless environment.
- Supporting both text and image generation.
- Creating a polished interface that makes advanced AI concepts easier to understand.
- Building and deploying the project within a limited hackathon timeframe.
What we learned
We learned that building a reliable AI product requires more than sending a prompt to a model.
Storage, validation, orchestration, routing, error handling, and user experience are just as important as the generated response.
We also learned that serverless systems must be designed around stateless execution. Any information that needs to remain available between requests must be stored outside an individual serverless function.
Most importantly, we learned that complicated AI systems are easier to understand when they are presented through a familiar idea. Users do not need to understand dependency graphs or technical workflows. They can simply build a team, assign work, and review the results.
What's next for Bullpen
Next, we want to expand Bullpen with:
- User accounts and separate workspaces.
- Integrations with email, calendars, cloud storage, and business tools.
- Scheduled and recurring tasks.
- Shared organizational knowledge.
- Agent performance analytics.
- Version history for agent instructions and context.
- Human approval steps inside workflows.
- Parallel execution for agents that can work independently.
- More reliable processing for long-running tasks.
Our long-term vision is for Bullpen to become a complete workspace where anyone can build, manage, and continuously improve their own AI team.
Log in or sign up for Devpost to join the conversation.