Developer Projects

Robot Dojo pits two simulated Unitree G1 humanoids, karate-inspired vs taekwondo-inspired, in live MuJoCo physics on Unitree's pretrained balance policy, shown in a Three.js arena with each robot's own eye camera. Long-horizon angle: a research agent evolved each style's movement programs over dozens of physics trials, keeping compact versioned state (hypotheses, candidate lineage, held-out comparisons) instead of a growing transcript. Karate hand reach rose from 0.119 to 0.203 m on held-out seeds with zero falls; failed trials stay on record. Liquid AI: each fighter runs its own local LFM2.5-VL-450M (llama.cpp in Docker) that sees only its robot's head-camera frame and returns a schema-validated tactical intent. In a recorded bout, three accepted "approach" decisions closed the gap from 1.70 m to 0.73 m. Next: Liquid picks combos using compact opponent memory, moving to MLX on Apple Metal (0.13-0.24 s per call vs 8-16 s on CPU) and LEAP LoRA tuning on robot-eye decisions. Demo video: choreographed combos, but hits are scored from real physics contacts and a robot staggers only when a strike actually lands. Limits: the exchange sequence is scripted and the kick is not yet balance-validated. FLUX video renditions were planned but not built.

We used Nimble, LiquidAI, and RawTree to build a **web app** that **recommends recipes** to users and let them select from 3 different options and then get a **video tutorial of the recipe from the web**.

What it does: Actintro already ranks everyone at your Luma event against your goal. This agent picks up the top leads you never got to talk to, searches the web for each company's careers pages and open roles, and writes one follow-up per person. You swipe: Keep sends it to your drafts, Fix sends it back. One tap ("Shorter", "Warmer") or a typed note turns your fix into a rule on a small style card, and the rejected drafts are rewritten with it at the same time. The long-horizon part: the agent never reads its own history. Each draft reads only three small cards (event, lead, style), so what it reads per draft stays flat while the log grows. The page charts both lines live. Code checks only exact things (no em dash, no link, your exact closing line, the word limit); anything that needs judgement is a model call. Tools: Tinybird (Rawtree) stores the append-only log of every search, draft, swipe and rule, and feeds the live feed and chart; no model reads it back. Nimble does the live web search behind each card's sourced facts. Black Forest Labs FLUX generates the faces of the made-up people in the public sample room (real companies, invented names). We also measured Liquid AI's LFM2.5-1.2B locally as a filter; it was fast but not accurate enough (47/100), so it is out. AWS Bedrock writes the drafts. Repo: github.com/vidiyala99/actintro-followups

Long-horizon agents drown in their own history: every observation gets appended, every call gets slower and costlier, and stale context corrupts decisions. Lethe fixes this with three rules. (1) Explicit mutable state: a one-page Mission Ledger the agent rewrites every cycle instead of a transcript, with a hard 6k-token cap per LLM call. (2) The agent edits its own context through tools: update_plan, record_decision, add_lesson, set_recommendation, mark_stale. (3) A clear split between persist and discard: raw pages die with the worker that read them, extracted facts carry a TTL, facts confirmed by two sources persist, and a sold listing wipes everything about it. The demo mission prices a dealership's used RVs against the live web. Scouts use Nimble to search and read listings and return a card under 200 tokens. A Liquid LFM2.5 model running locally on a laptop assigns every fact its TTL and confidence. An Auditor checks comparability and, when a strategy fails, writes a lesson and the agent switches strategy on its own. OpenAI's gpt-oss models plan and decide. All state and every event, including token counts per call, live in a RawTree database, so kill -9 followed by restart resumes in under a second with no replay. Results: max context 2,876 tokens over hours of live runs. The naive baseline (same tools, append-everything) hits the provider's wall by step 6. The dashboard shows both lines, the board, the facts being expired and contradicted, and the self-corrections.

We built a long running agent that accompanies a patient throughout their medical journey. It allows the patient or the medical provider to generate visualizations to their patients conditions. It works on device to preserve privacy for the patients and it can remember the patients questions and preferences. It also allows for editing and modifying the visualizations so that the explanation is truly accurate for the patient.

AgentFire is a reliability and endurance-testing platform for autonomous agents — essentially chaos engineering for AI agents. It compresses a simulated 24-hour production shift into minutes and tests whether an agent remains reliable as history and memory accumulate. In the first incident, the agent diagnoses an expired authentication credential, remediates it, and verifies recovery. RawTree stores the full flight recorder of observations, tool calls, actions, and evaluations. Liquid AI then compiles that long history into compact durable experience, reducing roughly 13,000 tokens to about 378 tokens while preserving the full audit trail. Later, a similar-looking incident occurs, but the real cause is database connection exhaustion. The agent retrieves the old authentication memory and incorrectly repeats the prior remediation, so AgentFire fails the run despite eventual recovery. After applying a general memory-safety rule — memory is evidence, not current truth — the same fire drill is rerun. The agent rejects the stale remediation, fixes the database issue, verifies recovery, and passes with zero unnecessary or unsafe actions. Nimble provides real-world incident intelligence, OpenAI powers the agent under test, RawTree provides telemetry and replay, and Liquid AI compiles durable experience.

