Add hackathon winners to showcase

sites/labs/src/content/showcase/concordia.md

@@ -0,0 +1,31 @@
+---
+title: Concordia
+description: A multi-agent coordination framework executing Claude-driven agents inside BrowserPod synced with Minecraft.
+repository_url: https://github.com/0-robert/Concordia
+author: Agentic
+project_type:
+  - Hackathon Project
+niche: Collaborative AI
+tags:
+  - BrowserPod
+score: 85
+hero_image: "./concordia.png"
+---
+
+## What is Concordia?
+
+Concordia is an orchestration framework that coordinates four independent, Claude-driven AI agents working together in a shared virtual space. It provides a visual and debuggable interface for multi-agent systems, using Minecraft as the rendering layer while running the underlying communication and coordination protocol inside BrowserPod.
+
+The project won **3rd Place** at the 2026 AI in the Box Hackathon.
+
+## What the demo includes
+
+- **Emergent Division of Labour**: Agents use natural language to divide the map, share inventory states, and cooperate to complete goals (like mining diamonds) without a central orchestrator.
+- **Human-in-the-Loop Intervention**: Users can scan a QR code to manually take control of a single agent via a phone controller while the remaining three agents continue working autonomously around them.
+- **Observability Interface**: A real-time stream showcasing each agent's current thoughts, tool invocations, active chat messages, and inventory status alongside a live "god-view" map.
+
+## How it works
+
+Concordia's backend and public control plane run entirely inside a BrowserPod Node.js container launched from a single browser tab.
+
+The orchestrator utilizes three basic primitives—`team()` (read sibling state), `chat()` (broadcast intent), and `deposit()` (log results). To connect external controllers (such as a judge's phone on local venue Wi-Fi), BrowserPod starts an Express server and a WebSocket relay. By leveraging BrowserPod's outbound port portal, the sandboxed server is exposed via a public HTTPS/WSS link. This network inversion bypasses local NAT and firewalls, allowing external devices to connect securely. The Anthropic Claude API proxy stays server-side inside the BrowserPod container to keep secret keys secure.

sites/labs/src/content/showcase/devhub.md

@@ -0,0 +1,32 @@
+---
+title: DevHub
+description: Group, analyze, and safely execute multiple GitHub repositories in the browser using local AI and BrowserPod.
+repository_url: https://github.com/IlanRV/Frontend
+author: DevHub
+project_type:
+  - Hackathon Project
+niche: Software Security
+tags:
+  - BrowserPod
+score: 95
+hero_image: "./devhub.png"
+---
+
+## What is DevHub?
+
+DevHub is a multi-repository developer workspace that allows developers to group multiple GitHub repositories into a single workspace, browse files, run projects safely in the browser, and perform AI-powered codebase analysis.
+
+The project was awarded **1st Place** and the **Software Security Award** at the 2026 AI in the Box Hackathon.
+
+## What the demo includes
+
+- **Workspace Organizer**: Group related frontend and backend repositories into unified workspaces.
+- **AI Code Chat**: Ask natural language questions about single repositories or across the entire multi-repo workspace.
+- **Persisted Code Browsing**: View cached file contents and directory hierarchies, serving code tree updates instantly even if the sandbox environment is offline.
+- **Security Audit Logs**: Track static and runtime security events (such as suspicious dependencies or risky lifecycles) reported directly from the sandboxed workspace.
+
+## How it works
+
+DevHub's architecture uses a React/TypeScript frontend communicating with an Express/TypeScript server via the BrowserPod SDK.
+
+When a user adds a GitHub repository, the frontend boots a BrowserPod instance entirely inside the browser to securely clone the codebase. The frontend reads files locally in the browser sandbox and sends the structural metadata to the Firestore backend. The backend triggers asynchronous AI analysis (using OpenRouter/Claude) to calculate dependency graphs, security risks, code summaries, and runtime compatibility notes. If a project is runnable, the frontend spins up its runtime server inside the BrowserPod container and exposes it to the web using BrowserPod's port portals.

sites/labs/src/content/showcase/forklab.md

@@ -0,0 +1,32 @@
+---
+title: ForkLab
+description: Verify AI-generated code branches inside disposable browser sandboxes before patching production code.
+demo_url: https://forklab-ai-hackathon.vercel.app/
+repository_url: https://github.com/Jyozaa/Forklab-AI-hackathon
+author: Meal Deal
+project_type:
+  - Hackathon Project
+niche: Developer Tools
+tags:
+  - BrowserPod
+score: 90
+hero_image: "./forklab.png"
+---
+
+## What is ForkLab?
+
+ForkLab is a client-side execution environment designed to bridge the trust gap when using AI coding assistants. It allows developers to safely run, inspect, and verify AI-generated patches and test suites inside isolated, disposable browser containers before adopting the code changes.
+
+The project won **2nd Place** at the 2026 AI in the Box Hackathon.
+
+## What the demo includes
+
+- **Command Center (/try)**: A central dashboard managing prompt templates, task runners, placeholder configurations, and git branches.
+- **Interactive Sandbox (/sandbox-test)**: A real-time playground that boots a runtime environment, writes code files, runs execution commands, and streams log outputs.
+- **Patch Verification Sprint (/sprint)**: A demonstration of a deterministic bug-fixing loop that loads a CSV export project, executes a failing test suite, applies an AI-generated patch, and reports a passing proof state.
+
+## How it works
+
+ForkLab is built as a Next.js application leveraging BrowserPod as its core execution engine.
+
+When a user triggers a code execution task, ForkLab spins up a BrowserPod sandbox completely client-side in the user's browser tab. Because BrowserPod utilizes WebAssembly to run full server-side runtimes (like Node.js v22), ForkLab can write files directly to the virtual filesystem, install dependencies, run test scripts, and capture standard terminal output. Security headers (COOP/COEP) are configured on the Next.js routes to allow `SharedArrayBuffer` isolation, keeping the untrusted code entirely sandboxed away from the developer's local operating system.

sites/labs/src/content/showcase/greencode.md

@@ -0,0 +1,32 @@
+---
+title: Greencode
+description: Audit Python code for energy efficiency and carbon intensity using AST parsing inside BrowserPod.
+repository_url: https://github.com/AbhishekVishwagna/Greencode
+author: Team Mumbaikars
+project_type:
+  - Hackathon Project
+niche: Sustainability
+tags:
+  - BrowserPod
+score: 80
+hero_image: "./greencode.png"
+---
+
+## What is Greencode?
+
+Greencode is a static analysis tool designed to audit Python code for carbon intensity and energy efficiency. By identifying inefficient algorithmic patterns, it helps developers reduce their software's carbon footprint and rewards optimization progress with Carbon Credits and a digital certificate.
+
+The project was awarded the **Sustainability Award** at the 2026 AI in the Box Hackathon.
+
+## What the demo includes
+
+- **Energy Auditor**: Evaluates Python code against 30+ "Green Rules" covering computational complexity, memory thrashing, and database query loops.
+- **Granular Energy Scoring**: Ranks code efficiency on a scale of 10 to 100, highlighting "Carbon Monster" segments that require optimization.
+- **Actionable Refactoring**: Provides real-time code rewrite suggestions to help transform inefficient structures into "Green Master" code.
+- **Digital Sustainability Ledger**: Tracks optimization progress and displays calculated carbon savings in a public dashboard.
+
+## How it works
+
+Greencode splits its execution between a React frontend and a Python auditor core running client-side inside a BrowserPod sandbox.
+
+When a developer pastes code into the editor, the React frontend passes the code to the Python core executing inside the BrowserPod container. Using BrowserPod's in-browser Linux runtime, the python environment compiles the source code into an Abstract Syntax Tree (AST) using `auditor.py`, evaluates structural complexity using `scanner.py`, and outputs the energy score using `scorer.py`. Because all computation runs inside the local browser sandbox, sensitive source files never leave the developer's machine, ensuring absolute code privacy.

sites/labs/src/content/showcase/vitalstream.md

@@ -0,0 +1,32 @@
+---
+title: VitalStream
+description: An AI-powered patient monitoring system with predictive triage built inside a secure browser sandbox.
+repository_url: https://github.com/Ella-Afonso/Real-Time-Patient-Monitoring-AI
+author: The Bellayesian Inferrers
+project_type:
+  - Hackathon Project
+niche: Healthcare
+tags:
+  - BrowserPod
+score: 80
+hero_image: "./vitalstream.png"
+---
+
+## What is VitalStream?
+
+VitalStream is a patient vital signs monitoring dashboard that combines real-time IoT vital simulations, alert scoring, predictive trend detection, and AI clinical decision support. The system is designed to help clinical staff identify which patients will require attention next and organize handovers safely.
+
+The project won the **Accessibility & Healthcare Award** at the 2026 AI in the Box Hackathon.
+
+## What the demo includes
+
+- **Ward Monitoring**: Real-time IoT simulator streaming heart rate, blood pressure, SpO₂, temperature, and respiratory rate for patients across 12 wards.
+- **Predictive Acuity Alerting**: Flags patients whose vitals are trending toward danger limits (e.g. rising heart rate indicating tachycardia) before they breach normal thresholds.
+- **AI Handover Reports**: Generates structured, NHS-compliant shift handover documents detailing shift summaries, alert histories, and ward recommendations.
+- **Voice & Telephony Alerts**: Announces alerts using browser-native text-to-speech and triggers automated phone calls to on-call staff via Twilio.
+
+## How it works
+
+VitalStream runs its entire data server and clinical logic inside a BrowserPod sandbox to ensure GDPR compliance.
+
+When launched, BrowserPod boots a local Node.js environment client-side. The sandbox runs an Express.js server that generates patient vitals using a Gaussian-distributed random algorithm. To provide patient assessments and query answering, the Express server interacts with the Anthropic Claude API using credentials passed from a local environment configuration. All clinical logs and sensitive patient details are processed locally within the browser tab's secure boundary, preventing any patient data from being sent to external databases or servers.