Project Info

Hive AI Agents

Inspiration

aIn just a few clicks, Hive AI Agents transforms plain-English directives into fully tested, documented, containerized micro-services and then dynamically stitches them into complex, multi-step workflows under a root orchestrator. Built on Flask, Docker, Google Cloud Run, and powered by Gemini and Anthropic LLMs, it learns which peers to include via a custom LLM-guided CSV slicing and self-optimizes through recursive agent creation—no manual wiring, no boilerplate. Inspiration We saw a growing trend in treating AI “agents” as first-class microservices that can be composed into larger workflows—borrowing best practices from event-driven microservices architecture and EDA patterns to scale agents reliably. At the same time, leaders like Meta predict that AI will function as a mid-level engineer by 2025, writing and reviewing code in real time. We wanted to build a meta-AI: an AI that not only writes code but manages, tests, deploys, and orchestrates its own creations.

What it does

Automated Agent Generation: Users post a JSON prompt (“Create an agent that summarizes research papers…”), and the backend spins up a new Flask microservice, complete with Pydantic validation, pytest suites, documentation, Docker packaging, and a Cloud Run deployment—all via LLMs. Hierarchical Orchestration: A top-level “ResearchMaster” agent exposes /research-master, accepts a pipeline of registered agents, calls each in sequence, and returns a full execution trace or error details. Service Registry & Semantic Discovery: Every agent’s metadata is appended to agents.csv and a REST /registry endpoint—allowing GPT to pick which peers to include contextually, thus avoiding prompt bloat and ensuring relevance.

How we built it

We chose Flask for its minimal footprint and ease of writing microservices. Each generated agent lives in its own folder, and we use os.makedirs(..., exist_ok=True) to avoid mkdir collisions. pipreqs (with --mode no-pin) auto-generates requirements.txt without strict version pins—preventing deployment breakage on numpy upgrades. For orchestration we integrated Orkes Conductor via the Python SDK, defining three tasks (choose_or_create_agent, ask_agent, log_usage) and a simple DAG—all running alongside Flask in the same container. Containers deploy to Google Cloud Run with a --revision-suffix to enforce unique revisions on every build.

Challenges we ran into

Name collisions & idempotency: Re-deploying the same agent name caused Cloud Run ALREADY_EXISTS errors; fixed by adding a random suffix per deploy. Prompt context bloat: Feeding the entire registry to GPT exceeded token limits; solved with a GPT-guided CSV slicer that asks an assistant which agents matter most, then clamps to 30 rows. Silent failures: Initial 500s from uncaught exceptions left us blind; we added a global sys.excepthook to log full stack traces and wrapped each expensive step (build_agent, gcloud, ping_gpt) in try/except blocks for clear JSON errors.

Accomplishments we're proud of

Recursive agent creators: We built agents that generate agents—e.g. documentation generators, test writers, and even a new agent factory—demonstrating true self-improvement. Seamless orchestration: The three-node Conductor workflow immediately visualizes each request’s path in the Orkes UI, complete with retries, SLA timeouts, and audit logs. Plug-and-play registry: Judges can hit /registry in a browser, see every agent spun up, and chain them in new pipelines on the fly.

What we learned

Microservices patterns like the Service Registry are invaluable for AI workflows—treat agents as replaceable, discoverable services rather than monolithic code. Prompt engineering is just as critical in system architecture: crafting clear system prompts and fallback logic can make or break reliability under token constraints. DevOps for AI requires new guardrails (constraints files, revision suffixes, file locks) to handle the unpredictability of LLM-generated code.

What's next

We plan to add parallel fan-out, where multiple agent variants run concurrently and the platform selects the best output. We’ll explore dynamic sub-workflows that fork mid-pipeline based on runtime signals. Finally, we aim to launch a dashboard UI to visualize agent trees, live executions, and semantic-search-powered recommendations—all in real time.

Calhacks-2025-Backend

Overview

Calhacks-2025-Backend is an advanced AI-driven platform designed to create, manage, and orchestrate AI agents—automatically. It is an "AI agent to create AI agents," enabling users, researchers, and developers to automate complex workflows by dynamically generating, deploying, and coordinating specialized micro-agents for a wide range of tasks.

What Does This Project Do?

1. Automated Agent Creation

Natural Language to Agent: Users can describe the functionality they want in plain English, and the system will generate a new AI agent (microservice) tailored to that description.
End-to-End Pipeline: The platform handles everything from code generation, testing, and documentation to containerization and cloud deployment—without manual intervention.

2. Hierarchical Agent Orchestration

