Project Info
Inspiration
Most AI experiences today are trapped behind a monolithic chat box. But our daily lives aren't lived in text threads—they are tactile, physical, and multi-sensory. I wanted to step out of the browser and build a framework for a context-aware partner in physical space. This inspired the "Orchestra Metaphor." Instead of one giant AI trying to do everything, I envisioned a "Conductor" (a central event router) that delegates tasks to specialized, single-purpose AI agents (the "Line Cooks").
What it does
The Conductor is an open, event-driven framework for orchestrating cooperative AI agents. In this Version 0.1 MVP, the system uses a Streamlit dashboard to simulate a physical hardware trigger. When triggered, the Conductor executes a JSON "Score." Rather than executing logic itself, it simultaneously routes commands across an Event Bus to specialized agents. A single tap can trigger a Memory Agent to log the stateful interaction, a Voice Agent to speak a greeting, and a Music Agent to queue a playlist—all running concurrently.
How we built it
We adhered to a 7-Layer Multi-Agent Architecture. We built a zero-latency web dashboard using Streamlit, connected to a Python backend powered by asyncio to handle non-blocking event routing. To ensure the Conductor had "Working Memory" without the latency of a vector database, we utilized a session-scoped Python dictionary. Codex and GPT-5.6 acted as my Senior Implementation Engineers, instantly writing the asyncio.gather() logic required for concurrent multi-agent actions.
Challenges we ran into
Building an asynchronous event loop from scratch in Python is inherently complex. Managing state so that the Conductor didn't suffer from "amnesia" required careful planning. Furthermore, translating the vision of a physical cardboard prototype into a purely digital MVP required pivoting our hardware integration strategy to a web-based UI.
Accomplishments we're proud of
We successfully separated orchestration from intelligence. Building a fully functional, zero-latency Event Bus and stateful Memory cache using lightweight Python dictionaries instead of heavy databases proved that multi-agent systems can be incredibly fast.
What we learned
I learned how to deeply integrate asynchronous Python programming (asyncio) and how to use Codex as a strategic architectural partner rather than just a simple code generator.
What's next
The next step is Layer 6: Hardware Integration. We plan to move the simulation out of the browser and into our tactile cardboard enclosure, mapping physical sensors (like piezoelectric vibration sensors) to the Event Bus to bring The Conductor into the physical world.
🎼 The Conductor
An open, event-driven framework for orchestrating cooperative AI agents across physical and digital environments.
🌟 The Vision (Concept UI)
🧠 The Philosophy (The Orchestra Metaphor)
Most AI experiences today are trapped behind a monolithic chat box. "The Conductor" separates orchestration from intelligence.
- The Conductor (The Head Chef): Standing at the kitchen pass, the Conductor reads incoming order tickets and coordinates who executes them. The Conductor never executes logic itself.
- Specialized Agents (The Line Cooks): Independent modules designed to do one single task perfectly (e.g., streaming music, speech).
- The Event Bus (The Ticket Rail): The central channel where events are published. No agent talks directly to another.
📦 What We Built (Hackathon MVP v0.1)
Codex and I built a fully functional Layer 1 & 2 Prototype using Streamlit and Python asyncio.
- Concurrent Execution: Using the Score Engine, a single trigger can tell our Voice Agent to speak and our Music Agent to play a playlist simultaneously.
- Stateful Memory: A lightweight, session-scoped working memory cache that logs all events so the Conductor doesn't suffer from amnesia.
🤖 Codex Collaboration
Codex and GPT-5.6 acted as my Senior Implementation Engineers. I fed Codex our "7-Layer Architecture" as raw text, and it successfully built our asynchronous event loop. It accelerated the workflow by instantly writing the asyncio.gather() logic required for concurrent multi-agent actions, allowing me to focus on the overarching system design.
🚀 How to Run Locally
pip install -r requirements.txtstreamlit run dashboard.py
Analysis
View
Metric
- 4
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
- PythonIn code
- StreamlitIn code
- OpenAIClaimed
2 of 3 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
16 KB
Source files
6
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
falisha-shoun/Conductor-Hackathon
9 files · 19 KB · @ 45a7471
Structure
Application logic
3 files · 33%Domain rules, services and shared utilities.
Supporting
Layers are inferred from where files sit in the tree, not from reading the code. A project that names its directories unconventionally will read oddly here — open the file browser to check anything the diagram implies.
Languages
- Python66%
- Markdown34%
Share of indexed source by file size. Binary and vendored files are excluded.
Dependencies
requirements.txt
pypi · 1- streamlit
Declared in the repository’s manifests at the indexed commit. A declared package is not proof it is used, and runtime dependencies are listed first.
This project’s features have not been analysed yet.
Export this project's context (description, README, evidence, key source files) to chat with an AI agent elsewhere.