podman/docs/generated/STRATEGY.md

# PodMan — Winning strategy

**Track:** Continual Learning

**One-liner:** PodMan is the Jarvis for engineering teams: it watches every engineer's screen in realtime, fuses that live context with your GitHub state to catch merge collisions the API literally cannot see — because the changes are still unpushed on someone's laptop — and the more it watches, the better it learns who owns what and when to step in.

## Why this track
Continual Learning is the only track where PodMan's core mechanic IS the track definition, not a bolted-on framing. The other two are weaker fits and invite skepticism. (1) "Recursive Intelligence" / agents-building-agents implies PodMan should spawn or rewrite sub-agents — PodMan doesn't; claiming it would be a lie judges can smell, and you'd be compared against literal AutoML/agent-factory demos you can't out-build in 20h. (2) "The Self-Improvement Stack" is about tooling/infra that helps OTHER systems improve (eval harnesses, observability, RL pipelines) — PodMan is an end-user product, not dev infrastructure, so it reads as off-theme. (3) Continual Learning = "a system that gets more useful the longer it runs, accumulating knowledge with minimal human supervision, without catastrophic forgetting." That is exactly PodMan's loadbearing loop: it watches screens + git over a session and builds a persistent team world-model (who owns which files/features, what's in-flight, each engineer's style, recurring conflict patterns) stored in MongoDB Atlas + Voyage embeddings, and it gets measurably better at predicting collisions the more it observes. Critically, it has a SECOND, judge-pleasing learning loop that doubles as the hackathon's recursive-self-improvement theme: PodMan learns its own intervention POLICY from outcomes (was the flagged collision real? did the human accept the sync PR? did they dismiss it?), so its precision/recall improves within the demo. Two stacked learning loops (world-model + policy) let you show "it gets smarter" twice in 3 minutes, which is the single most important thing for this track. Pick Continual Learning; it is defensible, demonstrable live, and uniquely yours.

## DQ risks

- Dashboard-as-hero trap: the pod grid of live screen tiles is visually the most obvious thing on screen and is on the explicit BANNED list ('any project where a dashboard is the main feature'). If the demo opens on, lingers on, or returns to the grid as the centerpiece, a judge can bucket you as a banned dashboard project.
- Image-analyzer mislabel: 'vision model looks at screenshots' can be pattern-matched to the banned 'image analyzers' category if you describe PodMan as analyzing images rather than as a proactive multi-agent that acts on fused screen+git state.
- Private-repo / setup violation: rule requires PUBLIC repos and the demo must show ONLY hackathon-built work. Demoing against a private team repo, or wiring in a pre-existing side project, is an instant DQ.
- Team-size / pre-existing-work violation: max 4 members and NEW work only. Reusing a prior 'screen-watching agent' codebase, or showing more than 4 participants in the pod, breaks the rules.
- Faked-realtime risk: if the collision 'detection' is obviously hardcoded/scripted with no real vision+git inference, judges reading it as a canned animation undercuts both the Technicality score and the legitimacy of the demo (borderline 'show only what you built').
- Consent/recording optics: screen+mic+webcam capture of teammates can read as a privacy red flag to judges; not a formal DQ but it can sour the room if not addressed.
- MiniMax/Modular/unused-sponsor confusion: claiming prizes for tools you didn't meaningfully use (e.g. listing MiniMax or Mojo without real integration) can read as padding and hurt credibility with sponsor judges.

## DQ mitigations

