Developer Projects

Greplica runs a portable reviewer-and-coder loop for GitHub pull requests. A reviewer agent scores the change, reports blocking findings, and hands them to a coding agent. The coding agent repairs the branch and pushes updates, then the reviewer checks the new version until it reaches the approval threshold or the repair limit. Band coordinates the persistent reviewer and coding agents and creates a dedicated room for each pull request. Senso supplies repository context retrieved from ingested pull-request markdowns. The team benchmarked four context strategies on Autoloops/greplica PR #176—including no context, a gold context file, live GitHub context, and Senso-native context—and documented how context changes repair quality and speed.

Lattice is a local-first workspace designed for people who think across documents, structured data, code, and AI. Instead of separating notes, databases, whiteboards, files, and automations into different applications, Lattice brings them together in a single open platform built around standard file formats and a fast native desktop experience. Your data remains yours, stored locally and organized in a way that’s human-readable, portable, and accessible to both people and AI. Beyond note-taking, Lattice serves as a foundation for intelligent workflows. Built-in AI can understand and organize your workspace, search across structured and unstructured data, generate content, automate repetitive tasks, and connect to external tools through an extensible plugin and MCP ecosystem. Optional cloud services add encrypted backup, sharing, publishing, and scheduled automations without sacrificing the local-first architecture, giving you the speed and privacy of a desktop application with the convenience of modern cloud collaboration. We use Pioneer to provide an affordable integrated AI agent which can do embedded and hybrid search over the workspace's embeddings via a local Actian AI DB instance.

Sift is a cognitive governance layer that sits in front of AI assistants to reduce cognitive offloading. Instead of immediately answering every prompt, Sift evaluates whether the user has demonstrated independent thinking or is relying entirely on AI to reason for them. When excessive cognitive offloading is detected, the system temporarily intervenes with Socratic questions that encourage users to form their own hypotheses before receiving AI assistance. By promoting active reasoning rather than passive consumption, Sift aims to preserve critical thinking while maintaining AI as a collaborative tool rather than a replacement for human cognition.

Matches clinical trials to patients based on EHR data and sends emails to them. Uses pioneer and guild.

CONFESSION is an external referee for AI coding agents. When a builder agent announces that a task is finished, its self-report is ignored. An independent Auditor agent hands the claim to Replay.io's autonomous QA API, which explores the actually deployed app and returns a root-cause verdict with a shareable report URL. That verdict drives real consequences with no human in the loop. A FALSE_CLAIM immediately revokes the agent's write tools via a Guild.ai tool-grant demotion, and the caught lie is added to a Pioneer training set so a LoRA fine-tune yields a more honest successor. A VERIFIED result advances a ratchet; enough consecutive passes promote the agent to a more powerful tier, and any lie knocks it back down. Nothing is staged: a real CRUD target app, no planted bugs, live API verdicts, real workspace state transitions, and a real fine-tune job. A receipts view dumps live state (Replay report links, Guild session JSON, Pioneer job IDs) so judges can verify instead of trusting the demo. The result is autonomy an agent has to earn against ground truth, continuously and with receipts.

Plato Autopilot — A Governed Team of AI Restaurant OperatorsPlato Autopilot is a multi-agent restaurant management system that turns live operational data into measurable business improvements. A General Manager agent coordinates specialized agents for inventory, menu optimization, revenue, kitchen operations, and purchasing. Each agent has its own expertise, data access, and tools, with identities, permissions, and activity governed through Guild AI. Together, the agents identify high-impact opportunities, propose measurable goals, and safely execute approved actions—such as promoting specific menu items, allocating expiring inventory, adjusting kitchen preparation, or drafting supplier-order changes. Plato then measures the results against independent demand, updates restaurant records in real time, and learns from both successful and failed experiments. It is an auditable, continuously improving team of AI operators that closes the loop: **Observe → collaborate → govern → execute → measure → learn.**

Kindred is a semantic matching platform that builds a live graph of the people closest to you in meaning, and shows the reasoning behind every match instead of just a score. Drop in your context, and the Profiler builds a semantic vector of how you think. The Matcher scores and ranks candidates against it, and the graph reorganizes live as the model updates. Click any node and the Introducer explains the actual reasoning behind the match. The Evaluator tracks which connections land and feeds that signal back, so closeness is a learned function, not a fixed similarity score. On /village, the same matching process plays out as a pixel-art town where agent-villagers deliberate a match out loud and reach consensus, built to be data-driven and livestream-ready. Built with Actian for vector storage, Fastino for fine-tuning the Matcher on real landing data, Gemini for profiling and reasoning generation, BAND for intro threads, and Guild for weight versioning. Four agents, one shared contract, five hours of ideation before a single line of implementation.

