Project Info

VibePrompting

Inspiration

With bigtech embracing AI agentic models in their workflow and working towards seamless integration with the infrastructure, there can be many errors during this phase. We wanted to work on this very phase of shifting and deploying AI models and also not break production while doing it. There are several cases wherein agents do not perform to their full potential due to reasons completely unrelated to the design or deployment but due to improper prompting. Even though it may seem like debugging these cases can be straightforward, our team has experienced designing near perfect workflows (of course from a human standpoint) and can still have erratic results due to semantic differences and language processing errors. That is how we thought of VibePrompting. We aim to automate the entire phase of designing agentic workflows.

What it does

VibePrompting is a dashboard which takes as input the AI model that the user is working on, and works on refining the workflow to help the AI model perform better. Our product has the following features: Real time AI agent refinement: On uploading the agent to the platform the user can see the workflow and input commands to customise the agent without the additional burden of overcoming precise prompting. Enabling editing different configs of the agent: Our platform allows the user to revise specific part of the field of the json config of the agent thereby giving the user more control and flexibility and mimicking the experience of working on the json itself rather than a black box intermediary which is not the best experience for devs. Version control and activity logs: We enabled version control features like branching and building off from different branches so that the dev can easily test out models made from the different branches rather than struggle with figuring the most optimised prompts which give the best results. The platform even has a log history highlighting the different changes made for better UI. Reinforcement learning with workflow performance metrics: We used RL to analyse the performance of different agents designed by the user and automatically improve the agentic prompts under the hood.

How we built it

We built a robust frontend using Next.js, React, and TypeScript. The responsive frontend features an interactive graph for managing prompts, an AI-powered interface for modifying the prompts, and a JSON editor. The interface is styled with TailwindCSS and uses Framer Motion for smooth animations. The backend server is built with Flask and Python, which is designed to handle the infrastructure logic, version control, and branching for agent workflows. The backend provides API endpoints that integrate with Gemini API and custom Gemini agents to refine prompts and apply reinforcement learning based on feedback loops to improve user prompts. It features a versioning system with branching and history logs, allowing users to track and manage different agent versions. The server seamlessly interacts with Google ADK, enabling users to run tests, refine their agents, and switch between the dashboard and ADK for custom evaluations.

Challenges we ran into

Managing complex state: One of the major challenges was creating our own version control software for tracking changes. This meant maintaining history of the different changes in the activity log. We needed to work on maintaining the different states of the agentic workflows as well as a way to quickly and seamlessly transition between them. The logic behind this took a lot of time to streamline and develop. Integration with google ADK: While working on this platform there were a lot of design considerations in terms of the dev kit to be used and how we could integrate it into our platform. One of the errors we faces was triggering the google adk every time the user changes the workflow.

Accomplishments we're proud of

Finishing our project in 24 hours 🥳 Integrating reinforcement learning with real-time prompt refinement Implementing our own version control system

What's next

The next focus for Vibe Prompting is to step out of the MVP and scale the infrastructure to enable traffic and deployment. Currently, our platform allows agent development in the Google ADK framework but we will be working on compatibility with more frameworks. We will also be working on making the version control more seamless and improve the state changes to make them faster.

VibePrompting for AI Agents

Transform your Google ADK agents with intelligent prompting and dynamic conversation flows.

Features

AI Agent Enhancement: Upload your Google ADK agent and enhance it with intelligent prompting capabilities
Dynamic Conversations: Create branching conversation flows and dynamic agent responses
Real-time Processing: Process and modify your agents in real-time with instant feedback
File Upload: Upload ZIP files containing Google ADK agent folders for processing

Getting Started

Prerequisites

Python 3.8+
Node.js 18+
Google ADK (Agent Development Kit)

Installation

Clone the repository:

git clone <repository-url>
cd BerkeleyAI

Install backend dependencies:

pip install -r requirements.txt

Install frontend dependencies:

cd frontend
npm install

Running the Application

Start the Flask backend (from the project root):

python app.py

Start the Next.js frontend (from the frontend folder):

cd frontend
npm run dev

Open your browser and navigate to http://localhost:3000

Usage

Landing Page: Visit the root URL to see the VibePrompting landing page
Upload Agent: Upload a ZIP file containing your Google ADK agent folder
Process Agent: Use the train interface to enhance your agent with intelligent prompting
Navigate: Use the navigation to switch between the landing page and the main application

File Upload

The application accepts ZIP files containing Google ADK agent folders. The upload process:

Validates the file is a ZIP archive
Extracts the contents to a unique directory
Identifies agent configuration files
Stores the upload information for processing

API Endpoints

POST /upload_agent - Upload Google ADK agent ZIP file
POST /process_json/general/<session_id>/<node_id> - Process JSON
GET /history/<session_id>/<node_id> - Retrieve processing history
POST /retrigger_adk_web - Restart ADK web server

Project Structure

BerkeleyAI/
├── app.py                      # Flask backend server
├── prompt.py                   # Prompt processing logic
├── requirements.txt            # Python dependencies
├── uploads/                    # Uploaded agent files
├── history/                    # Processing history (per session)
├── hotels_com_api_agent/       # Example agent implementation
│   ├── __init__.py
│   ├── agent.py
│   ├── agent.json
│   └── tools/
│       ├── get_hotel_details_endpoint.py
│       ├── search_hotel_destination_endpoint.py
│       └── search_hotels_endpoint.py
├── frontend/                   # Next.js frontend
│   ├── app/                    # App router pages and layout
│   │   ├── layout.tsx
│   │   ├── globals.css
│   │   ├── page.tsx
│   │   ├── landing.tsx
│   │   ├── History.tsx
│   │   ├── AgentEditor.tsx
│   │   ├── ChatInput.tsx
│   │   ├── Logs.tsx
│   │   └── train/
│   ├── components/             # UI components
│   │   └── ui/
│   │       ├── button.tsx
│   │       ├── input.tsx
│   │       ├── scroll-area.tsx
│   │       └── select.tsx
│   ├── lib/                    # Utilities and types
│   │   ├── agent.json
│   │   ├── types.ts
│   │   └── utils.ts
│   ├── public/                 # Static assets (if any)
│   ├── package.json            # Frontend dependencies
│   ├── tsconfig.json           # TypeScript config
│   └── ... (other config files)
├── __init__.py
├── adk                         # (ADK integration stub)
└── .venv/                      # (optional, for Python virtual environment)

Technologies Used

Backend: Flask, Python
Frontend: Next.js 15, React 19, TypeScript
UI: Tailwind CSS, Radix UI
Agent Framework: Google ADK

For more details, see the frontend/README.md for frontend-specific development and customization notes.

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

CSSIn code
FlaskIn code
Next.jsIn code
PythonIn code
ReactIn code
Tailwind CSSIn code
TypeScriptIn code
Google GeminiClaimed

7 of 8 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

114 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.