- Reframe the hero as the intervention, not the grid: open the demo on a single engineer's normal coding view (IDE), NOT the pod grid. The pod grid appears only for ~3-5 seconds as 'PodMan's peripheral vision,' then collapses to a corner. The hero shot is the proactive PodMan card + voice interrupting the moment a collision is imminent. Say the words out loud: 'PodMan is a proactive agent, not a dashboard — the screens are just its eyes.'
- Always describe PodMan as an agent that UNDERSTANDS and ACTS on fused screen+git state, never as an 'image analyzer.' Lead with the action (warn / show diff / open sync PR) and the GitHub fusion, so vision is plumbing, not the product.
- Create the demo repo PUBLIC on GitHub up front; show the github.com URL on screen during the demo so judges can see it's public. Keep all code in the new /Users/karti/Desktop/Podman repo (confirmed scaffolded fresh today, empty except placeholders) — nothing pre-existing.
- Cap the visible pod at <=4 members and have exactly the hackathon team in it; state team size in the submission. Keep the git history in the public repo as proof all commits are from the hackathon window.
- Make realtime genuinely load-bearing AND legible: pipe real LiveKit screen tracks to Gemini 3.5 Flash vision, show the live transcript/inference ('I see Alice editing auth/session.ts; Bob has unpushed changes to the same file') as on-screen captions so judges SEE real inference happening, not a scripted card. Have a deterministic fallback path rehearsed in case wifi dies, but the primary run must be live.
- Add a one-line consent gate ('each engineer opts in to share') and a visible 'PodMan is watching' indicator; mention privacy-by-design in one breath. Turns a red flag into a maturity signal.
- Only claim sponsor prizes you actually integrate: DigitalOcean (deploy), LiveKit (transport), Gemini 3.5 (vision+Live API voice+Live Translate), MongoDB Atlas + Voyage (memory). Drop MiniMax/Modular from the pitch unless one is genuinely wired in; do not pad the sponsor list.

## Prize stacking

- **Best Usage of Gemini 3.5 ($5000 cash) — PRIMARY TARGET** — Make Gemini the brain on three distinct surfaces so it's undeniably the core, not a call: (1) Gemini 3.5 Flash native Computer Use + vision interprets each live screen track frame-by-frame into structured 'work intent' (file, feature, function being edited). (2) Gemini Live API drives PodMan's realtime VOICE intervention — it speaks the warning and converses ('want me to open a sync PR?'). (3) Gemini Live Translate makes the voice intervention multilingual for a distributed team — a clean, demo-able wow that almost no one else will show. Optionally use the Managed Agents / Interactions API (antigravity-preview-05-2026) to host PodMan's agent loop. On stage, explicitly enumerate 'three Gemini 3.5 surfaces' so the Gemini judge can check every box.
- **Best LiveKit** — LiveKit is the realtime spine and you should say it's irreplaceable: screen-share + mic + webcam ingest per pod member over LiveKit tracks; PodMan joins each room as an AI participant (LiveKit Agents) that consumes video tracks and publishes its voice + intervention cards back over LiveKit data channels. The MOAT line — 'unpushed changes are invisible to the GitHub API, so realtime capture is the only way' — is literally a LiveKit pitch. Show the agent as a real participant in the room.
- **Best DigitalOcean** — Deploy the PodMan backend agent + the LiveKit egress/worker + the React PWA on DigitalOcean (App Platform or a Droplet) using the $200 credits. Put the public demo URL on a DO-hosted domain and show it in the browser during the demo. Mention the deploy target by name in the submission. Keep MongoDB on Atlas (separate sponsor) and embeddings on Voyage — that's fine, DO hosts the compute.
- **MongoDB Atlas + Voyage AI (memory/continual-learning credibility)** — This is what makes the Continual Learning claim TRUE and technical, not hand-wavy. Store the evolving team world-model + intervention-outcome log in Atlas; embed work-intent snapshots and past conflicts with Voyage AI; use Atlas Vector Search so PodMan retrieves 'have we seen this collision pattern before?' This directly powers the 'watch it get smarter' money moment and earns a second sponsor's attention while reinforcing the chosen track.

## Maximizing each judging criterion