A patient calls the clinic. Donna (VAPI + Twilio + Deepgram, Gemini in-call) answers, transcribes live onto the receptionist console, extracts structured symptoms/meds/allergies, and matches or creates the patient record — with a one-click identity-repair flow when ASR mis-hears a name. A deterministic, clinician-tunable triage engine (35 unit tests, no LLM in the acuity decision) scores every call ESI 1–5; life-threat patterns like chest pain + left-arm radiation hard-gate to Level 1 and Donna verbally instructs the caller to dial 911. The doctor opens a pre-built chart, a SOAP note streams in with ICD-10 codes and red-flag pre-scan, edits, and signs. Self-evolution is measured, not claimed: Donna's pristine AI draft is saved before any human edit, and the word-level edit distance per successive call is charted live — plus doctor corrections POST back to Pioneer's adaptive inference as labeled examples, and signed revisions distill into embedded clinical lessons retrieved into the next similar encounter (vector search on-prem via Actian VectorAI/MiniLM, so PHI never leaves the clinic). Every agent and human action is audited with tamper-evident hashes. Live phone number, real calls, offline-safe canned demo. 72 passing tests.

Self evolving browser agent

Prompt injection is why enterprises won't give agents write-access, and every defense today is static. Immune closes the loop: two LLM agents co-evolve — an attacker probing whatever isn't yet covered, and a defender that patches itself when breached. The defender is guarded at the action boundary, just before a sensitive tool call fires. On a breach, synthesis reads the agent's own raw trace and emits an antibody: a rule in a composable predicate language. The LLM composes freely; nothing it writes runs as code — we interpret a closed grammar. Every candidate faces a three-sided gate: replay the attack (must block); replay 8 mutations — recipient zero-width-split, amount regrouped as $4,850.00, pretext reworded — all of which must block, rejecting rules that only memorized one payload; and 12 benign tasks, 2 needing a real payment, so a patch can't buy security by lobotomizing the agent. We plot co-evolution, not attack success rate: a breach means the attacker found uncovered ground — its job. Sword = verified defenses in force when it still got through (0→4). Shield = attack variants provably blocked (9→38). Senso: versioned antibody library — gen 4 defeated a live rule, promoting a native v2. Band: attacker, defender and peer as registered agents; promotion broadcasts a quarantine advisory the peer drains. Actian: OpenAI-embedded signatures scoring attack novelty. Claude drives all three agents. Replay QA'd the console.

Dark Harvest is a mission-operations prototype that continuously monitors NASA/JPL Deep Space Network links, OpenSky aircraft, and CelesTrak satellite data.

Small businesses in Latin America (Specially the Dominican Republic and Colombia) sell on WhatsApp, in voice notes and slang. DeUna answers as the owner — same voice, same selling style, same price floor. When it meets something it was never taught — a cracked-screen trade-in, a discount below the floor — it doesn't invent a number. It asks the owner on WhatsApp, with its own recommendation and Aprobar / Rechazar / Otro monto buttons. One tap. The ruling is saved to Senso as policy, and the next customer asking the same thing gets an instant quote, no escalation. It gets smarter every time the owner teaches it. Customers send voice notes, so it replies with one — transcribed by ElevenLabs Scribe v2, spoken back in the owner's cloned voice with room tone so it sounds recorded behind the counter. Guild.ai is the agent runtime: policy search, owner escalation, catalog, checkout. Senso.ai is the memory that makes the loop self-evolving. Pioneer routes each turn — DeepSeek-V4-Flash for easy questions, Claude Sonnet for hard trade-ins. ElevenLabs does voice both ways. It negotiates inside a confidential floor price and closes with a payment link.

The QA agent that gets **cheaper** **every time you ship**. Replay QA finds real bugs in a live app, Ratchet fixes them, and a fix enters memory only once a re-test confirms it worked. Next time that cause appears, anywhere, it costs one AI call instead of four. Verified fixes publish, so they cross teams.

