# AI Engineer World's Fair Hackathon 2026: Project Gallery

- **Event:** [AI Engineer World's Fair Hackathon 2026](https://cerebralvalley.ai/e/aiewf-hackathon-2026)
- **When:** Jun 27 at 9:00 AM – Jun 28 at 5:00 PM (PDT)
- **Where:** San Francisco, CA
- **Hosts:** [Cerebral Valley](https://cerebralvalley.ai/u/events)
- **Projects:** 70 (6 placed)
- **Page:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery

## Projects

### 1. Test Submission

This is a test submission.

- **Team:** [Adam Blumenfeld Test](https://cerebralvalley.ai/u/adam--test)
- **GitHub:** https://github.com/ecsbeats/testproject
- **Demo video:** https://youtube.com/testvideo
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=1

### 2. Cowboys

Agent Arena is an evolutionary tournament where AI agents compete on the same real-world web task, learn from the winner, and get smarter every round.

Three agents with different strategies attempt the same task live, on real websites, using Gemini 3.5 Flash Computer Use to drive a real browser. The system scores each run on its ground-truth outcome, picks a winner, extracts the winning behavior into a skill patch, and teaches it to the losers — who retry and improve.

It runs in three modes: a head-to-head tournament, a "paste any URL" Live Arena that pits the agents against a site of your choice in real time, and a Relay mode that shows genuine continual learning — an agent gives its best effort, genuinely fails, and the lesson from that failure is extracted and inherited by the next attempt until it succeeds. Every run is captured as a replayable trajectory with real screenshots.

Agents compete. Winners teach. Losers evolve.

- **Team:** [Bilal Patoli](https://cerebralvalley.ai/u/bilalpatoli), [Zohaib Patoli](https://cerebralvalley.ai/u/zopatoli)
- **GitHub:** https://github.com/bilalpatoli/Agent-Arena
- **Demo video:** https://www.loom.com/share/98054f63be8a495691131cd39fd6fe56
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=2

### 3. RSI

A Recursive Self-Improving AI that fine-tunes its own weights from failures — meta agent, target agent, LoRA, repeat.

- **Team:** [S G](https://cerebralvalley.ai/u/whatdhack)
- **GitHub:** https://github.com/whatdhack/recursive-self-improvement
- **Demo video:** https://github.com/whatdhack/recursive-self-improvement/blob/main/rsi_explainer.mp4
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=3

### 4. shake

Earthquake simulator for historical DeepShake analysis, shake prediction and damage estimation, follow-up house repair and related architecture enhancement stuffs, plus multiagent workflow with continual learning and improvement stack, i.e., sentinel/consultant agent is able to provide constructive comment and engineering technique/tips, research agent is able to scrap real-time data for complying item and supplier list, help to make decision effectively, etc., shake will assist you and walk you through from macro (understand what is earthquake which is very important if you live in SF bay area) to micro (how to protect your house) and you will become a shake proof person eventually

- **Team:** [sam sam](https://cerebralvalley.ai/u/gguf), [Cal Cu](https://cerebralvalley.ai/u/calcu), [Shruti Mandaokar](https://cerebralvalley.ai/u/Shruti_Mandaokar)
- **GitHub:** https://github.com/mochiyaki/shake
- **Demo video:** https://youtu.be/aZVAkintkT4
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=4

### 5. field-ratchet: a recursively self-improving AI for PCB design.

Electrical design engineers often have to place and route boards by hand — agonizing over where the buck switching node goes, how far the crystal sits from the noisy regulator, whether the USB pair stays balanced, which decap hugs which power pin, etc, etc — then run DRC, find the field-risk and EMI problems, rip it up, and do it again, carrying hard-won intuition from one board to the next that never actually compounds into the tool. Fieldratchet turns that loop into an executable, self-improving compiler: feed it a KiCad schematic and it parses, classifies, places, routes, and scores a real KiCad board, where placement is a coupled-oscillator (Kuramoto) substrate — the netlist compiles into phase oscillators (shared nets become attractive/synchronizing couplings placed near each other, noisy↔sensitive nets become repulsive/anti-phase couplings kept apart), steered by a conditioning block of board intent, thermal hotspots, and engineer feedback, with hundreds of phase-seeds raced and each synchronized field decoded to coordinates via coord = board_size · sigmoid(a·sinθ + b·cosθ) — and then it gets better at the act of designing itself: each iteration mutates its own optimizer (coupling gains, drives, damping, readout) and only promotes a change when the canonical geometric + field-risk score improves and an independent damped-wave EMI voxel solver (refining 4 mm down to 10 µm inside hotspots) doesn't regress, so the best score is monotonically non-increasing (a true ratchet), and the evolved substrate transfers — a substrate improved on one board makes the optimizer ~24% better on an unseen board with zero new feedback, beating simulated annealing by 78% on our 187-component autonomy mainboard — all fully offline (no kicad-cli, no network, no API keys), shipping as an Electron app + CLI. Repo: https://github.com/JacobFV/fieldratchet

- **Placement:** Finalist
- **Team:** [Jacob Valdez](https://cerebralvalley.ai/u/jvboid)
- **GitHub:** https://github.com/JacobFV/fieldratchet
- **Demo video:** https://youtu.be/EtsaYMcorNU
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=5

### 6. Atlantis

An RL agent (GRPO + LoRA) that learns the person-specific privacy attacks universal safety filters miss — eliciting "allowed-but-compromising" leaks judged against each person's contextual-integrity care vector, and recursively self-improving its own weights and its own curriculum of harder targets.

- **Team:** [Yiying Xie](https://cerebralvalley.ai/u/Irene_xie)
- **GitHub:** https://github.com/Bestpart-Irene/RL-persona-red-team-agent
- **Demo video:** https://youtu.be/DN-OdHUR5Z0
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=6

### 7. agentic_ontology

DeFi/Crypto Macro-Regime RSI Engine—an AI system that reads the economy like a team of macro strategists and explains what it means for crypto. Eight specialized AI agents continuously analyze live Federal Reserve economic data, while an orchestrator synthesizes their findings into a single market verdict. Unlike traditional LLMs, every conclusion is grounded in an ontology knowledge graph that models causal relationships, measured correlations, and historical time lags, reducing hallucinations and producing explainable market intelligence.

Our Hackathon contribution extends this system with Recursive Self-Improvement (RSI). We use Claude Sonnet 4.6 as a teacher to generate high-quality reasoning traces, distill that knowledge into a compact model, and allow the student model to improve its own weights through an iterative feedback loop. Every new model is objectively evaluated and promoted only if it outperforms the current version, creating a safe, autonomous learning system.

This work is important because it demonstrates a new blueprint for trustworthy AI agents: grounded by causal knowledge, governed through versioned reasoning, continuously self-improving, and composable through MCP. While we apply it to macroeconomics and crypto today, the same architecture can power AI decision-making in healthcare, supply chains, manufacturing, climate science, and any domain where reasoning must be explainable and evidence-based.

- **Team:** [Minakshi Mukherjee](https://cerebralvalley.ai/u/nori_84853)
- **GitHub:** https://github.com/adaboostmm/crypto-rsi-engine
- **Demo video:** https://youtu.be/76qfiBkfcLc
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=7

### 8. Omnicon RSI

Introducing Omnicon RSI (Recursive Self-Improvement) - taking your golden summaries from Omnicon - and using them to improve and benchmark conversation summarizers - so you don't have to make the same corrections in the future

- **Team:** [Will Dahl](https://cerebralvalley.ai/u/willdahl)
- **Demo video:** https://www.loom.com/share/50501cf31bad4cb48116404f4bdb7bda
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=8

### 9. RecursiveLearner

[Do not include in judging - incomplete result as of deadline, just adding thought process] 

RecursiveLearner — training-free recursive self-improvement via test-time "lessons memory"

The question: Can a small open model improve itself at inference time, with zero weight updates, by writing lessons from its own mistakes and retrieving them when it meets similar problems? And can it be fully self-contained — one model acting as solver, embedder (clustering its own failures using its own hidden-state activations), and lesson-writer?

The approach: Run the model on a train split → collect what it gets wrong → cluster those failures by the model's own activations → have the model diagnose each cluster and write a short reusable strategy → at test time, route each new problem to its nearest failure-cluster and inject that lesson into the prompt. No fine-tuning — pure prompt-patching. (Proposer models + a model catalog served via DigitalOcean's inference API; activations + local inference on an RTX 3090; vLLM for throughput.)

What we found:
- IFEval (instruction-following): a clean positive. Self-derived lessons gave a statistically significant held-out gain (+5.5%, p=0.036), and more lessons helped monotonically (+4.4%, p=0.013). Genuine training-free self-improvement.
- BBH (multi-step reasoning): On a fully-consistent, leakage-checked 3-shot protocol (n=675, Qwen2.5-7B), failure-derived self-lessons are neutral-to-marginally-positive on BBH reasoning (strict Δ 0.0; format-agnostic Δ +1.5%, net-positive on ~half the 27 tasks), and a clear win on instruction-following (IFEval +5.5% held-out, p=0.036).

- **Team:** [Orhan Celiker](https://cerebralvalley.ai/u/otceliker)
- **GitHub:** https://github.com/otceliker/ai-engineer-hackathon
- **Demo video:** https://youtube.com
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=9

### 10. Kevin Durant

THIS PROJECT IS APPLYING FOR- BEST USE OF GEMINI

Self-Taught Operator

Self-Taught Operator is an AI agent, built on Gemini 3.5 Flash's computer-use capability, that teaches itself to operate software it's never seen by writing its own verified skills from its own successes.

I used NandGame — a browser logic-circuit game — as the testbed. The agent perceives the board, reasons about what to build, and wires it up by naming the connections it wants. When it solves a level, the system synthesizes what it actually did into reusable executable code at runtime — real code generated from the agent's own trajectory, not a hardcoded answer. Those skills are embedded with Voyage AI and stored in MongoDB Atlas, so the agent can retrieve them by similarity and compose them into circuits it never explicitly learned — like building a half-adder from an XOR and an AND skill it solved separately.

Everything is verified by an external referee — NandGame's own validator, not the model grading itself. The strongest proof is the demo's climax: I delete a skill the agent learned, watch it grab the wrong one and fail the referee, then restore it and watch it recover. The skill isn't decoration — it IS the capability.

One challenge: Gemini couldn't reliably click NandGame's tiny clustered pins. Instead of faking it, I let the agent name the connections it wanted and made the execution reliable underneath — it still does all the thinking. Every skill in the library was genuinely solved by the agent itself.

Tech stack: Gemini 3.5 Flash (computer-use), MongoDB Atlas (storage + vector search), Voyage AI (embeddings), Python, Playwright.

Continual learning that gets more capable the more it's used.

Built by Holden G. Richard :)

- **Team:** [Holden Richard](https://cerebralvalley.ai/u/TISL)
- **GitHub:** https://github.com/HoldenRichard/self-taught-operator.git
- **Demo video:** https://youtu.be/BMJl9FYgArE
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=10

### 11. Bonsai

Every domain expert who owns "what good looks like" — a compliance lead, a security reviewer — is drowning, hand-checking AI answers one at a time, and the ones that bite are the confident answers whose citation doesn't actually hold. Bonsai turns those experts into bonsai gardeners. They shape the ideal form once — a small, frozen standard — and the harness does the patient tending: it watches a cited-answer agent (Gemini 3.5 via Vertex AI), catches every claim whose citation doesn't trace to its source, clusters that failure by meaning (MongoDB Atlas $vectorSearch over Voyage embeddings), grows a new branch — one general check that catches that family of mistakes — and prunes the checks that overfit or go stale. Any real decision turns on dozens of factors; the rubric captures that accumulated judgment branch by branch, instead of one brittle hand-written test. And the growth stays honest: a build-time test fails CI if the loop ever reads the gardener's frozen standard (a guardrail, not an unbreakable wall). On that held-out set the loop can't read, agreement rose 9→14 of 15 (Wilson 95% CI [70.2%, 98.8%], sign-test p=0.031). The aim: one gardener, many trees.

- **Team:** [Nicholas Allison](https://cerebralvalley.ai/u/knick)
- **GitHub:** https://github.com/enturesting/bonsai
- **Demo video:** https://youtu.be/AkhUHc4OgXo
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=11

### 12. Veritas

Meet Veritas: a silent AI agent that fact-checks live meetings/debates in real time.
It plugs directly into LiveKit, handles over 70 languages, and matches spoken claims against a local  database in just two milliseconds. If a claim is brand new, Veritas researches it on the web via Gemini with Google Search grounding, then stores the answer, so the longer it runs, the faster it gets. It also flags live contradictions (both same-speaker and cross-speaker) with precise timestamps. It’s the ultimate truth layer for panels, debates, and high-stakes meetings.

- **Team:** [Aniruddh Bhandarkar](https://cerebralvalley.ai/u/anib), [Anish Bhandarkar](https://cerebralvalley.ai/u/Anish-100)
- **GitHub:** https://github.com/Anish-100/AIEWF-Hackathon-2026
- **Demo video:** https://youtu.be/T8EhPNoQjec
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=12

### 13. Two Levers

SIA × GraphWorldModels
A self-improving AI loop where every improvement is measured against reality.
The problem
A deployed AI agent performs at some level and then stays there. Improving it usually takes a human in the loop — someone notices it's underperforming, diagnoses why, hand-edits the prompt or scaffolding, or kicks off a retraining job. That cycle is slow, expensive, and doesn't scale. The agent can't get better on its own from its own experience.
For an agent to improve itself safely, two things have to be true: it needs to act on both levers that actually move performance — the scaffolding around the model and the model's own weights — and every gain has to be a real, verified number, because you can't responsibly let a system modify itself on a metric you don't trust.
What this is
A working implementation of the two-lever self-improvement loop from the SIA paper, built on a real world model from the GraphWorldModels project. An agent is dropped into an environment it knows nothing about and improves itself with no human in the loop:

It builds its own world model. By exploring, the agent learns how its environment behaves — which moves from which states lead where, and what they're worth — and stores it as a real transition graph (the GraphWorldModels Neo4j schema). It plans over this map instead of acting blindly. You watch the value landscape light up live as it learns.
Lever one — it fixes its own scaffolding. A Feedback-Agent reads the agent's actual performance (success rate, coverage, whether it's plateaued) and rewrites how the agent operates — its exploration, its planning depth — when it's underperforming. In the demo you watch it detect that the agent is stuck and fix it, with the performance curve responding.
Lever two — it retrains its own weights. When better scaffolding stops paying off, it fine-tunes the underlying language model on the agent's own logged experience, using real GRPO LoRA — the method and structure from the SIA repo (8-sample groups, advantage = reward minus group mean), running on a GPU.

Every number on screen is computed from real outcomes — path efficiency is literally optimal-steps over actual-steps, graded by the environment. Nothing is hardcoded to a target; delete the loop and the dashboard goes blank.
What it proves
A complete self-improvement loop — a world model the agent builds, a feedback agent that fixes the scaffold, weight updates that retrain the model — that closes and stays measurable, with every improvement earned from real outcomes. The demo runs this loop live.
Why it matters
The same shape — a world model the system builds, a measured feedback loop that improves the scaffold, selective weight updates, all verified against reality — is the pattern behind real deployed agents that today only improve when a human intervenes: a trading agent that should sharpen its edge from realized outcomes, a drone that should improve its navigation from flight logs, an analytics agent that updates its model as new data arrives. The grid is the cheapest environment to prove the loop itself works and is measurable; swap in the real domain and the machinery is identical.
The honest boundary: this proves the loop is real and measurable — not that it already beats a hand-tuned production system on a real task. The demonstration is the mechanism; the application is that same measured pattern, pointed at a real environment.

- **Team:** [Suvasis Mukherjee](https://cerebralvalley.ai/u/suvasis)
- **GitHub:** https://github.com/dronomyio/worldmodel_sia.git
- **Demo video:** https://youtu.be/QUvKLHs5hIo
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=13

### 14. EvoLoRA

EvoLoRA is an auditable, bounded self-improvement loop for LoRA fine-tuning. You provide a plain-English goal; a MiniMax agent plans the evaluation set, the training data, and the LoRA hyperparameters; Python validates and controls every step; a small model is trained and scored against a locked benchmark; and the best adapter is preserved. The entire learning process is made visible: the agent plans, the model trains, results are scored and judged, and you decide whether to keep going. 

LiveKit is used for dictation support as well as narration of the training process. MongoDB is used to persist all of the training-related data and LoRA adapter paths in the cloud. Digital Ocean is used for our external LLM-as-a-judge for scoring the evals prepared by Minimax.

- **Placement:** Finalist
- **Team:** [Vaibhav Satishkumar](https://cerebralvalley.ai/u/VS-Coder), [Pranav Emmadi](https://cerebralvalley.ai/u/PranavEmmadi), [Akshay Langhani](https://cerebralvalley.ai/u/AkshayLanghani)
- **GitHub:** https://github.com/Visual-Studio-Coder/EvoLoRA/
- **Demo video:** https://youtu.be/4lz4LjBrG7I
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=14

### 15. Auto QA

A self improving system to QA our changes with evidence, and add reviews in github.
It uses Google Gemini Managed Agents and Computer use to test de app and give a complete report of the new features
It learns how our app works to test it more efficiently and give better feedback.
It also learns with any new merge into main

- **Team:** [Blas Moreno](https://cerebralvalley.ai/u/Blas)
- **GitHub:** https://github.com/slab10000/auto-qa
- **Demo video:** https://youtu.be/n45jkNbU85w
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=15

### 16. SubStrata

A satellite classifier that gets smarter from its mistakes — without ever retraining the model.

SubStrata labels satellite imagery (Sentinel-2, Google Dynamic World, EuroSAT) into land cover — trees, shrub, grass, crops, water, built — and paints it as a segmentation map. The twist is what happens when it’s wrong: a second Gemini “Strategist” looks at the miss and writes a plain-English lesson, like “tell trees from shrub by tall shadows and coarse canopy texture,” then files it in a graph organized by a land-cover hierarchy and injects the relevant lessons into the prompt before the next pass. The model’s weights never change — it improves by remembering, not retraining. And because the memory is a hierarchy instead of a flat list, a lesson learned on trees vs shrub automatically transfers to a never-seen grass vs shrub pair (both are vegetation), something a vector database can’t do. Every label can cite the rule behind it, so you can read why it believes what it believes — and an analyst can click a wrong cell, correct it, and watch that correction become a new lesson, human-in-the-loop, weights still frozen. It matters most where you can’t retrain in the field: satellites in orbit, denied-comms defense work, environmental monitoring with a handful of expert corrections instead of a labeling campaign. Land cover is the petri dish; the edge is the point. Built on Gemini 3.5 (Vertex AI), Gemma, Google Earth Engine, a networkx in-memory graph, and a live Next.js dashboard.

- **Team:** [Aayush Gandhi](https://cerebralvalley.ai/u/aayushgandhi), [Neev Tamboli](https://cerebralvalley.ai/u/neevtamboli10), [Anish Gupta](https://cerebralvalley.ai/u/AnishGupta)
- **GitHub:** https://github.com/gandhiaayush/spirit-land
- **Demo video:** https://youtu.be/jGgLMwZsc-I
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=16

### 17. PiPlan

Engram is a continuous-learning memory system that lets an LLM keep serving users while deciding what to store in RAG, what durable beliefs to internalize into model weights, and hot-loading those edits live in the background.

- **Team:** [Tangyi Qian](https://cerebralvalley.ai/u/JerryQian)
- **GitHub:** https://github.com/xesws/AIEHackathon
- **Demo video:** https://youtu.be/15ZMkpkQMug
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=17

### 18. SplatForge

SplatForge is a robot manipulation agent that trains itself inside the worlds it reconstructs. Point a phone at a tabletop and it turns the scene into a photoreal 3D Gaussian Splat, a digital twin you can view from any angle, then drops a robot into a physics replica of that scene and teaches itself to "pick up the mug." Robot policies normally improve only by consuming human teleoperation and labeling, which is the slow, expensive bottleneck on every manipulation project. SplatForge's bet is that a robot can write its own training data and improve itself, closing a fully autonomous loop.

The loop runs in six steps with no human in the middle. First it reconstructs a real scene into a Gaussian Splat. Then an LLM curriculum generates task variations and edge cases (the mug rotated, occluded by a bowl, lit more dimly) and emits them as structured scene specs. The policy attempts each scenario in a MuJoCo physics simulator, and a vision language critic scores every rollout with a pass or fail verdict. Successful trajectories are distilled into a LoRA fine tune of the policy, while failures become the next round's targeted curriculum, selected by vector search over embeddings of past failures. The loop repeats on its own, and a live success rate curve climbs as it goes.

The central design insight is that a Gaussian Splat is a renderer, not a physics engine, so it cannot tell you whether a grasp actually succeeded. That splits the work in two. The splat is the eyes and skin, providing the photoreal views the critic scores, while MuJoCo is the body and physics, where the robot actually acts and where grasp success is measured by whether the mug clears a height threshold. The robot acts in MuJoCo and is shown in the splat, so the camera tells one coherent story: it learns inside the very scene it reconstructed. This fits the hackathon's focus on continual learning and recursive self improvement. The system measurably improves the more it runs, generates its own training data, updates its own weights, and uses the VLM critic to evaluate itself.

Under the hood it runs on Python, PyTorch, and MuJoCo, which handles physics and the success signal. It runs on CPU so it works on a laptop, including Apple silicon. Gaussian splatting through gsplat and Nerfstudio builds the digital twin, and LoRA/PEFT adapters drive the fine tuning loop, trained on DigitalOcean GPU droplets. A FastAPI orchestrator runs the closed loop behind a React dashboard with a live success rate chart and a splat viewer. It leans on several sponsors: DigitalOcean for the fine tuning GPUs, Google Gemini as both curriculum generator and visual critic, MongoDB Atlas with Voyage AI as the trajectory replay buffer and failure vector search, and optionally LiveKit for voice control and MiniMax as an alternative LLM or VLM. Per the rules, the off the shelf pieces, the splat renderer and the base foundation models, are clearly separable from what we built during the event: the loop orchestration, the curriculum generator, the self critic evaluation harness, the LoRA fine tuning loop, and the dashboard that ties it all together.

- **Placement:** 1st Place
- **Team:** [Shivam Singh](https://cerebralvalley.ai/u/shivsingh123), [Jay Trivedi](https://cerebralvalley.ai/u/JayTrivedi)
- **GitHub:** https://github.com/ShivamSinghNow/SplatForge
- **Demo video:** https://www.youtube.com/watch?v=MrdXQv5wlB4
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=18

### 19. OpsGym

OpsGym is a self-improving policy engine for operations teams

- **Team:** [Chris Davis](https://cerebralvalley.ai/u/datadavis)
- **GitHub:** https://github.com/thedatadavis/opsgym
- **Demo video:** https://drive.google.com/file/d/1Cz2CWjTOz66lWNSLepHKPvIgWhbJnPJB/view?usp=sharing
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=19

### 20. AcmeBox

The unit economics regarding customer support bots using frontier models from OpenAI and OpenAI won't ever make sense. Research labs reinvest gains into larger models that feature increasingly large token traces, while cheap labor is extremely prevalent in contact centers. As a result, I believe fine-tuning company-specific models (with less than 100 billion parameters) to accomplish 8-10 set tasks will become more and more common.

Today, my project features an EffectTS REST API, an MCP Server of that REST API, a custom "AcmeBox Bench" evaluation inspired by Sierra's tau2-bench, a React-based chat widget, and a custom pipeline for continuously improving a Liquid LFM2.5-8B-A1B MoE self-hosted model to better serve AcmeBox, the HelloFresh competitor. All of this works creates a self-improving hardness for an 8 billion parameter model to eventually compete with much larger and more performant models.

- **Team:** [Ayush Kumar](https://cerebralvalley.ai/u/ayukumar261)
- **GitHub:** https://github.com/ayukumar261/AcmeBox
- **Demo video:** https://youtu.be/q7sSqoPep0w
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=20

### 21. autodiscover

Personalized feature creation and discovery

Pain point 1. Don't like how an app is organized, either too complex or too simple
Pain point 2. Global updates for all users are not always appreciated

My system solves both, with X as a case study.

- **Team:** [Timothy Tong](https://cerebralvalley.ai/u/ttong)
- **GitHub:** https://github.com/ImTimTong/autodiscover
- **Demo video:** https://www.youtube.com/watch?v=pR2-P59TpmQ
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=21

### 22. Recallroom

Recallroom is a copilot for learners. Learning in this new age can be made so much easier. Watching lectures for students, or anything academic doesn't need to feel lonely or leave you feeling unsure about what is going on. Rolli watches and listens to the lecture with you in real time, compiling a wiki and improving its knowledge base in real time. Users can ask questions and get answers contextualised not just to the context of the lecture, but also answered in the way they prefer to learn - whether that be with clearer walk throughs, examples or visuals. A judge will also continually improve the agents explanations, tune it to the student, while also trying to keep some taste of the way the lecture is being delivered to keep consistency.

- **Team:** [Jonathan Chng](https://cerebralvalley.ai/u/potatoman03)
- **GitHub:** https://github.com/potatoman03/recallroom
- **Demo video:** https://www.loom.com/share/08525bad5a354e1f86d2a0c63ac2412a
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=22

### 23. RSIW

LLM driven world and reward design and improvement based on policy feedback.

- **Team:** [Arjun Prasaath Anbazhagan](https://cerebralvalley.ai/u/AI_research)
- **GitHub:** https://github.com/Arjunprasaath/Recursive-Self-Improving-World
- **Demo video:** https://drive.google.com/file/d/1dwQtmkeBDvXolJasnX_oi-CKPzAICSfp/view?usp=sharing
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=23

### 24. BrickByBrick

An autonomous visual-agentic data factory that finds a small model's UI-coding blind spots, turns them into a training set, and LoRA-fine-tunes the model on real GPUs — live.

- **Team:** [Peyton A Li](https://cerebralvalley.ai/u/Peytonli), [Logan Li](https://cerebralvalley.ai/u/Loganli1)
- **GitHub:** https://github.com/PeytonLi/BrickByBrick
- **Demo video:** https://www.youtube.com/watch?v=U0DsR81rm4A
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=24

### 25. Bron

We built a recursively self-improving infrastructure for solving complex supply chain optimizations that monolithic LLM's overlook due to the multi-objective layer with conflicting constraints. Problems are decomposed into modular execution graphs that define communication, delegation, and operator assignment. As the system runs, it continuously restructures this topology, selectively breeding successful graphs together. A frontier meta-operator creates initial division of labor and a measurement program, then benchmarks these teams, keeping only the most successful one but storing the worse architectures in a database so not to repeat itself later. Then, using the most successful of architectures, the meta-operator tries to make it better by further mutating it with known best practices learned through continuous iteration. This process goes on until a certain benchmarking threshold is met for a team. Essentially, the system is better at a given problem with time because we encode the problem's solution strategy into the topology of operators itself. 

Our UI also makes the full workflow accessible to non-technical users, allowing them to monitor exactly how the custom infrastructure is evolving. Through our agent, “Bron,” users can describe their problem in plain language. Bron then guides them through defining the problem statement, asks the necessary follow-up questions, and helps manage custom files when needed. Bron effectively serves as the entry point to the system: it gathers the right context and turns it into a detailed, structured prompt that a typical user may not know how to write on their own.

This approach lets us iteratively improve both the network and the solution for a given supply chain problem. In our F1 CO2 emissions reduction flight plan example, our novel method reduced carbon emissions compared with the baseline case.

Because the F1 calendar spans many countries and tight race-week deadlines, the logistics network is complex: freight, staff, cars, parts, hospitality equipment, and other resources must arrive at each circuit on time. The baseline case represents a standard flight plan or routing strategy, while our method searches for improved routing, scheduling, and allocation decisions that reduce unnecessary travel, lower emissions, and still satisfy operational constraints.

- **Team:** [Denis Koterov](https://cerebralvalley.ai/u/godbrigero), [Cade Miller](https://cerebralvalley.ai/u/Ruya-Cade), [Aman Upganlawar](https://cerebralvalley.ai/u/AmanUpg)
- **GitHub:** https://github.com/Cademiller23/bron
- **Demo video:** https://youtu.be/gFN9B9X4JoU
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=25

### 26. Darwin SRE

Self-improving SRE System

https://whale-app-pn7gj.ondigitalocean.app/

- **Team:** [Srikar Achanta](https://cerebralvalley.ai/u/srikar_achanta)
- **GitHub:** https://github.com/sachanta/darwin-sre
- **Demo video:** https://drive.google.com/file/d/1CSWHcu2QiZFPaP5UiXT4jt1NV3HB8h6N/view?usp=drive_link
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=26

### 27. SQLWriters

Tagline

Drift detection and automated self-improvement for AI agents: it detects when an agent's accuracy silently degrades and makes the agent learn from its own failures to recover — autonomously, with no human in the loop.


Description

The problem: AI agents are evaluated once, at launch, then deployed into a world that keeps shifting — inputs get harder, distributions move, edge cases pile up. Accuracy decays quietly, and nobody notices until something visibly breaks. The fix today is manual and reactive: a human eventually spots the regression, gathers failures, and rewrites prompts or re-tunes the model. That doesn't scale, and it leaves agents silently underperforming in the meantime.

What we built: A self-improvement layer that wraps an agent and closes the loop on its own competence. It treats the agent's accuracy like a production telemetry stream and runs a statistical drift detector over it — windowed, with no trained model — that fires only on a sustained distribution shift, not a single bad answer (one slip is noise; a downward trend is drift). When drift is detected, an automated correction loop kicks in: it collects the agent's own failing cases, has a stronger teacher model generate corrected outputs, execution-verifies each one against ground truth (falling back to verified gold when the teacher is wrong), and injects the results back into the agent as few-shot memory — with anti-forgetting anchors so newly learned hard cases don't erode existing skill. The agent recovers because it learned; nothing is reverted and no bigger model is swapped in. That growing example set is the self-improvement.

Proof it works: We demonstrate on a text-to-SQL agent (throwaway scaffolding) evaluated on the Spider benchmark, simulating production complexity-creep: easy queries hold a stable ~78% baseline, then the input distribution shifts to hard and extra-hard queries and accuracy collapses. The detector catches it automatically, correction runs unattended, and on held-out questions the agent never saw as examples, hard-bucket execution accuracy recovers from 30% to 57% — out-of-sample, validated with a paired McNemar test (p = 0.016, zero regressions), and ending more accurate than the teacher model that generated its examples.

Why it matters: The detector is stateless and channel-agnostic — the loop works for any agent that emits a quality signal, not just SQL. It's a template for autonomous agent maintenance: detect, diagnose, self-correct. As agents move into production and the world shifts under them, this is how they stay alive — monitoring and repairing their own competence without waiting for a human to notice.

- **Team:** [Logan Rudd](https://cerebralvalley.ai/u/LoRu), [Rohan Chavan](https://cerebralvalley.ai/u/Rohanpc), [Mihir Agarwal](https://cerebralvalley.ai/u/Catan), [Yiwen Wei](https://cerebralvalley.ai/u/AyaWei)
- **GitHub:** https://github.com/loganrudd/agent-self-improvement
- **Demo video:** https://youtu.be/s3hiz4MvEXU
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=27

### 28. Ignore All Previous Instructions

Superprediction is a continual learning system over prediction markets. We perform rollouts at inference time with Gemma E4B, which has search capabilities by Exa. Say at time t we generate a probability of a given market state. By t+1, we have a true probability of t. If we're incorrect, we generate a retroactive trace with Gemma 26B for a plausible CoT (with live search tool calls) and perform on-policy self-distillation into our E4B model via a method reminiscent of ECHO, where we RL on the binary outcome at time t and SFT on the tool calls, to efficiently encode optimal prediction strategies. We use Gemini 3.5 Pro to adjust our CoT so it does not leak information at t+1 and could have been theoretically generated at t by a strong predictor.

With this, we hillclimb on prediction tasks from 0% to 12.7% after SFT on around 100k market timesteps and continual learning for ~1 hour on polled Polymarket data. Deployed in the real world, this system would continually learn real-world nuances and dynamics to maintain a market edge in an increasingly instituionalized exchange.

- **Team:** [Ronok Tanvir](https://cerebralvalley.ai/u/ronoktanvir), [Louis Mascari-Dumont](https://cerebralvalley.ai/u/louismd), [Aarush Gupta](https://cerebralvalley.ai/u/bxptr)
- **GitHub:** https://github.com/bxptr/superprediction.git
- **Demo video:** https://www.youtube.com/watch?v=lVMWb_adHKQ
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=28

### 29. Solux

Solux is an AI-powered geospatial screening platform for solar and solar-plus-storage development in India and the United States.

Solar developers often waste time and capital evaluating sites that later fail because of land-use conflict, poor grid or road access, terrain issues, missing water feasibility evidence, environmental risk, or weak project economics. Solux helps solve this by turning a natural-language project request into an evidence-backed site-screening workflow.

A user can ask something like: “Find the best sites for a 100 MW solar plus 50 MW battery project in Rajasthan and Gujarat. Avoid dense vegetation, steep slopes, and areas far from roads or transmission.” Solux parses the request, validates that the region is supported, retrieves real candidate locations from our prepared USA/India dataset, enriches each candidate with geospatial and solar evidence, runs deterministic scoring and model-assisted reranking, and returns the top 10 locations with names, addresses/localities, coordinates, confidence, source warnings, and GO / INVESTIGATE / KILL decisions.

The product is not a generic map dashboard. It is a decision system for early-stage solar fatal-flaw screening. Solux shows which sites look promising, which need further diligence, and which should be rejected before developers spend money on land control, interconnection, permitting, or engineering.

The frontend uses a 3D Earth command-center interface where only India and the United States are supported. Unsupported regions are explicitly rejected instead of producing fake results. Every project is saved separately, every query creates a traceable run, every recommendation is tied to evidence, and missing data lowers confidence instead of being hidden.

- **Team:** [Chetas Parekh](https://cerebralvalley.ai/u/chetas)
- **GitHub:** https://github.com/chetas1208/Solux
- **Demo video:** https://drive.google.com/file/d/1zosd4N3YAglxWjjKUIv-XW6E3tFzLKZZ/view?usp=share_link
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=29

### 30. AgentShield

AgentShield Arena is a self-improving guardrails system that solves the problem of securing customer-facing AI agents against adversarial attacks.

# The problem: Companies deploying AI agents (support bots, sales assistants, workflow agents) need protection against misuse. While generic prompt injection and jailbreak defenses exist, the real danger lies in business-rule violations — attacks that exploit the specific logic, permissions, and workflows of your system. A refund bot has different vulnerabilities than a medical-records assistant. Every AI agent has a unique attack surface defined by its tools, permissions, and business rules. Static, one-size-fits-all guardrails cannot cover this.

# Our solution: An automated adversarial arena that creates a red-team/blue-team co-evolution loop, tailored to each specific AI system:

- An Attack Agent probes the target with increasingly sophisticated exploits — not just generic jailbreaks, but system-specific business-rule bypasses (e.g., splitting a $500 refund into multiple sub-$100 requests to circumvent approval thresholds).
- A Defender learns generalized patterns from every successful attack and applies them as runtime guardrails.
- Each round, attacks get smarter and defenses get stronger — the system adapts itself.

# What makes us special: We focus on business-logic violations — the exploits that generic guardrails miss entirely. Every client's AI agent is different: different tools, different rules, different users, different risks. AgentShield doesn't ship a static ruleset — it self-improves by adapting to each client's unique system, discovering and defending against the specific threats that matter for their agent. The adversarial loop ensures guardrails are always evolving, never decaying.

# The hardened Defender then ships as the production guardrails layer — arriving in production already battle-tested against the exact attack surface it will face, with protection that keeps getting better after deployment.

- **Team:** [Kamil Zych](https://cerebralvalley.ai/u/vonHousen)
- **GitHub:** https://github.com/vonHousen/agent-shield-arena
- **Demo video:** https://youtu.be/KvL2YOh7yb4
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=30

### 31. GPU Sitter

GPUSitter is an on call engineer that responds to failures in GPU datacenter clusters. \
We built tools for the agent to inspect NVIDIA sensor data, and power, temperature, and utilization data. 
From that it reasons about the root issue and informs about resolution.
Self improvement: After its finished reasoning, with its expert knowledge, it updates its own small ML prediction model for failures. If it scores better than the existing ML model replaces it.
PS: The we data (schema) used it real LLM training cluster logs from the AcmeTrace paper. So you can actually use our setup for GPU operations :)

- **Team:** [Jeff Miller](https://cerebralvalley.ai/u/Look), [John Coleman](https://cerebralvalley.ai/u/johncoleman), [Mohid Butt](https://cerebralvalley.ai/u/mohid), [Octavian Cosmin](https://cerebralvalley.ai/u/octavianc)
- **GitHub:** https://github.com/jcmiller/hackathon-datacenter-agent
- **Demo video:** https://youtu.be/BhjBohJsYrY
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=31

### 32. PodMan: Pair Programmer ❤️

https://www.podman.live/

PodMan is the pair programmer for your AI-native dev. team. Writing code got cheap; knowing who's writing what didn't. With humans-plus-AI (and soon swarms of agents) all hitting one repo, the bottleneck shifted from engineering to coordination and no human can track it. PodMan joins your pod over LiveKit, watches every teammate's screen with Gemini Vision, fuses it with local git changes GitHub can't see, and the instant two people touch the same file it alerts everyone has€” a live card plus an on-device Gemma reasoning through Hermes agent before the conflict lands. Then it learns: every team decision, code quality style saved as trace in MongoDB Atlas, vector search recalls past collisions, and a self-tuning(learning) policy nudges less and escalates smarter over time with no retraining, no babysitting. It's not a coding assistant; a coordination layer that improves itself, built for the agent-swarm era. Real-time multimodal awareness, on-device voice, continual learning with€” zero interruptions.

- **Placement:** 2nd Place
- **Team:** [Ramis Hasanli](https://cerebralvalley.ai/u/ramizik), [Karti Tripathi](https://cerebralvalley.ai/u/karti), [Yahya Alhinai](https://cerebralvalley.ai/u/yhinai), [Shakthi Bachala](https://cerebralvalley.ai/u/Shakthi_Bachala)
- **GitHub:** https://github.com/karti-ai/podman
- **Demo video:** https://youtu.be/bWJIsIWTgr0
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=32

### 33. OmniForge

The Self-Healing Proxy — autonomous runtime debugging, patching, and hot-swapping for production AI systems.

- **Team:** [Sri K](https://cerebralvalley.ai/u/chinni), [Shradha Pujari](https://cerebralvalley.ai/u/ShradhaaP)
- **GitHub:** https://github.com/Shradhapujari/ai-engineer-worlds-fair-2026-hackathon
- **Demo video:** https://drive.google.com/drive/folders/1zGI93uuE-iJtAZjlOzUPzhX6las-eRxl?usp=sharing
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=33

### 34. OmegaPacman: Interpretable Multi-Agent Learning

Four ghost agents learn to catch a Pac-Man on a grid. After 
each round, each ghost reflects on what happened and rewrites 
its strategy — in plain English you can read.

What makes this different from black-box multi-agent RL: the 
agents' entire learned strategy is human-readable text, not 
neural weights. You can watch a ghost "realize" it should 
converge from multiple sides — and read the exact note where 
it wrote that down.

We also found something surprising: when we told the ghosts to 
"cooperate," they passively guarded zones and failed. When we 
told them only to "catch Pac-Man," cooperation emerged on its 
own — they began converging and trapping. Coordination wasn't 
coded; it was discovered.

The learning is still unstable — performance varies round to 
round, and the agents don't yet monotonically improve. But the 
core result holds: multi-agent strategy that is both emergent 
and fully interpretable.

- **Team:** [Elden Gu](https://cerebralvalley.ai/u/eg2026)
- **GitHub:** https://github.com/eldengu/omegapacman/tree/antigravity-mag-vertexai-flash
- **Demo video:** https://youtu.be/KxrHJwLWu-Y
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=34

### 35. Autodrone

I built Autodrone, an LLM-driven drone agent that takes a natural-language mission and flies a simulated drone through an Unreal/AirSim environment. The core idea is that the LLM is not just giving one-off commands; it is inside a self-improvement loop. Each flight produces structured rollout data: the mission, route, drone state, actions, rewards, safety violations, and final outcome. That data is stored in MongoDB, where successful trajectories become reusable flight memory and failed attempts become lessons for future runs. The harness can then use those stored experiences to change future behavior automatically by retrieving past successful routes, adjusting the context window, generating training examples, and computing GRPO-style advantage scores across multiple attempts. In short, I made an LLM fly a drone, then gave it memory and feedback so it can improve its future flight behavior from its own simulator experience rather than relying on manual human correction.

- **Team:** [Carl Okpala](https://cerebralvalley.ai/u/Carldtytan), [Jiyun Kim](https://cerebralvalley.ai/u/jiyun)
- **GitHub:** https://github.com/Carldtitan/Autodrone
- **Demo video:** https://youtu.be/K10EQv3A-K8
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=35

### 36. Veche

VECHE makes computer-use reliable and cheap on legacy software with no API, no DOM, no MCP. It is made possible by continual learning: a swarm of vision agents maps the app from pixels into one shared memory by consensus, which gets more reliable and cheaper the more it is used, and heals itself when the software changes. Veche is the MCP you never wrote.

- **Team:** [Alexandre Geng](https://cerebralvalley.ai/u/Alexyz)
- **GitHub:** https://github.com/Oxyz-Studio/veche
- **Demo video:** https://gyazo.com/eff6439d6627c96c35a90286254c67d0
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=36

### 37. GravityMedShield

GravityMedShield - Human-in-the-Loop Recursive Medical De-identification 

Medical AI is experiencing an unprecedented boom, but it faces a massive regulatory wall: **Patient Privacy**. 

The bottleneck of AI in healthcare is access to medical data

Hospitals have Petabytes of quality medical data, but are not allowed to share them without proper PHI sanitation.
PHI that is Protected Health Information.
- Names
- Dates - birth dates
- Biometrics
- Visuals
- Unique Identifying traits

To train models or share medical data, datasets must be strictly de-identified. But standard tools fall short and eventually fail.

The solution GravityMedShield - a human in the loop medical de-identification studio built on antigravity powered by three specialized agents
Agent A: Conductor cleans metadata headers and extracts PII search terms
Agent B: Visual Specialist - locates burned in PHI data in image frames using state of the art gemini 3.5 flash - and a local model inside a hospital 
Agent C: Pixel Masker - redacts visual PHI in dice files

Reviewers can run this application locally and review side-by-side unredacted and sanitized data approve, reject, rework manually or with AI

The game changer is what makes this application future proof: recursive self-improvement. Whenever a reviewer performs manual corrections, the system memorizes these actions for future images with that device fingerprint.

This way the AI learns from human supervisors continuously refining its deidentification skills.

- **Team:** [Martin W](https://cerebralvalley.ai/u/robotmartin)
- **GitHub:** https://github.com/wojtczyk/GravityMedShield.git
- **Demo video:** https://youtu.be/ROysB3AE0t4
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=37

### 38. Aperacium

A real paralegal does one task at a time. ABLE runs four Gemini Computer Use agents in parallel — simultaneously navigating a court portal, researching case precedents, profiling opposing counsel, and mapping evidence to legal claims — then feeds every finding into an adversarial drafting loop where Agent Alpha writes and Agent Beta critiques until the motion clears a quality threshold.
The result: a court-ready Motion for Summary Judgment in under 4 minutes, with a human in the loop at every critical gate.
What makes it technically distinct:
4 parallel Playwright browsers, each driven by Gemini 3.5 Flash Computer Use via the Interactions API, running in isolated ProactorEventLoop threads
Stateful multi-turn sessions using previous_interaction_id — each agent remembers context across browser actions
Adversarial Alpha/Beta loop with score-gated exit — not just generation, but self-evaluation and recursive revision
Live WebSocket streaming of screenshots, diffs, and agent thoughts to a 3-panel React dashboard
Theme: Self-Improvement Stack — the system evaluates its own output, critiques it adversarially, and iterates until it meets a quality bar. No human writes a single word of the motion.
Prize targeting: Gemini 3.5 Computer Use + Interactions API (Best Gemini Usage — $5,000).

- **Team:** [Raghavendra Dinesh](https://cerebralvalley.ai/u/rdinesh2)
- **GitHub:** https://github.com/rdinesh207/ai-paralegal
- **Demo video:** https://youtu.be/gCauTnzpxbs
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=38

### 39. Recursive Shield

Recursive Shield protects browser-use AI agents from audio prompt-injection attacks during sensitive workflows. We built a fake paper-brokerage environment where Gemini listens to market audio and controls tools like read_portfolio, set_field, place_order, and confirm_order. Poisoned audio can subtly steer the agent into unsafe actions such as copying private portfolio data into notes or attempting unauthorized trades. Recursive Shield sits at the tool boundary, evaluates each proposed action against policy, and blocks unsafe behavior before state changes occur. The system also produces labeled trace JSONs for evaluation, guardrail testing, and recursive training.

- **Team:** [VIMALANANDHAN SIVANANDHAM](https://cerebralvalley.ai/u/vimzzss), [Vineeth Rayadurgam](https://cerebralvalley.ai/u/openvini), [Siva Girish](https://cerebralvalley.ai/u/sivagirish), [Nandhakumar Apparsamy](https://cerebralvalley.ai/u/Nandhakumar)
- **GitHub:** https://github.com/vineeth917/Recursive-shield
- **Demo video:** https://www.loom.com/share/8b01beb0c64b4342bb2e2eed20e3f036
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=39

### 40. Dream Harness

HarnessDreams a macOS health app for AI coding harnesses: while your tools rest, it runs a "Sleep Cycle" that scores how well you and your agent collaborated and turns friction into reviewable improvements.

- **Team:** [Yuan Gao](https://cerebralvalley.ai/u/velagao), [jalil laaraichi](https://cerebralvalley.ai/u/reachjalil)
- **GitHub:** https://github.com/reachjalil/harness-dreams
- **Demo video:** https://drive.google.com/file/d/1Q0cBjqeCKd5H1zZajXeKvt2xXsE3atP0/view?pli=1
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=40

### 41. A.S.F

Autonomous SRE agents fail in production for two reasons: a single-shot LLM can't reliably diagnose and fix a real incident, and there's no honest way to know whether the agent caused a recovery or whether Kubernetes just self-healed. We built a harness that solves the first by searching for fixes and grounds the second in a real, decoupled oracle — on a live Kubernetes cluster.
The harness wraps a fixed LLM (no model training) and improves how it remediates through bounded tree search: the LLM proposes candidate actions, a synthesized verifier prunes unsafe branches before they execute, safe actions run on the real cluster with undo on abandoned branches, and an out-of-band oracle scores whether the incident actually resolved. The search is the engine of improvement — it turns an agent that fails a cascade single-shot (0/15) into one that resolves it 8/20, by giving it multiple diagnose→act→verify rounds instead of one guess. We adapted the Code World Models / Auto-Harness method (DeepMind) to SRE, where tree search both finds remediations at the incident level and evolves the safety verifier from real outcomes.
Three validated results, all on real infrastructure: (1) an attribution oracle with a no-agent control arm that credits the agent only for recovery it caused — attributed delta +1.00 [0.62, 1.00] on persistent faults, and correctly reports no signal when the agent genuinely fails; (2) tree-search auto-remediation that cracks a cascade single-shot couldn't, with an attributable lift; (3) a measured safety gap — the synthesized verifier is accurate (0.87) but lets through 38.5% of dangerous actions vs 15.4% hand-written, the exact metric a deployable harness must close. Every number traces to a committed result file; thin margins, an open-weight-only model sweep, and the still-untested safety coupling are reported, not hidden.

- **Team:** [Freja Ren](https://cerebralvalley.ai/u/frejar398), [Ashish Ranjan](https://cerebralvalley.ai/u/ashishranjan2404), [Srushti Sunil Madhure](https://cerebralvalley.ai/u/Srushti247)
- **GitHub:** https://github.com/srushtismadhure/RSI_agents
- **Demo video:** https://youtu.be/pvnXUazfLhk
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=41

### 42. Temper

TEMPER evaluates the harness wrapped around a model — the system prompt, skill files, and tool definitions — not the model itself. It identifies where that environment is helping or hurting performance, generates targeted fixes using Gemini, confirms the fixes work, and honestly flags what it cannot fix.

The key output is the delta column: harness score minus bare-model baseline on identical questions. A negative delta on Tool Call Accuracy means your harness is actively degrading a capability the model natively has.

- **Team:** [Oak Soe Khant](https://cerebralvalley.ai/u/Mr_Shine), [Sheel Shah](https://cerebralvalley.ai/u/shahxsheel), [Aaditya Desai](https://cerebralvalley.ai/u/aadityad)
- **GitHub:** https://github.com/aadityad12/Temper.git
- **Demo video:** https://youtu.be/vBObj6qz28Q
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=42

### 43. Rune

Rune is Stack Overflow for the agentic era.

Coding agents like Claude Code, Codex, Cursor, and other AI coding harnesses are solving bugs inside private sessions — but most of those learnings disappear after the session ends.

Rune passively monitors agentic coding sessions, captures traces, errors, fixes, and context, then turns them into reusable debugging memory. Humans can explore the public bug knowledge base, and future agents can retrieve the same learnings before wasting tokens and time.

The goal is simple: every solved bug should become useful memory for the next developer, the next agent, and the next generation of open-source models.

- **Team:** [Vinay Kudari](https://cerebralvalley.ai/u/vinay), [Alekhya Kodali](https://cerebralvalley.ai/u/buildinghexanaut)
- **GitHub:** https://github.com/vinaykudari/rune
- **Demo video:** https://youtu.be/nC03TTOGq9w
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=43

### 44. tutorAI

AI tutors are everywhere. But are they actually working?

Today's AI tutors are patient, available 24/7, and far less intimidating than a human teacher. Yet there's a glaring blind spot: no one is measuring their effectiveness in a rigorous, scalable way.

That's the problem tutorAI solves. Instead of waiting for real students to give feedback, we deploy simulated AI student agents on DigitalOcean that interact with any AI tutor in real time — asking questions, making mistakes, and responding the way real learners do. We then evaluate the tutor's responses across dimensions like clarity, scaffolding quality, pacing, and knowledge retention proxy scores. In addition, we also evaluate the student understanding because even the best students can only help so much, right? After all, they can't just inject knowledge into a human brain.

The result: a live benchmarking layer for AI tutors — think of it as an automated eval harness, but for pedagogy.

- **Team:** [Henry Qi](https://cerebralvalley.ai/u/henryqi)
- **GitHub:** https://github.com/henryqi-goldenbear/world-fair-hackathon
- **Demo video:** https://youtu.be/OwceukmwHnE
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=44

### 45. Yolo WallStreet Model

YOLO WallStreet is a modular AI trading research system built to forecast short-term stock moves by combining market data, time-series modeling, news ingestion, and large-language-model reasoning. The project is designed around a staged ensemble rather than a single monolithic model, so each component handles a specific part of the prediction problem.

  The core baseline starts with historical OHLCV market data and engineered technical features. A Chronos-based forecasting stage generates forward-looking time-series signals such as expected short-horizon
  returns, directional confidence, and bull/bear scenario estimates. These outputs are then combined with structured market features inside an XGBoost ensemble, which serves as the main numeric prediction
  engine for baseline return forecasting.

  A second pipeline focuses on fresh information. News headlines are collected per ticker through Bright Data, normalized, and stored incrementally so ingestion can resume without repeating completed work.
  These news items are transformed into model-consumable signals through a FinGPT-style feature extraction step. The intent is to detect sentiment, catalysts, novelty, company-specific relevance, and risk
  flags from recent headlines and combine them with the quantitative baseline.

  On top of the baseline forecaster, the system includes an LLM-based adjustment layer using Gemma. Instead of replacing the numeric model, Gemma acts as a bounded adjuster: it reads the baseline prediction,
  recent news context, volatility, and risk indicators, then outputs a constrained adjustment in basis points. This produces a final adjusted return estimate while preserving the baseline model’s stability.

  The repository also includes training scripts for GPU environments, export flows for Mac inference, a FastAPI serving path, model metadata tracking, resumable data pipelines, and production/candidate model
  directories. Overall, YOLO WallStreet is structured as an end-to-end experimental trading stack for building, training, evaluating, and serving a hybrid quantitative plus LLM-driven stock prediction
  system.

- **Team:** [Kaushik Sivakumar](https://cerebralvalley.ai/u/kaushik07)
- **GitHub:** https://github.com/KaushikSiva/yolo-model
- **Demo video:** https://youtu.be/GUDagEwLa1c
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=45

### 46. Darwins

DARWIN — an AI that researches quant trading alphas and measurably gets better at it. Each generation it proposes new trading signals, kills the weak, breeds the strong, and accumulates a vector memory of every win and failure that compounds into sharper research. The twist: it's graded by a judge it can't fool — a deterministic, cost-aware backtest. With memory on, it discovers +119% more profitable signals than its memory-ablated self. Continual learning, measured. "The LLM proposes, the backtester disposes."

- **Team:** [Javokhir Shomuratov](https://cerebralvalley.ai/u/javokhir), [Guangting Yu](https://cerebralvalley.ai/u/GuangtingYu), [Aneesh Durai](https://cerebralvalley.ai/u/aneeshdurai)
- **GitHub:** https://github.com/ShJavokhir/quant-alpha
- **Demo video:** https://www.loom.com/share/8a43cc069e2b4302ab85f9b738b8ed0c
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=46

### 47. Judy

Self-learning Judge and Jury for Question Answering Tasks. To improve the llm-as-judge using recursive self-improvement methods for QA use cases.

- **Team:** [Varshini Balaji](https://cerebralvalley.ai/u/jarvisvb)
- **GitHub:** https://github.com/varshini2305/judy
- **Demo video:** https://youtu.be/GegcriOFonA
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=47

### 48. Gemini CUA Skill Loop

Skill-Loop for Gemini Computer Use
A training-free loop on Gemini 3.5 Flash Computer Use. A kept skill must have passed a verified retry. We measure two things separately: (A) the reliability of a kept skill under re-rolls, and (C) whether the live distillation loop converges in one shot from scratch.

Abstract
Computer-use agents re-attempt every task from scratch and repeat their mistakes. We build a loop that watches Gemini 3.5 Flash Computer Use fail a task, distills a reusable skill from that failed trajectory, retries with the skill in context, and keeps the skill only if a verified retry passes, otherwise it is discarded. No fine-tuning, no weight updates, no reinforcement learning.

We measure two distinct things and keep their results separate. First, the reliability of a kept skill, i.e. re-rolls of the same task with the kept skill held byte-identically in context vs no skill: on ArXiv--23 from the WebVoyager benchmark, graded by WebVoyager's own automatic evaluator, the bare agent failed 3/3 trials under a fixed 30-action budget (budget-exhausted fighting an arXiv form widget) and the agent with the pre-distilled kept skill loaded byte-identically into context passed 3/3 (19–29 actions). The kept skill was earned in a separate prior live run (§3.8). The same kept skill generalised to two held-out tasks from the same template (N=1 graded run each, no held-out baseline; passes are consistent with generalisation but do not establish a pass-rate lift). Second, the boundary of where distillation can help: on Apple--0, a mechanics-bound task whose custom JavaScript dropdown cannot be reliably operated by a pixel-only agent, the keep-gate correctly refused to persist a non-working skill. The combined empirical map: strategy- fixable failures → the loop learns a fix; widget-mechanics failures → it correctly refuses to pretend it can.

A separate experiment (§5.4) running the full live loop from scratch, fresh distillation at every iteration, no pre-loaded skill, converged on iteration 3: the third distilled skill (category scroll-and-read, passed in 9 steps) was persisted by the verified keep-gate. Iterations 1 and 2 (form-filling, url-construction) failed and were discarded. The keep-gate's category-diversity prompt, which forces each iteration to propose a strategy in a different category from prior rejects, was what unblocked convergence, iters 1 and 2 in v1 (no diversity) had cycled inside the same keyboard-shortcut basin. We report both A and C honestly: A measures reliability of a kept skill on re-rolls; C measures single-shot convergence of the live loop from scratch.

To our knowledge, no open-source library combines failure-driven skill learning with a verified keep-gate wired to Gemini Computer Use; we release this as infrastructure papers and benchmarks can build on.

- **Team:** [Renan Serrano](https://cerebralvalley.ai/u/renanserrano-2)
- **GitHub:** https://github.com/renantrendt/gemini-cu-skill-loop
- **Demo video:** https://youtu.be/oye4QkJkveY
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=48

### 49. SeaForge

SeaForge is a Gemini-powered self-learning loop made for Autonomous Surface Vessel manufacturers to test their ships against real Navy mission briefs. Gemini 3.5 runs mission simulations with the cheapest components, learns everything about how it breaks, and iterates to find the cheapest configuration to complete the mission. With each iteration, Gemini stores a persistent memory based on which components repeatedly failed, under what environmental conditions, etc. and continuously improves every simulation.

- **Team:** [Atharv Joshi](https://cerebralvalley.ai/u/atharv29), [Dennis Li](https://cerebralvalley.ai/u/dennislii), [Akilan Paramasivam](https://cerebralvalley.ai/u/akilanp), [Shashvath Srivatsa](https://cerebralvalley.ai/u/shashvaths)
- **GitHub:** https://github.com/deltoidal-icositetrahedron/SeaForge/tree/shash
- **Demo video:** https://www.youtube.com/watch?v=65wGI-LWonM
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=49

### 50. Focal point

FocalPoint is a chat interface that watches how you read and adapts in real time — no feedback buttons, no ratings, no extra effort from the user.

Using your webcam and MediaPipe iris tracking, FocalPoint records where your eyes linger, what you skim, and where you re-read. Every paragraph in every response is a gaze zone. After each turn, a Reward Agent scores those zones: smooth reading earns +1.0, confusion gets −0.5, skimming −0.3, skipped zones −0.2. That signal updates your reading profile on the spot.

A Prompt Agent then rebuilds the system prompt from your profile — adjusting complexity, response length, format, and flagging topics you've struggled with. The model doesn't get fine-tuned. The system prompt does. We call this Recursive Self-Improvement: the AI rewrites its own instructions based on how well its last response was actually read.

A Meta-Agent runs at session end to consolidate long-term memory across six layers — episodic, semantic, procedural, working, sensory, and prospective — so the adaptation carries forward into every future conversation.

The result: a model that starts verbose and expert-level, then learns to meet you exactly where you are. Purely from your eyes.

Stack: React · FastAPI · Gemini · MediaPipe · MongoDB · Antigravity (multi-agent memory)

- **Placement:** Finalist
- **Team:** [Yash Patodkar](https://cerebralvalley.ai/u/ypatodkar), [Jay Patil](https://cerebralvalley.ai/u/jaypatil588)
- **GitHub:** https://github.com/ypatodkar/FocalPoint
- **Demo video:** https://youtu.be/bv-V5vNh_0A
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=50

### 51. Agent University

Agents can already modify prompts, write tools, store memories, and run experiments. But without rigorous infrastructure, self-improvement is hard to trust. An agent may appear to improve while actually overfitting to a visible benchmark, reward-hacking the evaluator, or introducing hidden regressions.

We solve this with three components.

First, we provide an MCP trajectory recorder. It plugs into agent systems and captures the full experimental trace: prompts, tool calls, code edits, terminal commands, observations, metrics, failures, and final outcomes.

Second, we provide skill versioning. Every prompt, tool, workflow, or agent skill can have versions. You can inspect what changed, compare performance, and see the trajectory of improvement over time.

Third, we provide the harness for task-derived private held-out evaluation. The user creates the task, and Agent University helps build private held-out variants, seed splits, evaluator checks, and regression cases from that task. New skill versions are tested on those hidden cases without exposing them to the agent. This lets us detect reward hacking and overfitting before a skill is promoted.

Together, these components create Agent University: a collective learning system for agents. When one agent solves a task, we do not simply copy its final prompt. We preserve the entire trajectory, distill it into a reusable skill, validate it on hidden tests, and transfer it to future agents.

In our Flappy Bird control demo, a baseline agent needed around 100 experimental iterations to find a stable strategy. With Agent University, that experience is converted into a verified skill, and a fresh agent solves a held-out version of the task in about 3 steps.

The core idea is simple: agents should not start from zero every time. But agent learning must be verifiable. Agent University makes agent self-improvement measurable, reproducible, and safe.

- **Team:** [Dixing Xu](https://cerebralvalley.ai/u/dexhunter)
- **GitHub:** https://github.com/dexhunter/agent-university
- **Demo video:** https://youtu.be/XmIldpxqP8c
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=51

### 52. RACx

Recursive Autonomous Customer Experience

Moves the needle from answering a question to solving the underlying ticket.

- **Team:** [Charan Bandi](https://cerebralvalley.ai/u/charanbandi), [Jaspreet Kaur](https://cerebralvalley.ai/u/jaskaur), [yoha g](https://cerebralvalley.ai/u/Yoha)
- **GitHub:** https://github.com/Yoha02/CX_Lab
- **Demo video:** https://www.loom.com/share/4bd0d5522db74170882f7e402032cba6
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=53

### 53. Gambit

Gambit — a self-improving auto-negotiator.

Selling secondhand is a haggling tax: most people anchor wrong, fold early, and leave money on the table, while writing the listing and grinding through lowball offers eats hours. Gambit lists your item, negotiates with buyers to land the best price in reasonable time, and, the point, gets better at it from its own past negotiations, with no human labeling.

It runs a continual-learning loop: one shared policy plays seller and buyer in self-play (the buyer wears a hidden reservation price drawn from a persona), every negotiation is scored by a deterministic, verifiable surplus from the seller's secret floor, no LLM judge to game, and an optimizer reflects on wins and losses to propose one atomic strategy change per generation. A change survives only if a paired A/B on a locked, never-trained-on held-out set raises surplus with zero integrity violations. The model's weights stay frozen; the policy (anchor, concession schedule, accept threshold, walk-away patience, plus per-situation lessons) is what learns. The demo is the curve climbing, and holding on buyers it never trained against. A human can drop into the buyer seat and haggle the trained seller live in the chat UI; it won't sell below its floor.

- **Team:** [Matt Kearns](https://cerebralvalley.ai/u/NudePineapple), [Ankur Garg](https://cerebralvalley.ai/u/ankmister), [Jean Jimenez](https://cerebralvalley.ai/u/jean)
- **GitHub:** https://github.com/clocktower39/gambit
- **Demo video:** https://gambit.nudepineapple.com/video
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=60

### 54. Tutor Loop

Most AI tutors reset every session. They don't remember that you struggled with derivatives, or that a human tutor's graph-first explanation actually worked. TutorLoop fixes that: human tutoring teaches the AI tutor to get better. 

TutorLoop is an education marketplace. Students search and buy notes and textbooks, book human tutors on a calendar, and join live AI voice lectures where they can interrupt and ask questions.

- **Team:** [Akhil Sachar](https://cerebralvalley.ai/u/akhil-sachar)
- **GitHub:** https://github.com/akhil-sachar/tutor-loop
- **Demo video:** https://youtu.be/GDP84_1Xgto
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=52

### 55. rote

Rote is a self-improving computer-use agent for real desktop work. When a task is new, Gemini Computer Use drives the browser or Mac app live; Rote records the run, compiles it into a reusable skill, verifies it against ground truth, and stores it so future requests replay instantly with zero model calls across devices and users just like stack overflow.

It gets faster as it works: searching skill memory, replaying verified workflows through chat or voice, recovering from UI drift, and showing progress through a native Mac notch companion. Rote turns Computer Use from a one-time remote control into a growing library of verified abilities.

- **Placement:** 3rd Place
- **Team:** [Jin Choi](https://cerebralvalley.ai/u/gorajing), [Riccardo Bollati](https://cerebralvalley.ai/u/Bolla), [IkJun Choi](https://cerebralvalley.ai/u/ikjunchoi), [Xiermaimaiti Xiahamuhamaiti](https://cerebralvalley.ai/u/ShahArslan)
- **GitHub:** https://github.com/gorajing/rote
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=54

### 56. Gatekeeper

The trust layer for production web agents. A support agent issues real refunds in a live browser; Gemini 3.5 Flash predicts each screen, a self-trained Gemma LoRA (Digital Ocean) acts, a never-worse gate blocks any upgrade that lies, and every action ships a tamper evident signed receipt

- **Team:** [NarasingaMoorthy Veilukanthaperumal](https://cerebralvalley.ai/u/vnmoorthy)
- **Demo video:** https://drive.google.com/drive/folders/1wxOSSNLgbyRn9hImRr1gMyDGey4U84iw?usp=sharing
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=56

### 57. Cadenza

Cadenza is a composition feedback tool that learns each composer's individual voice over time, becoming more useful the more it's used. Most music feedback tools give everyone the same generic rubric, so a composer's tenth submission gets evaluated exactly like their first, with no memory of their patterns or growth. Cadenza evaluates work across six dimensions and accumulates every evaluation into a per-composer profile that gets sharper with each submission, surfacing specific observations about that composer's tendencies, blind spots, and stylistic goals. It fits the Continual Learning theme because it improves through its own outputs with no retraining or user intervention, getting to know the composer automatically as they keep creating.

- **Team:** [Jeeya Khetia](https://cerebralvalley.ai/u/jeeya1)
- **GitHub:** https://github.com/jk118/cadenza
- **Demo video:** https://youtu.be/9Yi4S5GAQFI
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=58

### 58. Shadermind

An agent that draws. You become the artist.

ShaderMind is a drawing tool — but the hand holding the pen is an agent. It generates live GLSL sketches; you steer with 1–5 ratings and short notes. It learns your taste over time and nudges each new batch a little closer to what you love and wanted to see.

Like a sketchbook that remembers: everyday shaders, small changes from the last, not reinventions. Inspired by Zach Lieberman's daily code sketches. The 3,650 count is a north-star metaphor for that practice — not a calendar.

Under the hood, preference memory follows PLUS: your taste compressed into readable text that sharpens every batch — joined with code-aware retrieval, a curated pattern library ranked by your ratings, per-shetch critique, and an optional voice curator you can talk to in a LiveKit room.

- **Team:** [Rae Jin](https://cerebralvalley.ai/u/raejin), [Tommy Purcell](https://cerebralvalley.ai/u/tommypurcell)
- **GitHub:** https://github.com/jin-dalrae/shadermind
- **Demo video:** https://youtu.be/t4cmX0g9Sto
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=55

### 59. IntoTheUnknown

An AI discovers an unknown planet's physics and learns how to discover the physics laws by updating its weights and then records discovered facts into the memory, mimicking how humans learn.

- **Team:** [JungDae Suh](https://cerebralvalley.ai/u/ForAllManKind)
- **GitHub:** https://github.com/jungdaesuh/IntoTheUnkown
- **Demo video:** https://youtu.be/UKjK_lIQKxs
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=57

### 60. DynaAgent

Existing Multiagent systems are typically built around predefined agent roles and static workflow. They have limited ability to create new specialist agents at runtime, evaluate their effectiveness and adapt their workflow based on task requirements.  This work proposes a self evolving multistage framework that dynamically synthesis agents, constructs adaptive workflows, evaluates agent performance and refinance future executions through accumulated experience

- **Team:** [Anantha Kandrapu](https://cerebralvalley.ai/u/ARK_BABA), [Karthik Ravi](https://cerebralvalley.ai/u/kaddynator)
- **GitHub:** https://github.com/kaddynator/self-evolving-harness
- **Demo video:** https://github.com/kaddynator/self-evolving-harness/raw/main/Evolutionary_AI_Engineering_Teams/dist/harness-demo.mp4
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=62

### 61. Marine Gravity

An agentic coding manager that continuously improves to deliver high quality PR with minimum human input. It tracks software engineer requests into coding episodes, runs coding agent workers, and coordinates review, approval, and integrations across GitHub, Linear, and Slack.

- **Team:** [Julaiti Alafate](https://cerebralvalley.ai/u/julaiti), [Akshat Gupta](https://cerebralvalley.ai/u/akg007)
- **GitHub:** https://github.com/arapat/marinegravity
- **Demo video:** https://youtu.be/dasRGLxqG6Y
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=59

### 62. 9320

Kun is a mission-control cockpit and runtime for autonomous ML experiment loops — and the open standard those trajectories are logged in.

Run-centric tools (W&B/MLflow) show params, metrics, artifacts, curves. Agent-tracing tools (LangSmith/Weave) show prompts, calls, spans, cost. Autonomous ML experimentation needs a trajectory-centric interface:

mission
  -> hypotheses
    -> code/config diffs
      -> experiments
        -> metrics/evals/failures
          -> decisions
            -> branches/forks/human interventions

The wedge/moat is ecosystem position, won the way LangSmith/OpenTelemetry won observability: be the thing you instrument your existing loop with (Mode B) and run your research on (Mode A) — not a novel algorithm.

Kun works in two modes:

Mode A — Kun drives. Its LLM planner proposes a change, a patcher applies it (config edits or real code edits via a coding-agent subprocess), the runner trains/evals, and it decides what to try next. Steering has teeth: fork, approve/reject, and mid-run instruct all execute.

Mode B — Kun observes/steers an external loop. Any loop emits Kun's event format in ~5 lines via kun_log, and (optionally) reads Kun's steering back through a feedback channel. Add-on, not a replacement.

- **Team:** [Shiven Mian](https://cerebralvalley.ai/u/shivenmian)
- **GitHub:** https://github.com/shivenmian/kun
- **Demo video:** https://youtu.be/r4zlj8eG3ag
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=61

### 63. LaunchLens

LaunchLens helps teams safely test and launch AI agents. Today, agent behavior is often defined across messy chats, docs, shared demos, and last-minute feedback, while QA is still mostly manual. LaunchLens converts those requirements into a golden QA flow, then uses Gemini Computer Use to test the agent through the browser like a real user. It captures screenshots, transcripts, latency, pass/fail evals, drift from expected behavior, and recommended fixes. The goal is to make AI agent testing repeatable, measurable, and self-improving before teams ship to users.

- **Team:** [Rajashekar V](https://cerebralvalley.ai/u/raj)
- **GitHub:** https://github.com/rajashekarcs2023/launch-lens
- **Demo video:** https://youtu.be/trnLMEOZt5M
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=63

### 64. yunaki

Yunaki :  shared memory and self-evolving skills for agent teams. Your code, your model, your memory — shared across your team

- **Team:** [Yugandhar Gopu](https://cerebralvalley.ai/u/Yugandhar_gopu)
- **GitHub:** https://github.com/Yugandhar-G/yunaki-skills
- **Demo video:** https://www.loom.com/share/64041e3dcb3743ac9ab766598363704a
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=64

### 65. RevMem

governance and context for autonomous enterprise agents

- **Team:** [Neil Joshi](https://cerebralvalley.ai/u/njoshi22), [Angeline Guo](https://cerebralvalley.ai/u/angeline), [shiliu woshi](https://cerebralvalley.ai/u/woshishiliu)
- **GitHub:** https://github.com/njoshi22/aie
- **Demo video:** https://www.youtube.com/watch?v=5ckXiCOgO8o
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=65

### 66. liminal

Companies are starting to manage teams of AI agents like teams of people — and can't answer the question that follows: is all that AI work actually moving the goals we resourced it for? Liminal is the governance layer for agentic work that gets smarter every time a human corrects it. It catches when agents drift from the goal (a $1.2M deal silently dropping a required EU-data-residency clause), enforces the human correction as real operating state — flipping status, blocking the bad downstream action, sealing a tamper-evident audit — and turns that correction into an eval the next agent pass is graded against: Fail → Pass. Built on a real governance loop, live Gemini inference, LiveKit, and DigitalOcean. The Self-Improvement Stack for agentic work.

- **Team:** [Shruti](https://cerebralvalley.ai/u/LiminalShruti), [Sean Nejad](https://cerebralvalley.ai/u/kuzushi_security)
- **GitHub:** https://github.com/liminalshruti/liminal-engine
- **Demo video:** https://drive.google.com/file/d/1bhRbXRLWctrXax0WDAVuKR2KVdzkxxOM/view?usp=sharing
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=66

### 67. Muse the Agent

## StoryForge: AI-Powered Children's Storybook Generator

**From imagination to illustrated eBook in minutes.**

StoryForge is an end-to-end AI pipeline that transforms a simple character idea into a fully illustrated, publish-ready children's storybook — complete with cohesive narrative, custom artwork, and an EPUB you can read on any device.

### What It Does

Using Google's agent pipeline and a three-skill architecture, StoryForge handles every step of the creative process:

1. **Character Creation** — Define your hero, their world, and their adventure
2. **Story Generation** — A coherent, age-appropriate narrative built page by page
3. **Illustration** — AI-generated images matched to each page, maintaining visual consistency throughout

### Two Modes, One Pipeline

- **Nano-Bana** — A 5-minute illustrated story, perfect for bedtime
- **Nano-Bana Pro** — A full 10-minute adventure with richer detail and more pages

Both modes output a polished, fully illustrated **EPUB** — ready to share, print, or publish.

### Why It Matters

Creating a children's book used to require a writer, an illustrator, and weeks of iteration. StoryForge collapses that entire workflow into a single agentic pipeline, making personalized storytelling accessible to parents, educators, and creators everywhere.

- **Team:** [Mark Blake](https://cerebralvalley.ai/u/weekendsuperhero)
- **GitHub:** https://github.com/WeekendSuperhero/story-book-generator
- **Demo video:** https://youtu.be/G1HKkc5eEKs
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=67

### 68. RAX

RAX is a real-time, low-latency robotic agent framework powered by Gemini 3.1 Flash Audio and LiveKit Agents. By leveraging a persistent, bidirectional WebRTC/WebSocket pipeline, RAX enables an autonomous robot to "see" through its camera, "hear" user spoken commands, process environmental context multi-modally, and execute precise physical actions (like gaze-tracking or halting) via asynchronous function calling—all with natural, conversational, and instantaneous voice feedback.

- **Team:** [Armin Foroughi](https://cerebralvalley.ai/u/arms)
- **GitHub:** https://github.com/arminforoughi/RAX/blob/main/docs/gemini_livekit.md
- **Demo video:** https://youtu.be/TxFt6AMlrpg
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=68

### 69. VOICE-BRIDGE

Voice Bridge is a real-time, multimodal lip-reading assistive-communication tool for people with ALS. As ALS progressively destroys speech (80–85% of patients lose  
  ▎ intelligible speech) while leaving the mind fully intact, urgent needs — "water," "raise the bed," "I'm choking" — can take minutes to communicate. Today's          
  ▎ alternative, a $15–20k eye-tracker, is fragile to lighting and head angle and is abandoned by 30–50% of users.                                                       
  ▎                                                                                                                                                                      
  ▎ Voice Bridge reads the mouth instead of the gaze — the signal a patient can still produce — and fuses lip movement with blinks and small gestures to recover intent  
  ▎ even when audio fails. Recovered intent is spoken aloud and routed as severity-graded, role-aware alerts (comfort → caregiver, clinical → nurse, emergency → entire  
  ▎ circle of care), and the patient-specific understanding persists across staff turnover so a new nurse inherits what the system already knows.                        
  ▎                                                                                                                                                                      
  ▎ It runs on an ordinary camera and laptop via a capture → VSR → TTS adapter pipeline: a zero-dependency offline default that works today, with hosted lip-reading     
  ▎ (Claude vision) and expressive voice (MiniMax) that activate when keys are provided.                                                                                 
  ▎                                                                                                                                                                      
  ▎ Honest caveat: this is an early assistive-research prototype, not a clinically validated medical device.

- **Team:** [Sachin Naik](https://cerebralvalley.ai/u/sachin-crispai)
- **GitHub:** http://github.com/sachin-crispai/voice-bridge
- **Demo video:** https://youtu.be/gWhJOBuKFZ4
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=69

### 70. Nidra

Nidra (Sanskrit for "sleep") is a self-hosted personal assistant that learns who you are from what you actually do online, then sleeps on it.

A privacy-first browser extension captures the signals: what you read, what you search, your calendar and email activity. It runs on Chrome and iOS Safari from one codebase, and everything stays on your own hardware. Password and payment fields are never captured, and banking or auth sites are skipped entirely.

Two layers sit on those signals. Opinions are grounded beliefs about you, each with a confidence score and a link back to the evidence (read a dozen Rust articles, so probably into Rust). Dreams are the nightly sleep pass: an on-device model (Gemma, via Ollama) reads your recent activity and makes a leap heuristics can't. Flight searches, a car rental, and some reading about ryokans become "probably planning a trip to Japan."

What keeps it honest is one rule: a dream never becomes a belief by itself. It has to be confirmed by something you do later, and dreams nobody acts on expire. Over many cycles the system gets better at dreaming, judged against what really happened instead of grading its own work, which is the failure mode that quietly breaks most self-learning systems.

- **Team:** [Nagarjuna Kanamarlapudi](https://cerebralvalley.ai/u/nagarjunak), [Praveen Kanamarlapudi](https://cerebralvalley.ai/u/Praveenk)
- **GitHub:** https://github.com/nagarjunakanamarlapudi/Nidra
- **Demo video:** https://youtu.be/pvJzgQI6WCs
- **Project:** https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery?project=70

---

Markdown version of https://cerebralvalley.ai/e/aiewf-hackathon-2026/hackathon/gallery. Site index for agents: https://cerebralvalley.ai/llms.txt · full text: https://cerebralvalley.ai/llms-full.txt