HorizonCraft is a personal world builder: you chat about your life and an agent turns it into a living 3D world. Mention Tahoe and a ski chalet appears by the lake; mention Rome and a Colosseum rises under a starry sky, because it's night there. Attach a selfie and you're in the world too. Underneath is a memory layer for long-horizon agents. The agent never sees a transcript. Every prompt is rendered from a bounded typed state: placed things with coordinates, landmarks, live conditions, and facts about you. Every build stage checkpoints atomically, so killing the agent mid-generation and restarting resumes at the exact stage. Memory changes behavior: rejected things go into a failures ledger and get regenerated differently; earlier builds become landmarks later requests can reference. Sponsors: OpenAI gpt-5-mini interprets conversation into structured actions from state, not history, so prompts stay ~800 tokens at turn 100. Liquid LFM2 (1.2B, local via Ollama) handles fast decisions: naming, sizing, keep/drop, half a second each. Nimble fetches real weather, temperature and local time for any place you mention, driving sky and day/night. Black Forest Labs FLUX draws every object, and FLUX Kontext turns selfies into characters. fal.ai hosts Hunyuan3D for image-to-mesh. Rawtree records every decision and token count, feeding a memory panel that proves the context never grows.

LongHorizonAgent is an AI agent architecture designed to work reliably across hundreds or thousands of steps without continuously growing its context. Instead of replaying the full conversation history, it maintains a small, structured working state containing what is true now, archives outdated or evicted information, and recalls it only when needed. The project demonstrates this approach through DesignDesk, an AI mechanical-engineering environment where natural-language design intent is converted into structured state, updated through engineering changes, and used to generate and validate real CAD geometry with build123d and OpenCascade. A Memory State Inspector makes state changes, archived facts, recalls, provenance, and context savings visible, while AWS Bedrock provides the main reasoning model, Nimble provides web tools, and Tinybird provides telemetry and analytics. The core idea is simple: **History grows. State doesn’t have to.**

Banks quietly reserve their best rates for new money. Stay loyal and you get the worst of it. AutoSvr is an agent that checks the market every day and keeps your deposit at whichever FDIC-insured partner bank is paying the most. How it works. Nimble runs a headless crawl of three rate sources (depositaccounts.com, bankrate.com, nerdwallet.com), waiting for each rate table to actually render before capturing the HTML. A Liquid AI LFM, called through OpenRouter, reads that markup and returns structured rate rows — so there are no brittle per-site scrapers to maintain. The sweep engine then applies four rules: the bank must carry FDIC or NCUA insurance, a new rate must beat the current one by at least 25 basis points, transfers initiate only on banking days, and interest books exactly once per calendar day. Everything lands in RawTree/ClickHouse as rate_observations, sweep_events and daily_accruals, and a SQL read layer compounds a blended APY at one row per day. Why 25 basis points. A transfer costs one to three days of interest in settlement, so chasing every basis point loses money. When AutoSvr holds, it says why: the demo account sits at 4.44% with 4.62% available — an 18bp gap that does not clear the threshold. What you see. A live balance, every bank that has held your deposit with its FDIC certificate number and the rate it paid each day, statements, and withdrawal with no lockup and no fee.

**A self-healing information pipeline for tracking natural disasters and accidents in real time — wildfires, floods, earthquakes, and similar events.**

Engram or talking avatars is a person you can upload and talk to. The goal of this to create digital replicas of anyone to the highest fidelity as possible. This digital replica of a person has high realism instill emotions and expressions in the avatars. We are future able to correct and finetune the voice of the person given prior audio recordings, or with a live transcription to finetuning tool. The "engrams" posses a memory bank, so that they can smoothly converse with people.

Baby monitors show what is happening now. NuserAI keeps track of what happens over time. It knows who is responsible, what the family prefers, what already happened, and what still needs attention. Liquid AI runs locally and turns live camera frames into structured observations while keeping footage on the device. When NuserAI does not know how to handle a non urgent situation, Nimble searches the live web. It can look through parent communities, product documentation, and other useful sources and bring the information back with the original source. RawTree keeps the long term state. It stores caregiver changes, preferences, previous actions, corrections, and unresolved tasks. If Mom was responsible and an action was allowed, but Dad later takes over or the family changes that permission, NuserAI checks the latest state before doing anything. It can notify caregivers, play approved audio, prepare a diaper reorder, or request configured home actions. If it cannot act safely or does not have permission, it asks the caregiver. NuserAI helps families keep track of what still needs to happen.