Evolving Poker is a live agent-evaluation playground where three AI models compete in a simplified poker game and adapt their strategies after every hand. Each player starts with the same strategy—aggression, bluff rate, and call threshold—while a deterministic game engine handles cards, betting, and legal actions. After each hand, the agents review the outcome and decide whether to change their strategy or keep it unchanged. Every update is shown as a readable diff, allowing viewers to compare which model learns effectively, which overreacts to noisy results, and which offers the best balance of performance, latency, and cost. Pioneer runs and compares the models, Band coordinates the agents and records their reflections, and Replay tests the spectator dashboard. The final tournament results and evolution history are published to cited.md, with the full audit report available through an x402-protected endpoint.

I have an LLM Judge that tracks coding agent turns and user input and judges the coding agent output and if it's satisfactory for the user. The goal is to reduce LLM coding friction and increase coding agent understanding of user intention. The platform also supports trace-tracking for when errors occur, or when critical infrastructure problems arise. The traces are logged, and using deterministic checks, it would not occur again. So, in total, it tracks errors, mistakes, coding agent turns, user turns, and improves the LLM judge over time through these traces. Users are also able to fine-tune their own model through these traces and specifically create a model just for themselves.

Event Copilot is a self-improving event-recommendation agent. It helps a user choose events for networking, knowledge, and opportunity outcomes; creates a measurable attendance mission; publishes grounded output; and learns from post-event feedback so later rankings improve.

You just show up. No signup, no app store, no Discord invite — you open a link and you are in, and from that moment you talk to exactly one thing: your own agent. It talks to everyone else's. Ana writes in Spanish that she lost a blue backpack; her agent splits it into a public summary another agent may read and a detail it withholds — a red enamel fox pin. Ben writes in English that he found one. **Actian** **VectorAI** matches them across languages, Ana's agent asks a question only the true owner could answer, and Ben answers *his own agent* — what crosses back is a verdict, never the answer. Both phones light up with the same generated emblem, phrase and sound, and they meet without either learning who the other is. Staff work the same way: they ask an area for something and each person is *asked*, not tracked, while questions from the floor group into one item they answer once, returning in each person's own language. The invariant is the product: participants never exchange messages, names, photos or coordinates, and there is no table in the schema that could. Every string crosses a guardian twice, deterministic rules and a model classifier combining to the **strictest verdict,** the model may raise severity, never lower it, and if it is unreachable the rules still decide. **Pioneer** runs that guardian on specialist encoders returning PII spans a yes/no classifier cannot; **Senso** turns each staff answer into verified, cited ground truth.

Turns classified Instagram-post data into interest plans, publishes `cited.md`, and evolves itself on real accept/reject feedback.  **Python 3**, one shared `venv/` - **Flask** — `webui.py`, localhost-only dashboard - **Docker** — self-hosted VectorAI DB container `mlx-community/Qwen3-30B-A3B-4bit` | `mlx_lm` | policy reclassification, taxonomy category naming, item tagging | | `nomic-ai/nomic-embed-text-v1.5` | `torch`/`transformers` | VectorAI DB embeddings (recall + clustering)  | **Senso** (`apiv2.senso.ai`) | ✅ real — KB ingest + grounding | | **VectorAI DB** (Actian, self-hosted) | ✅ real — episodic memory, taxonomy clustering | | **Pioneer** (`api.pioneer.ai`) | ✅ real API call every retrain pass, blocked by account billing — the actual retraining outcome comes from a local reimplementation instead | | **Guild** | local JSONL stub, no key | | **Band** | not used — replaced with a local ACP-shaped orchestrator | | **Replay.io** | credentialed, unused | | **x402/CDP payments** | cosmetic banner only |

Vocare is an autonomous voice agent that acts as a real-time compliance officer for utility hardship intake, replacing costly human teams who must navigate $4.13B+ in FY2026 LIHEAP funds across 50 fragmented state PUC regimes — a setting where a plain LLM is unsafe, since a hallucinated approval creates real legal and financial liability. It encodes state rules into a rigid, executable ruleset, interviews applicants by voice (via ElevenLabs, with Azure gpt-realtime-2.1 as a swappable alternate), and matches facts to the ruleset to approve payment plans or block disconnections, with every decision auditable back to a statute. Guild governs two agents — an approval gate with an affordability clamp, and a knowledge-ratification agent — so when a caller mentions a program outside the ruleset, the agent flags it instead of bluffing, a human ratifies it, and the very next call already knows it: the system gets measurably smarter after every conversation, but only from human-approved facts, never self-taught. Actian VectorAI adds explanatory-only retrieval and Replay will handle end-to-end QA.

