Project Info
[The Interaction Company of California] Build with Poke (Challenge 1: iPhone Air for everyone in the team Challenge 2: iPhone 17 Pro for everyone in the team Challenge 3: iPhone Air for everyone in the team Bonus: up to $100k in cash)
The Orchestration Company of Palo Alto
Inspiration
Have you ever had to manage 6 or 7 Claude Code instances at once? Have you ever felt like there's not enough space on your screen for all of the apps you need to code? Fear no more, introducing the Orchestration Company of Palo Alto! What It Does We allow you to manage all of your coding agents through a brand-new AR interface. Instead of having to constantly switch tabs, babysit Claude Code instances, and doomscrolling Twitter until your Cursor prompt finished, we allow you to hyper-accelerate your productivity through this new coding interface in using Apple Vision Pro. How We Built It For a technical diagram, please refer to the last photo. It helps better explain what is going on in our app. Apple Vision Pro is integrated into this simulator on visionOS: the user is placed in an office environment - floor, cubicles, and desks - and a set of agents is represented by spawning one desk per agent. The 3D world grows on demand: one agent at one desk at launch, and requesting another background task spawns one more agent at a new desk. The immersive experience is built with Xcode, SwiftUI, and an app-wide state model (AppModel) that holds agentCount and immersiveSpaceState. ContentView provides the 2D UI (Enter immersive space and Build an AI agent), while ImmersiveView renders the 3D office and dynamically allocates desks. This single source of truth both defines how many agents exist and ensures actions like adding agents are only available when the user is in the immersive space, so the simulation stays in sync with the Vision Pro session state. We have a TreeHacks Fix Agent MCP (Model Context Protocol) server. It’s implemented with FastMCP and exposes tools such as run_fix, run_analysis, and run_fix_default_repo so callers can trigger Modal sandbox runs and Claude Agent SDK fixes over the network. The server listens on localhost (and tunnels to Poke UI) and uses the streamable HTTP transport : clients send HTTP requests to /mcp and the MCP protocol runs over HTTP with Server-Sent Events (SSE) for streaming. So communication is HTTP/SSE, not WebSockets - one HTTP request can open a stream for server-to-client updates (e.g. tool progress or long agent output). The test client uses mcp to get a read/write pair and a ClientSession for initialize(), list_tools(), and call_tool(). The FastAPI backend acts as an MCP client: it connects to an MCP server (e.g. MCP_HTTP_URL, possibly a separate process or the same poke-mcp on another port) via mcp.client.http.http_client, then calls the run_fix tool with the user’s instruction and optional repo URL and returns the tool result as text. visionOS or any client → FastAPI /fix → MCP client session (HTTP) → poke-mcp (streamable HTTP on 8765) → FastMCP tools → Modal sandbox + Claude Agent. The streaming is handled by the MCP streamable HTTP/SSE transport. Challenges We Ran Into Working with VisionOS is very non-linear - we were very new to it, didn't know how to properly implement some of the more complicated aspects of our hack (and had to opt-in for hackier solutions), and didn't properly understand some of the technical limitations we might run into later on. Accomplishments That We're Proud Of This required learning a lot of brand-new tech that we'd never worked with before - working with multi-turn agents and building what (for most of us) was our first-ever AR hack. We also wanted to make the design feel warm and inviting. We designed animated assets to give the hack a whimsical feel, and we hope that it makes you feel at home :) What We Learned We learned that building hacks for the fun of it all is awesome, and we'll definitely doing it again. VisionOS is also really difficult to work with - we should budget more time to iron out technical issues. What's Next for The Orchestration Company of Palo Alto Build, break, ship, and dream :) Also go back to Waterloo and lock in for exams after TreeHacks is over. Please review our technical diagram (last photo) to check out the technical complexity of our hack! OpenAI: Artificial Intelligence Track We used OpenAI models for speech-to-text and text-to-speech which allows for communication between the user and the multi-turn agent. The multi-agent system itself is run by an orchestrator agent, which uses a custom MCP to spin up code sandboxes for remote code execution. Inside the sandboxes, we run a coding agent in a harness to be able to make changes to the codebase and put up a PR. Finally, we use AI to validate that the changes made by the agent were valid - the AI traverses the webpage for frontend fixes and tests expected behaviour. Anthropic: Human Flourishing Track It's evident that humans are reaching a limit where we receive more signals than we can handle. Engineer switch tabs 24/7 to supervise their coding agents. Employees report that they feel "more overstimulated than ever". The need is clear - we need a way to scale the way we process signals. This project is a first attempt on that - we implemented a thesis we had about the future of software engineering (that most engineers will be product engineers, and this medium creates enough space for folks to easily supervise their agents), and created this MVP project to demonstrate it. Modal: Sandbox Challenge As we spin up coding agents to modify new/existing parts of the codebase, we need to be able to apply these changes in an isolated environment. We use sandboxes to create a brand new coding environment, spin up a coding agent inside of it, clone the existing repo, apply the engineering fix, put up a PR, and double check that the expected behaviour is met through browser automations. Sandboxes are a central piece of this - without them, we wouldn't be able to make changes in isolation,. Anthropic: Claude Agent SDK It's evident that humans are reaching a limit where we receive more signals than we can handle. Engineer switch tabs 24/7 to supervise their coding agents. Employees report that they feel "more overstimulated than ever". The need is clear - we need a way to scale the way we process signals, and we started by reimagining what an agent orchestration interface might look like. For this project, we needed to spin up coding agents that make large scale changes to the codebase. To implement these agents, we used the Claude Agent SDK to create an agent, which would implement the requested change, and then put up a PR showcasing it. Human Capital: Fellowship Prize It's evident that humans are reaching a limit where we receive more signals than we can handle. Engineer switch tabs 24/7 to supervise their coding agents. Employees report that they feel "more overstimulated than ever". The need is clear - we need a way to scale the way we process signals. This project is a first attempt on that - we implemented a thesis we had about the future of software engineering (that most engineers will be product engineers, and this medium creates enough space for folks to easily supervise their agents), and created this MVP project to demonstrate it. We're a team of four Waterloo friends with varying backgrounds, and we'd be open to potentially continuing this project through the fellowship! Greylock: Best Multi-Turn Agent In order to make this project work, we needed an orchestrator. The orchestrator is a multi-turn agent with persistent context across terms, consistent personality, and the ability to make educated decisions on what to do. We were able to create a system where a persistent, multi-turn agent, uses MCPs to spin up sandboxes with coding agents inside, which are able to act on instructions and implement fixes to an existing codebase. Interaction: Build With Poke Most Useful: It's evident that humans are reaching a limit where we receive more signals than we can handle. Engineer switch tabs 24/7 to supervise their coding agents. Employees report that they feel "more overstimulated than ever". The need is clear - we need a way to scale the way we process signals, so we took a first-pass at what a coding IDE run by a conversational assistant (Poke) would look like. Most Technically Complex: Please take a look at the technical diagram (last photo). It shows how complex our system really is :) Most Viral: We did everything we could to make the project go viral. PFA the platforms which we posted / interacted on, and the metrics we reached: In-Person: ran into a bunch of people, got them to try our product! Twitter/X: 6,200+ interactions LinkedIn: 13,000+ impressions, 153 likes, 16 comments, 2 reposts Decagon: Best Conversation Assistant Our project is an implementation of what a coding interface would look like if it was a conversational assistant. We implemented a multi-turn agent with persistent context across terms, consistent personality, and the ability to make educated decisions on what to do. It helps you with your tasks, and can refer to previous conversions (either relevantly, or to make fun of you). We were able to create a system where this persistent, multi-turn agent, uses MCPs to spin up sandboxes with coding agents inside, which are able to act on instructions and implement fixes to an existing codebase, and then the multi-turn agent can discuss their results. Browserbase: Best Web Automation with Stagehand The biggest engineering problem at startups is that the pace at which senior engineers review code is much slower than the speed at which junior engineers can generate it using AI. To tackle this problem, we used Browserbase to tackle this issue by implementing fix validation. Using Stagehand, we are able to automatically traverse websites, and validate that the intended result was achieved. We also show the Browserbase recording of the agentic testing of a user's changes once the PR is put up by the agent, and this helps validate that the agent's changes are legit.
Treehacks
FastAPI server that takes a text-input (fix instruction), calls an MCP server, which scaffolds a Modal sandbox with the Claude Agent SDK, clones a sample repo, and runs the agent to implement the fix.
Architecture
- FastAPI (
server/):POST /fixwith{"text_input": "Fix the bug in auth.py", "repo_url": "https://..."}. Calls the MCP server over stdio. - MCP server (
mcp_server/): Exposes toolrun_fix(instruction, repo_url). When invoked, creates a Modal sandbox, clones the repo, runs Claude Agent SDK with the instruction (Read/Edit/Bash/Glob/Grep), returns output. - Sample repo: Default is
https://github.com/modal-labs/modal-examples. You can add your own and passrepo_urlin the request.
Setup
-
From repo root, create a venv and install deps for both server and MCP:
python -m venv .venv source .venv/bin/activate # or .venv\Scripts\activate on Windows pip install -r server/requirements.txt pip install -r mcp_server/requirements.txt -
Modal:
pip install modalandmodal token new(or setMODAL_TOKEN_ID/MODAL_TOKEN_SECRET). -
Anthropic: Create a Modal secret for the sandbox so the agent can call Claude:
modal secret create anthropic-secret ANTHROPIC_API_KEY=sk-ant-...Or set
ANTHROPIC_API_KEYin your env; the runner will pass it into the sandbox when no Modal secret exists. -
Run FastAPI (from repo root so
python -m mcp_server.mainworks):uvicorn server.main:app --reload -
Call the API:
curl -X POST http://127.0.0.1:8000/fix \ -H "Content-Type: application/json" \ -d '{"text_input": "List all Python files in this repo"}'With your own repo:
curl -X POST http://127.0.0.1:8000/fix \ -H "Content-Type: application/json" \ -d '{"text_input": "Fix the login bug in auth.py", "repo_url": "https://github.com/you/your-sample-repo"}'
Docker (server + MCP server)
This project can run the FastAPI server and the MCP server as separate services. The MCP server is exposed over Streamable HTTP at /mcp on port 8001.
-
Create an env file with your secrets (or export these in your shell):
cat > .env <<'EOF' ANTHROPIC_API_KEY=sk-ant-... MODAL_TOKEN_ID=... MODAL_TOKEN_SECRET=... EOF -
Build and run with Docker Compose (starts both
apiandmcp):docker compose up --build -
Call the API (same as above):
curl -X POST http://127.0.0.1:8000/fix \ -H "Content-Type: application/json" \ -d '{"text_input": "List all Python files in this repo"}'
Notes:
- The containers need outbound network access for
git cloneand the Modal sandbox. - The MCP HTTP endpoint is
http://127.0.0.1:8001/mcp. - The FastAPI server uses
MCP_HTTP_URL(default:http://127.0.0.1:8001/mcp) to reach the MCP server.
Optional: your sample repo
Create a small repo with a deliberate bug (e.g. a broken test or a bug in one file). Push it to GitHub and pass its URL as repo_url. The agent will clone it in the sandbox and apply the fix from text_input.
Poke MCP Integration
To integrate this MCP server with Poke (Streamable HTTP):
- Go to
https://poke.com/settings/connections/integrations/new. - Use the verified MCP server template for 1-click deploy:
https://github.com/InteractionCo/mcp-server-template. - Configure your MCP connection in Poke after deployment.
If you want to run this repo directly instead of the template, point Poke to:
http://<your-host>:8001/mcp (this is served by python -m mcp_server.http_server).
To send messages to Poke programmatically:
Bash
API_KEY="your-api-key-here"
MESSAGE="Hello from HackMIT!"
response=$(curl 'https://poke.com/api/v1/inbound-sms/webhook' \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-X POST \
-d "{\"message\": \"$MESSAGE\"}")
echo $response
TypeScript
const API_KEY = 'your-api-key-here';
const MESSAGE = 'Hello from HackMIT!';
const response = await fetch('https://poke.com/api/v1/inbound-sms/webhook', {
method: 'POST',
headers: {
'Authorization': `Bearer ${API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ message: MESSAGE })
});
const data = await response.json();
console.log(data);
Python
import requests
API_KEY = 'your-api-key-here'
MESSAGE = 'Hello from HackMIT!'
response = requests.post(
'https://poke.com/api/v1/inbound-sms/webhook',
headers={
'Authorization': f'Bearer {API_KEY}',
'Content-Type': 'application/json'
},
json={'message': MESSAGE}
)
print(response.json())
Voice service (chat.db poller + STT/TTS endpoints)
This repo includes a local voice service at voice-server.mjs that does:
- Initialize a new
Pokeclient on startup. - Read latest
message.date/ROWIDforPOKE_HANDLE_IDas the startup checkpoint. - Poll
chat.dbevery few seconds for new inbound messages from that handle. - Queue inbound messages in memory.
- Expose endpoints to run one recording turn, STT, and TTS.
Run it from repo root:
npm install
npm run voice
For auto-restart on .env or voice-server.mjs changes during development:
npm run voice:dev
Required env vars:
POKE_API_KEYOPENAI_API_KEYPOKE_HANDLE_ID(Messageshandle_idfor Poke contact)
Optional env vars:
POKE_SESSION_BOOT_MESSAGE(sent once to Poke on startup)STT_MODEL(defaultgpt-4o-mini-transcribe)TTS_MODEL(defaultgpt-4o-mini-tts)TTS_VOICE(defaultalloy)TTS_SPEED(default1.0)TTS_RESPONSE_FORMAT(wavorpcm; default auto:pcmwithffplay, elsewav)TTS_BATCH_QUEUE(defaulttrue; when true, queued inbound messages are concatenated and spoken together)TTS_BATCH_SEPARATOR(default" "; separator used between concatenated queued messages)SOUND_EFFECTS_ENABLED(defaulttrue)SOUND_EFFECTS_DIR(default./sound-effects)START_RECORDING_SOUND(defaultstart-recording.mp3)STOP_RECORDING_SOUND(defaultstop-recording.mp3)NO_RECORDING_SOUND(defaultno-recording.mp3)MIN_AUDIO_BYTES(default8000)CHAT_DB_PATH(default~/Library/Messages/chat.db)CHAT_POLL_MS(default1000)RESPONSE_TIMEOUT_MS(default120000)VOICE_HTTP_PORT(default8787)
Endpoints:
POST /record-once(record -> STT -> send to Poke -> await next inbound chat.db message -> optional TTS talkback)POST /sttwith{ "audioPath": "/abs/path/to/file.wav" }POST /ttswith{ "text": "hello" }GET /queueandPOST /queue/speak-nextGET /health
Local system tools needed for audio I/O:
rec(SoX) for recording with silence detectionafplay(macOS) orffplayfor playback
Project layout
treehacks/
├── server/ # FastAPI app
│ ├── main.py # POST /fix → MCP client → run_fix
│ └── requirements.txt
├── mcp_server/ # MCP server (stdio)
│ ├── main.py # FastMCP, run_fix tool
│ ├── agent_runner.py # Modal sandbox + Claude Agent SDK
│ └── requirements.txt
└── README.md
Analysis
View
Metric
- 31
- 14
- 10
- 2
- 1
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
- AnthropicIn code
- ExpressIn code
- FastAPIIn code
- OpenAIIn code
- PythonIn code
- SwiftIn code
- DockerClaimed
- JavaScriptClaimed
- Next.jsClaimed
- TypeScriptClaimed
- VercelClaimed
6 of 11 appear in the indexed code. 5 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.
AI coding agents
- CursorCommits
Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.
Codebase size
Source size
231 KB
Source files
46
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
FO214/treehacks
153 files · 4.1 MB · @ ab9f65e
Structure
API & routing
13 files · 8%Request entry points: routes, handlers and controllers.
Application logic
82 files · 54%Domain rules, services and shared utilities.
+4 more
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
- Python54%
- Swift28%
- Markdown15%
- Shell3%
- YAML0%
Share of indexed source by file size. Binary and vendored files are excluded.
Dependencies
package/package.json
npm · 10- @anthropic-ai/claude-agent-sdk
- +9 more
server/requirements.txt
pypi · 10- fastapi
- groq
- httpx
- matplotlib
- mcp
- openai
- pydantic
- python-dotenv
- tiktoken
- uvicorn[standard]
poke-mcp/requirements.txt
pypi · 7- anthropic
- browserbase
- fastmcp
- modal
- playwright
- python-dotenv
- stagehand
package.json
npm · 5- dotenv
- express
- groq-sdk
- openai
- poke
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.