We made a platform for generating hyper-personalized, topical local ads It is aimed at helping local businesses create advertisements that tie their products to recent local events and topics. Local small businesses tell us their city and what they want to promote. Our platform uses Nimble to find recent news stories in the area, then leverages Black Forest Labs FLUX video models to create a set of 10-second campaign creatives. Each ad references a different local news story, allowing us to identify which topics resonate best with each audience. We leverage Tinybird to log all inputs (instructions from advertisers), intermediate outputs (news stories and Black Forest prompts), and final outputs (the generated videos), as well as internal logs for generation failures. Our code then screens for bugs and failures and suggests fixes before executing any new calls, so compute and tokens are not wasted before issues are resolved. These logs will also allow us to identify the ad characteristics that perform best, so future ad generation can learn from previous campaign performance.

DevTrace: know what breaks before it breaks. The problem Libraries like Next.js, React and Stripe release new versions constantly, with renames, removals and breaking changes. The one change that affects your code is usually buried in long release notes that nobody has time to read, so teams find out only when something breaks in production. What DevTrace does You give DevTrace a library and your GitHub repo. It then works on its own, round after round: 1. Decides the most useful question to investigate next. 2. Searches the live web for release notes, docs and migration guides. 3. Remembers every page it reads, permanently. 4. Updates a short, up-to-date list of what changed, what could break, its key facts, and what it still needs to find out. It corrects beliefs that newer evidence proves wrong. 5. Checks your code and lists the files and exact lines that use the changed APIs. 6. Repeats, moving on to a new open question.

ClearLine is a privacy-first family check-in app for Android. It runs short, consented voice check-ins on-device with Whisper transcription and a local Liquid agent that compares history, asks for missing information, and resumes unfinished follow-ups after interruptions—so a daily “are you okay?” still happens when you’re far away. Optional Nimble search finds public caregiver resources only after exact query approval; optional RawTree stores only consented exports. It does not diagnose or score clinical risk.

Déjà vu is an always-on incident agent that decides who owns a production failure before it acts. When an alert fires, a runner wakes the agent with the current time. It investigates through typed tools (logs, metrics, deploys, config changes, similar past incidents, vendor updates) instead of loading history into its prompt. If we own the fault, it retrieves matching past incidents and runbooks, rejects decoys like an unrelated deploy, proposes or runs the fix, and refuses to close until recovery metrics hold for a full success window. It then saves a short, evidence-backed lesson, so when the same failure returns weeks later it diagnoses it in two checks without rereading old conversations. Tinybird is the timeline and memory: alerts, logs, metrics, deploys, config changes, vendor snapshots, and the agent's own actions and lessons. Every query is limited to what was visible at that moment. Nimble reads third party vendor status pages and changelogs, and Tinybird stores and diffs each snapshot. Liquid handles fast triage and escalates to Claude for hard diagnoses.

What it does: Livik profiles an LLM running on an Android phone, finds the slowest GPU kernels, and rewrites them one attempt at a time. Every attempt runs the full model on the device and must produce exactly the same tokens; only faster kernels are kept. On a 2020 Motorola Razr, Liquid AI's LFM2.5-230M went from 14.2 to 20.0 tok/s (+41%), 68% of the device's measured memory-bandwidth ceiling, beating the stock int8 engine at full fp16 precision. Long horizon without drowning in history: each cycle is stateless. The prompt is rebuilt from memory at a fixed ~6k tokens after 90+ cycles, while a full-history agent hit 64k tokens in 15. Kill it anytime; it resumes where it left off. RawTree (Tinybird): every worker call, device run, idea, kernel diff, research fact and benchmark is an event in RawTree. The agent reads its tried ideas, facts and best kernels back with SQL each cycle, which powers resume and warm start: LFM2.5-350M, never optimized before, jumped from 12.4 to 15.6 tok/s in under 2 minutes with zero LLM calls by reusing 230M's winners. Nimble: when the device's compiler rejects a kernel, the agent searches the web on its own (model paper, Qualcomm Adreno docs, the exact error) and stores distilled facts with sources. Liquid AI: LFM2.5-230M, 350M and VL-450M are the models. Claude Opus 5.5 on Vertex AI writes the kernels. The Lab web app runs, benchmarks and streams device logs.