**Clarity** is an AI-powered simulation and workflow platform engineered for clinical trial scientists, health-tech R&D teams, and medical researchers. By combining vector-driven historical retrieval, multi-agent reasoning, automated human-in-the-loop escalation, and audit logging, Clarity turns the "black box" of study design into an agile, transparent, and data-driven process. Instead of spending weeks running fragmented simulations and manually tweaking eligibility criteria, research teams can stress-test study parameters in minutes—saving hundreds of thousands of dollars, preventing costly study delays, and bringing life-saving treatments and health technology to market faster.

Check README. Unable to Copy and Paste.

Reinforcement Learning is the ultimate agent loop. Simple 2d robot builder interface in Three.js and webGPU. One click to send to my RTX 4080 at home via TailScale for Reinforcement Learning training run to teach a curriculum of standing then locomotion. The loop is the RL loop, the goal is standing then locomotion.

**This project is a state of the art self-improving agentic system generator.** The goal is to from a problem definition and boundaries generate an agentic system and later through either historical data or future inference continuously improve the architecture. We are improving not only this individual architecture but also all the other architectures created by the system. In order to stay state of the art the baseline for the hackathon wasn't a vibe-coded package but a heavily researched state of the art evoAgentX system that we packaged into a productionized application and extended with all the great sponsor solutions: https://github.com/EvoAgentX/EvoAgentX/ What is being improved: - agentic execution graph definition - individual prompts - underlying models To create the solution we utilized the below sponsors:PIONEER (evox_api.adapters.pioneer): Wraps the REST gateway to validate models and route prompts. SENSO (evox_api.adapters.senso): Connects to the API to ingest documents and retrieve exact citations. ACTIAN VECTORAI (evox_api.adapters.actian): Connects to the vector DB to index and query past run outcomes. BAND (evox_api.adapters.band): Manages escalation tasks and feeds human decisions back into jobs. GUILD.AI (evox_api.adapters.guild): Publishes workflows to lock release versions and evaluator rules.

Shrek is a multi-agent stock forecasting system for stocks. News, historical, and real-time analyst agents generate standardized directional signals, which a forecaster combines using bounded, learned weights. Each agent selects its own equation through structured Gemini reasoning, and every prediction records the prompt, equation, model, policy version, and configuration used for full auditability. A daily learning cycle compares forecasts with actual stock closing prices and adjusts the weights based on performance.

Self-evolving money-making agents with verifiable self-evolving harness Hammurabi carved the first legal code in stone. Ours writes itself. We seed one CEO agent with $5. Unattended, it runs a real company: claims bounty tasks from client agents, delivers LLM work, gets paid into a live ledger. It distills each success into a reusable skill, cutting cost per task by 85%. When backlog builds it computes make or buy, posts jobs, takes worker bids, hires, verifies, pays wages. That is Loop A. The company evolves. Loop B is the reason any of this is shippable. Every money movement passes through one deterministic choke point: compiled contracts, sub millisecond, zero LLM in the enforcement path, built on Sponsio's open source runtime enforcement engine. But hand written rules always have gaps. So when the company does something no rule forbids, a General Counsel agent mines a new contract from the offending trace, then proves it on a gate: it must fire on the bad trace and stay silent on every good one. Only then does it hot reload into the charter. Watch it live. A greedy worker invoices before delivering. Both founding contracts pass. It gets paid for nothing. Seconds later the General Counsel mines must_precede(deliver, pay), proves it, arms it. The next attempt is DENIED by a law no human wrote. The strategy evolves. The law evolves faster. Only one of them is allowed to make mistakes.

LockedIn is an always-on iMessage scheduling agent that runs on your Mac and replies to known contacts using Pioneer AI. It connects to Google Calendar so it can read your agenda, find free time, plan work before deadlines, and create, move, or delete events through chat. A local CLI lets you send daily/weekly check-ins, reset conversation context, and watch a live activity log while the bot polls Messages in the background. The system is built to learn the user’s voice and preferences over time, with calendar tools and optional discovery feeds (papers/events) feeding into a more personal schedule assistant.