- **Technicality (40%)** — This is 40% — over-index here. Show the hard part explicitly: realtime multi-track video fusion (LiveKit) -> per-frame vision inference (Gemini 3.5 Flash) -> structured work-intent -> JOINED with live git state (local diff via a lightweight per-machine agent + GitHub API) to detect a collision class that is provably undetectable by the API alone. Name the invisible-unpushed-changes insight as the technical moat. Add the vector-memory continual-learning loop (Atlas + Voyage) and the policy-learning-from-outcomes loop. Display live inference captions so judges see real model output, not a script. One architecture slide (LiveKit -> Gemini -> fusion engine -> memory -> intervention) shown for 10s cements it.
- **Creativity / Originality (25%)** — Lead with the counterintuitive insight nobody else will have: 'the most dangerous merge conflicts don't exist in GitHub yet — they're sitting unpushed on someone's laptop, and the only way to see them is to watch the work happen.' That single reframe is the originality hook. 'Jarvis for the whole team' (ambient, proactive, voice) vs the field's solo copilots is a fresh category. The Gemini Live Translate multilingual intervention is an unexpected, memorable flourish.
- **Live Demo (20%)** — Choreograph a single unbroken 'collision caught live' beat (see demo script) where PodMan interrupts BEFORE the push with voice + card. Then the 'it got smarter' beat where a second, similar near-collision is caught faster/more confidently because of what it learned in the first. Rehearse for wifi failure with a hot local fallback, but run live. Keep the banned dashboard off-hero. End on PodMan opening a real sync PR on the public repo — a concrete artifact judges can click.
- **Future Potential & AI Impact (15%)** — Frame as the ambient coordination layer for every engineering org — generalizes beyond merge collisions to duplicated work, onboarding ('PodMan already knows who owns what'), and incident response. Tie to the recursive-self-improvement theme: an agent that compounds team knowledge and refines its own intervention policy is a template for org-scale continual learning. One sentence on the wedge: starts as collision-prevention, becomes the team's shared memory.

## Demo script

1. [0:00-0:20] COLD OPEN ON THE PAIN, NOT THE PRODUCT. Full screen: Alice's IDE, editing auth/session.ts. Voiceover: 'This is Alice. Across the room, Bob is also editing auth/session.ts right now — but he hasn't pushed. GitHub has no idea. In ten minutes, one of them loses an hour to a merge conflict.' (No dashboard on screen yet. Establish the invisible problem.)
2. [0:20-0:40] INTRODUCE PODMAN AS EYES, COLLAPSE THE GRID FAST. Briefly reveal the pod: 4 live tiles. 'PodMan watches every engineer's screen in realtime over LiveKit and understands the work with Gemini 3.5 vision.' Show live caption appearing: 'Alice -> editing auth/session.ts (login flow). Bob -> editing auth/session.ts (token refresh), 14 unpushed lines.' Then COLLAPSE the grid into a small corner widget. Say it: 'PodMan isn't a dashboard — that's just its peripheral vision. Here's what it DOES.'
3. [0:40-1:25] THE MONEY MOMENT — CATCH IT LIVE, BEFORE THE PUSH. As Bob moves to commit, PodMan's voice (Gemini Live API) interrupts in realtime: 'Hold on Bob — Alice is editing the same function in session.ts and hasn't pushed. You'll collide.' An intervention card appears with the live diff of the overlapping region. PodMan offers: 'Want me to open a sync PR so you rebase cleanly?' Click yes -> PodMan opens a REAL PR on the PUBLIC GitHub repo (show the github.com URL). This is the single hero beat; let it breathe.
4. [1:25-2:05] WATCH IT GET SMARTER. Trigger a second, similar near-collision (Carol + Bob on payments/webhook.ts). PodMan catches it faster and with higher confidence, and SHOWS WHY via its memory: 'I've seen this pattern — session and webhook handlers conflict in this repo. Confidence 0.93.' Show the Atlas/Voyage memory entry that was written from beat one being retrieved now. Then the policy loop: 'Last time you accepted my sync PR, so I'll lead with that.' Two learning loops visible in 40 seconds = the Continual Learning proof.
5. [2:05-2:30] ONE FLOURISH + ARCHITECTURE. Carol is remote and Spanish-speaking — PodMan delivers the same intervention via Gemini Live Translate in Spanish voice. Flash the architecture slide for ~10s: LiveKit (ingest) -> Gemini 3.5 (vision + Live voice + translate) -> fusion engine (screen intent x git state) -> Atlas + Voyage memory -> proactive intervention. Name the three Gemini surfaces out loud for the $5k judge.
6. [2:30-3:00] CLOSE ON THE INSIGHT + IMPACT + ASK. 'The most dangerous conflicts aren't in GitHub yet — they're unpushed on someone's laptop. The only way to catch them is to watch the work, and the longer PodMan watches, the better it knows your team. It's the ambient coordination layer for engineering — Jarvis for the whole team.' End on the open PR + the public repo URL + the live DigitalOcean-hosted app. Stop talking; let the caught-collision artifact be the last thing on screen.