Developer Projects

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.