Vendors pass your data to their own sub-processors, and the only notice is often an edited web page. Night's Watch reads each vendor's sub-processor list and DPA and flags changes that break your policy. Each vendor has a small state card the agent rewrites instead of appending history. Over a simulated year, memory stayed under 1,900 tokens while full history hit 429k. Nimble fetches pages, Liquid LFM2.5 judges each new sentence, RawTree (Tinybird) stores history, GPT-5.6 Sol double-checks.

Aegis is an AI-powered SRE platform for managing incidents in distributed systems. It collects alerts, logs, metrics, traces, topology data, and recent code changes to identify the likely cause of failures. It recommends repairs, checks them against strict safety and permission rules, executes approved actions, verifies recovery, and rolls back unsafe changes. Every investigation and decision is recorded for auditing.

Long-running agents either keep every old note in context (slow, costly, noisy) or delete it and lose the reasoning. Memory on Alarm, built on our SPORE engine, adds a third option: "forget until." How it works: from one goal, the agent plans its research, classifies each observation as ACTIVE, DURABLE, SPORE or DISCARD, and turns temporarily blocked findings into a SPORE. The full evidence goes to a SHA-256-checked archive and leaves working memory. Only a small reminder remains: the exact wake condition, a search query and a schedule. A watcher starts itself (no wake button), checks the live web, and when the condition becomes true it wakes the memory once, restores the original reasoning, combines it with fresh evidence, re-decides, and updates the shortlist. **Tools:** • Liquid AI (LFM2.5-8B, local via Ollama): plans the research, judges live evidence with cited sources, makes the post-wake decision. Every output is schema-validated, and a deterministic guard blocks disagreement. • Nimble: live web searches for the watcher, with inspectable source URLs. • RawTree / Tinybird: external audit log; all 11 lifecycle events are written and read back to prove they were stored. Verified run: **5,720 working-context tokens** released, **9 live** sources, memory woken automatically, candidate shortlisted, 11/11 events verified. 52 automated tests.

LevelForge is an environment that allows  AI agents to handle better memory over long tasks. An LLM repairs a 2D platformer level action-by-action while a deterministic validator, not the model, judges whether it actually works. We compared four memory strategies live against a self-hosted 24B model.

**What we built.** A long-horizon agent that follows one fruit photo by photo and decides, every day, how hard to look. Every frame gets a cheap local look; the expensive model runs only when the agent's memory of that fruit says a change is worth it. A low-cost day is not a "healthy" verdict: the open question stays in memory until it is answered. ** ** **How it works.** Each day (1) **Liquid LFM2.5-VL-1.6B** runs locally on the photo and returns visible features, anomaly candidates and uncertainty, about 2 s per frame at zero API cost. (2) The controller restores the fruit's record from **Tinybird RawTree MCP** and applies explicit rules: new anomaly, change that persists or grows, open question due, too long since a precise look. (3) It either stops there or calls **GPT-5** with the original photo plus the past frames the memory points to. (4) Result, reason, open question and next check condition are written back to RawTree, so the agent survives restarts. **Nimble** found, verified and fetched the data: 7,516 apple photos (Manalagi, CC BY 4.0, task-id per file) and a Zenodo record of the same tomato photographed on 18 consecutive days (CC BY 4.0, MD5-checked). **Results.** On the same 18-frame sequence, baseline calls GPT-5 every frame; **our agent calls it 5 times**. Apple: 18 to 5 calls, $0.0321 to $0.0125 (61% lower). Tomato: 18 to 5 calls, $0.0227 to $0.0081 (64% lower). No disease labels, so we report calls and cost, not detection accuracy.

AI coding assistants forget everything between sessions, and the instruction files teams write for them (AGENTS.md, CLAUDE.md) go stale the moment a library changes. On long jobs like a major-version upgrade, they also drown in their own history and start repeating themselves. Evergreen is a long-running agent that does the upgrade and learns as it goes. It fixes one file at a time: known errors are fixed instantly by a saved rule; new ones get live official docs from Nimble, and Liquid's LFM2.5-8B-A1B model writes the patch entirely on the laptop, with no cloud AI. A fix is kept only if it passes safety guards and no previously passing test breaks; otherwise it's rolled back and retried, so progress never goes backwards. Every kept fix becomes a lesson with a confidence score, a source link and the library version it was proven on, and is written into the project's AGENTS.md so the next session with any assistant starts out knowing it. All history (attempts, patches, test results, lookups) lives in a Tinybird RawTree database instead of the prompt, so the prompt stays the same size from the first file to the last. In our run, it took a pandas 1.5 to 2.2 upgrade to all 21 tests passing. A live Next.js dashboard on Vercel reads RawTree and shows each run as it happens: tests passing over time, every patch and its diff, the rulebook, Nimble lookups, rollbacks, and zero human interventions. Built with Liquid, Nimble, Tinybird/RawTree, Python and Vercel.