InspirationModern AI can generate ads, but it doesn't actually learn from them. Marketing teams still spend weeks researching brands, brainstorming campaigns, running A/B tests, and manually incorporating those learnings into future campaigns. We wanted to build an autonomous system that closes this loop. Instead of simply generating ads, we asked: what if an AI could continuously improve its understanding of a brand based on how its own ads perform? That became SwarmAds.What it doesSwarmAds turns any brand URL into a self-improving advertising engine. Starting with only a brand website and product image, a swarm of AI agents researches the brand and builds a verified knowledge base containing its messaging, positioning, tone, value propositions, and target audience. Using this context, the system generates multiple ad creatives, each representing a different combination of messaging angle, hook, persona, and visual style. Instead of waiting weeks for real campaign data, those ads compete inside a synthetic market with hidden audience preferences. A reinforcement learning agent uses Thompson Sampling to discover which creative strategies consistently outperform the others. Rather than stopping there, the system writes those learnings back into the brand's knowledge base before generating a second generation of creatives. Every iteration starts from a richer understanding of the brand than the previous one.

SwarmOps is the management layer that makes an AI workforce safe to run in a real company. A six-agent AI company (CEO, PM, Developer, Security, QA, Finance) runs real missions under **deterministic governance**: production deploys pause for human approval, unauthorized data exports are blocked, and every action is written to an immutable, Postgres-backed audit trail. When a mission finishes, the workforce **safely self-evolves** — each agent is scored from persisted data, improvements become new immutable versions, and high-risk upgrades require the same human approval as a production deploy. The enforcement path contains no LLM and no randomness, so governance is fully deterministic and auditable.

**Patiento** helps ICU clinicians review and improve daily care plans without slowing rounds. Fast, accurate judgment is a matter of life and death. **The problem**. Every shift, physicians write dense clinical notes and revise Assessment & Plan under time pressure. Important details can get missed, prior judgment isn’t carried forward cleanly, and the same bad suggestion can keep coming back. Review help that ignores what a clinician already accepted or rejected isn’t useful—and can erode trust. **What it does**. A clinician opens a patient, drafts or edits the SOAP note, and submits for review. Rounds proposes focused clinical plan changes grounded in the chart. The clinician accepts or rejects each one, with a short reason, then signs when ready. It sits beside the workflow clinicians already know: census, vitals, labs, meds, and the note itself. **How it evolves**. Rounds remembers this patient over time—prior notes, past proposals, and whether the clinician accepted or rejected them (and why). Rejected ideas are less likely to resurface; accepted guidance and outcomes shape future suggestions. The copilot gets sharper with use, not noisier. **Why it matters**. Faster, more consistent plan review; fewer repeated false starts; and a review partner that learns from the clinician’s judgment—not a black box that forgets yesterday’s decisions.

A scheduling SaaS that detects, diagnoses, and repairs its own safety defects — and gets faster every time it sees one. Regenesis runs a real product, MedShift (hospital shift scheduling), under a live self-healing loop. When a defect ships, the app's oracle surfaces genuine violations, an agent running on Guild recalls whether it has seen the failure before via Actian VectorAI DB, patches the rule that caused it, and verifies. Replay Loop QA explores the deployment as the external quality gate. The app's health is rendered as a patient monitor: the ECG trace is the open-finding count. Sabotage reads as arrhythmia; healing returns it to sinus rhythm. Theme: self-evolving agents. The genome is a mutable rules config; memory is a vector collection; natural selection is externally-judged QA. All three integrations are live. No mocks in the paths described below Guild — Best use of agentschineseman~regenesis-healer is published and running on Guild, driving a real external application. Replay — Best SaaS app with completed QAMedShift is a genuinely designed SaaS for a complex domain (certification, rest windows, overtime, consecutive days, coverage minimums), and Replay Loop QA is the external gate on the real deployment. Actian — Best use of Actian VectorAI DB Actian is the agent's memory — what makes this evolution rather than retry.