Root Orchestrator: At the top level, a "ResearchMaster" agent coordinates a hierarchy of sub-agents, each responsible for a specific task in a larger workflow (e.g., scholarly research, data analysis, report generation).
Dynamic Composition: Agents can be composed, nested, and chained together, allowing for the creation of complex, multi-step pipelines.

3. Specialized Micro-Agents

Task-Specific Agents: The system can generate agents for a wide variety of tasks, such as:
- Crawling and parsing research papers from online databases
- Extracting and deduplicating citations
- Downloading and processing PDFs
- Running machine learning models and statistical analyses
- Generating summaries, visualizations, and reports
- Handling notifications, scheduling, and resource monitoring
Plug-and-Play: Each agent is a self-contained microservice with its own API, documentation, and health checks.

4. Agent Registry and Discovery

Centralized Registry: All created agents are registered with metadata, documentation, and endpoints, making them discoverable and reusable for future workflows.
Semantic Search: Users can search for existing agents by describing their needs, and the system will recommend the most relevant agents based on semantic similarity.

5. Automated Documentation and Testing

Auto-Generated Docs: Every agent comes with automatically generated documentation, including usage examples and API references.
Continuous Testing: Agents are tested automatically before deployment to ensure reliability and correctness.

6. Cloud-Native Deployment

Containerization: Each agent is packaged as a Docker container.
One-Click Cloud Deploy: Agents are deployed to the cloud (e.g., Google Cloud Run) with public endpoints, ready to be integrated into larger systems.

7. Extensible and Modular

Custom Pipelines: Users can build custom pipelines by chaining together existing agents or creating new ones on demand.
Integration Ready: Agents can interact with external APIs, databases, and other services as needed.

8. Example Use Case: Scholarly Research Pipeline

The platform can automatically build an end-to-end research assistant that:

Crawls academic databases for papers
Extracts and cleans metadata, citations, and content
Runs topic modeling and trend analysis
Generates executive summaries and visualizations
Notifies users of new insights via email or Slack

9. Interactive Q&A and Visualization

Question Answering: Specialized agents can answer user questions about the research dataset, fetch relevant document snippets, and maintain conversational context.
Data Visualization: Agents can generate charts, graphs, and dashboards from analysis results.

10. Security, Monitoring, and Maintenance

Access Control: Agents can enforce API key and role-based access controls.
Resource Monitoring: The system tracks resource usage and health of all agents, with automated alerts and restarts on failure.
Automated Cleanup: Old logs, temporary files, and unused resources are pruned automatically.

Key Features at a Glance

AI that builds AI: Describe what you want, and the system creates, tests, documents, and deploys a new agent for you.
Hierarchical orchestration: Build complex workflows by composing specialized agents.
Registry and search: Discover and reuse agents with semantic search.
Cloud-native: Agents are containerized and deployed with public endpoints.
Automated documentation and testing: Every agent is production-ready out of the box.
Extensible: Easily add new capabilities or integrate with external systems.

Who Is This For?

Researchers: Automate literature reviews, data extraction, and analysis.
Developers: Rapidly prototype and deploy new AI-powered microservices.
Organizations: Build scalable, maintainable AI workflows with minimal manual effort.

Example: Creating a New Agent

Describe your agent:
"Create an agent that summarizes research papers and emails the summary to my team."
The system will:
- Generate the code for the agent
- Test and document it
- Deploy it to the cloud
- Register it for future use
Result:
You get a ready-to-use API endpoint for your new agent, complete with documentation and integration options.

Why Is This Unique?

Meta-AI: This is not just an AI agent—it is an AI that creates, manages, and orchestrates other AI agents, enabling a new level of automation and scalability.
No manual coding required: Go from idea to deployed microservice in minutes, using only natural language.
Self-improving: The system can generate agents to improve itself, such as documentation generators, test writers, and even new agent creators. This recursive capability means the platform can evolve and expand its own ecosystem of agents over time, adapting to new requirements and domains with minimal human intervention.

Summary

Calhacks-2025-Backend is a groundbreaking platform that automates the creation, deployment, and orchestration of AI agents. By leveraging natural language, users can rapidly build complex, production-ready AI workflows—without writing code or managing infrastructure. The system's modular, extensible, and self-improving architecture makes it ideal for research, development, and enterprise automation.

Getting Started

For installation, setup, and API usage instructions, please see the Usage Guide (to be completed).

License

MIT License (or specify your license here)

Contact

For questions, feature requests, or contributions, please open an issue or contact the maintainers.

Calhacks-2025-Backend: AI that builds AI—so you can focus on what matters most.

Analysis

Compare with all teams

View

Metric

shay
6

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

PythonIn code
FlaskClaimed
Google GeminiClaimed

1 of 3 appear in the indexed code. 2 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

48 KB

Source files

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