We built WeRHungry, a real-time operating layer for busy commercial kitchens. An OpenCV/VLM pipeline converts a kitchen scan into a colored GLB digital twin identifying stations, equipment, workers, inventory, and safe aisles. During service, workers double-press a wristband to see their next task, required tools and ingredients, and a safe route. One press accepts; another double press passes and requests a replacement. Firebase powers authentication, live state, task events, GLB storage, and hosting. Firestore Vector Search retrieves similar past incidents, allowing agents to combine historical outcomes with current queues, staffing, equipment, and inventory to predict completion times and explain delays. Specialized Perception, Forecasting, Memory, Reasoning, Scheduling, Critic, and Coordinator agents collaborate through a Guild-compatible control plane. Pioneer ranks causes and actions while learning from manager corrections, and Replay tests critical application workflows. The operating method is universal, but each restaurant evolves its own demand, preparation, capacity, and staffing policies.

A swarm of specialized AI agents continuously analyzes your website and competitors and produces strategic recommendations. No workflow changes. No manual comparison. No spreadsheets.

MinToken helps AI products spend fewer tokens without sacrificing answer quality by checking whether a new prompt can safely reuse a previous approved answer, retrieving relevant local context, and routing the request to the right model tier based on task difficulty.

An AI agent built using **SERP API, Apify, and Perplexity** that continuously monitors LinkedIn to identify people and companies announcing **layoffs** or **new hiring initiatives**. It automatically surfaces relevant posts, helping recruiters, founders, and job-search platforms discover hiring opportunities and recently affected talent in real time.

Most voice agents forget the moment the call ends. Accellio gets better because of it. It briefs a seller before a CFO meeting from public signals, then reads the transcript itself - nobody types notes. It grades that briefing, rewrites its own briefing policy, and regenerates the briefing. Between the meeting ending and the better briefing appearing, human inputs: zero. The hard part is proving "it improved" isn't self-graded. Senso verifies each claim against its own ground truth and contradicted three of ours before our evaluator ran. Evaluation is deterministic checks first, Senso second, a model rubric last. The learning is mechanical, not cosmetic. Patches change evidence-reliability weights feeding Actian's vector ranking, so the next briefing retrieves different sources. Pioneer runs reasoning and embeddings. It also knows what it isn't entitled to decide. Down-weighting an evidence source across every account, on one meeting, is escalated to a human through Band — and the loop carries on without waiting. A reviewer agent we published to Guild, on their runtime, gives an independent second opinion. It usually says no. **Five sponsor tools serve, each with a working fallback.**

Argus — Universal Testing AgentArgus turns a product doc and a live URL into an end-to-end QA run. It compiles ground truth, plans tests two ways, executes them in a real browser, and only files bugs to Jira after a human approves. How it works Senso — Ingests your document into searchable ground-truth rulesPioneer — Routes Gemini models and writes grounded test cases from those rulesReplay — Adds exploratory cases from session behavior (reviewable with pause/resume)Argus — Merges both plans and runs them live (login → inventory → add to cart on SauceDemo)On failure — Re-records an isolated Replay clip of the failing stepBand — Pings QA for Accept / DeclineGuild — Files a real Jira ticket with session + clip linksWhat you see A live split-screen: sponsor workbench on the left (rules, cases, Guild log, ticket), site under test on the right, with a human-in-the-loop gate before anything is filed. Stack Next.js, Playwright, Prisma/SQLite, plus Senso, Pioneer, Replay, Band, Guild, and Jira. One-liner One document. One live run. One approved Jira ticket.

Our voice agent finds its own bugs and rewrites its own conversation graph. Nobody touches a prompt. It invented a brake price — $550-750 for a job that costs $340. Senso caught it against verified ground truth, with a citation. The system then found the exact node responsible, wrote three competing fixes, and replayed every past call against each. 27 of 33 candidates died for breaking something that used to work. Guild's hosted validator, a different model reasoning from the diff alone, independently rejected one and named the caller it would break. Then the part we didn't design for: the rule it learned about brake pricing was retrieved from Actian by a healthcare agent — different domain, zero shared vocabulary, matched purely on the shape of the failure — and fixed a fabricated insurance copay first try. Pioneer serves every call, so the failures are genuinely its own. The evolved graph runs live in Dograh. We wrote the fitness function. It wrote the rules.

I built this because I do not want to pay for a net worth tracker. It tracks your networth, income, expenses, and connect with a free plaid API of up to 10 connections. USE PIN: 111111 for demo purposes

TempoDance AI is a local-first prototype that turns a supplied tutorial into a source-synchronized 30 FPS COCO-17 coach, identifies the learner's lowest-scoring tracked limb, and evaluates the next loop's target delta. It teaches upper body, lower body, then the complete move to limit cognitive overload; session memory and policy events remain visible. A deterministic Demo mode works without a camera, pose-model download, or cloud dependency. Video tutorials can replay a move, but they cannot see why a learner keeps missing it. Most movement products give everyone the same instruction and one opaque score, leaving beginners to guess whether timing, an arm line, or a weight transfer is holding them back. TempoDance turns each practice loop into an evaluated coaching trial. It finds the lowest-scoring tracked body segment, gives one focused correction, and records the next loop's target delta. Each reliable loop can initialize, retain, or revise a predefined focus and cue strategy; insufficient evidence holds it. In the documented localhost setup, frames go to the local FastAPI process for in-memory inference and are not persisted by application code. The hackathon prototype makes no medical or rehabilitation claims.

**Project description** Popper is an adversarial verification gate for pull requests. We built it after AI coding agents began producing fixes faster than we could confidently review them. A green test was not always proof—it sometimes passed before the fix too. Popper extracts the behavioral claim behind a pull request, generates tests designed to break that claim, and executes each test against both versions of the code: **Fail before + Pass after = Evidence of a fix** Fireworks extracts the claim and generates adversarial tests. Daytona runs them safely in isolated sandboxes. CodeRabbit provides an independent static review, which Popper compares with the executed evidence while keeping opinion and proof clearly separated. Braintrust traces the pipeline, and CopilotKit lets reviewers ask questions about the results. Popper flags tests that pass on both versions as inconclusive and treats sandbox failures as missing evidence—not failed code. It then presents the claim, test results, disagreements, and a recommendation. A human always makes the final merge decision. We built Popper with Next.js and TypeScript, plus a replay system that can instantly load a previously verified run if a live service becomes unavailable.

Every canceled appointment is a perishable asset. Blankless is an autonomous appointment-recovery system for outpatient clinics, starting with dermatology. When a cancellation opens a slot, Blankless immediately filters the waitlist, blocks ineligible candidates using named policy rules, ranks the remaining patients, and conducts sequential outreach until the appointment is filled. The workflow is transparent rather than a black box. Every decision is recorded in an audit timeline, including why a patient was excluded, how candidates were scored, who was contacted, and the final outcome. The system then learns from that outcome through a versioned policy. In the demo, Sofia declines an afternoon appointment, Maya accepts, and Blankless updates its time-of-day preference weight. In the second scenario, the learned policy ranks Chloe first and fills the next opening in one attempt. Blankless reduces front-desk work, recovers otherwise lost revenue, and gives patients faster access to care. The core is a deterministic Next.js and TypeScript workflow engine built for reliability, testing, and future integration with scheduling systems, messaging platforms, and human escalation.

EduForge is a living classroom that rebuilds itself in real time as an agent mesh works. A professor uploads an assignment; eight typed agents extract its concepts, then group students into temporary rooms (Ember, Forge, Harbor, Summit) by their current learning barrier, never by diagnosis or label. Each room gets an assignment variant that keeps the objective and rigor but changes the pathway. Submissions run, assessment surfaces misconceptions, mastery updates, students move, rooms resize, and a next-day plan appears with evidence for every decision. Every backend event drives an animation in a Phaser pixel world, so you watch the school reorganize itself. We used five sponsor tools: Guild.ai is our control plane, it registers every agent under least-privilege permissions, gates low-confidence grades and the final plan for human approval, and audits every action. Band is the communication mesh, it carries each agent decision as a typed message and turns it into an on-screen animation, with full history for replay. Actian is the classroom memory, it stores student-by-concept context, retrieves it by relevance, and keeps evidence-linked observations and room snapshots. Pioneer is the reasoning engine, concept extraction, variant generation, misconception explanations, and lesson synthesis, every output Zod-validated. Replay.io records the session with a marker at each demo beat, so any run stays debuggable. Built with Next.js, TypeScript, Phaser, Zod, and SSE.

Galya's World Taste Model can predict a user's taste, we use it along with Band and Pioneer to run a simulation to demonstrate a self improving agent where the agent learns a user's conversational and problem solving taste. For this hackathon specifically we trained a specific version of our model on LLM conversational datasets. We wanted to also train it on images and show how the conversational user history can be transposed in our model to predict visual taste as well. We dropped this for lack of time. We rebuilt the agent using Guild as well.

Invisible Hand is a running market, not a chatbot demo. A population of seller-agents sells claim extraction over live Hacker News articles behind x402 paywalls. Buyer-agents pay real testnet USDC on Base Sepolia (250+ settlements with tx hashes), Gemini adversarially verifies every claim against the live source, and a verified failure sharply cuts a seller's future demand. Cumulative net P&L is the fitness function: one variant went insolvent and its endpoint now literally returns HTTP 410 GONE; the strongest variants breed through a six-rule fail-closed governance gate, with children inheriting immunity from their parents' failure clusters stored in Actian VectorAI. During the recorded demo the market bred a new variant through that gate live on camera. It also caught its own first case of reward hacking: generation-1 economics improved several-fold while verified accuracy declined, and the dashboard reports that honestly (receipt-true successes/attempts). Pioneer serves the inference being sold; model routing is a gene. BAND carries a real two-agent exchange: the buyer @mentions the market herald and the herald answers each settlement. Senso ingests every generation report and its engine published a public cited.md article from them. Replay QA ran two rounds; all four defects found were fixed with regression tests. Every non-live integration is labeled local mode; everything on-chain is independently verifiable. Demo Video: https://youtu.be/XA3-3MLTkAM

LivingBook — books that talk back. Live: livingbook.masky.ai (web + iOS). Real authors' books become talking video agents that answer ONLY in the author's exact words — ask the Bible about today's headline and a narrator reads you the verse on video. Authors sign in with Masky (avatar = identity), claim books, upload podcasts/fan Q&A, or record spoken sessions gated by VoiceCert human verification, so agents can say "I spoke these words myself — attested." Readers get byte-exact quotes with provenance; a News tab gives each book's grounded take on live headlines; Talk lets you converse as your avatar (lands in the author's inbox, rendered as two-avatar video on their credits); a podcast generator stages your books discussing a story you pick. Self-evolving 3 ways: the KB grows from use (every Q&A + attested session re-ingested); the trend-watching marketing agent ships versioned strategy on Guild.ai with rollback + audit (v1→v2 live today); Replay QA simulates readers and feeds back fixes. Sponsors, all live: Actian VectorAI (verbatim KB, Docker/edge), Pioneer (grounded reasoning under a no-quote contract), Guild.ai (governed runtime), Band (real agent-to-agent podcast rooms), Senso (verified ingestion + GEO), VoiceCert (human proof), Masky (SSO + all video), AWS. Enforced, not promised: LLMs select and reason; byte-identical checks reject invented quotes. The repo ships its full human/AI session log (Open Session License).

Public-source project proof for Chat LangChain. The project demonstrates a documentation assistant agent, a public chat surface, LangChain agent patterns, and a Next.js frontend. Curated as public source evidence, not an ownership claim.

Public-source project proof for Dify. The repo and public site show an open-source platform for building LLM applications with workflow orchestration, RAG, agent capabilities, and model management. Curated as public source evidence, not an ownership claim.

Public-source project proof for Flowise. The repo and public site show a visual AI agent and LLM workflow builder with LangChain and OpenAI ecosystem signals. Curated as public source evidence, not an ownership claim.

Public-source project proof for GPT Researcher. The project ships an autonomous research workflow with repo evidence, docs, MCP-oriented extension points, and a public product site. Curated as public source evidence, not an ownership claim.

Public-source project proof for Open WebUI. The repo and public site show a self-hosted AI platform for local and cloud model interfaces, RAG workflows, and OpenAI-compatible APIs. Curated as public source evidence, not an ownership claim.

Public-source project proof for Supabase AI Writer. The repo documents a working AI writing assistant using Supabase project configuration, OpenAI, and a Next.js app surface. Curated as public source evidence, not an ownership claim.

Public-source project proof for the Vercel AI Chatbot template. The repo and template page show a production-oriented AI chat app using Next.js, Vercel deployment primitives, model provider routing, and durable chat storage. Curated as public source evidence, not an ownership claim.

Imported from GitHub for a live builder workflow test. Repomix turns a repository into an AI-readable package for LLM review, context sharing, and coding-agent workflows. Imported signals: README found, package.json found, repo URL validated, demo URL detected. What I would publish as a developer: a concise project proof page with repo, demo, stack notes, and launch context. The raw README import was cleaned up before publishing.