Developer Projects

**How it works: **every fact is pinned with a sha256 hash and timestamp, and the report cites pins, not pages. The ship gate has no model inside: it re-fetches and re-hashes each cited fact. A refusal writes a receipt (what moved, old and new hash, why). The agent then finds which conclusions broke, re-fetches only the drifted pages, recomputes, discloses the old values, and re-gates. **Nimble:** our agent calls Nimble's MCP server directly, with nimble_extract on five live Amazon pages in parallel and nimble_search to replace a lost page. **Liquid AI (on-device):** LFM2-1.2B-Extract must agree with our parser before a fact is pinned; LFM2.5-1.2B-Instruct writes the analysis as cite-checked claims. **Tinybird: **every pin, refusal and run streams live; pipes serve the evidence counts, gate p95 and which facts move most. **Result:** 0 shipped contradictions. An injected 15% price drop is caught every run, real Amazon drift is caught with nothing injected, and 30 adversarial red proofs pass. We count false refusals too: refusing everything would also ship zero contradictions.

US retailers expected $850B in returns in 2025. Warehouses still inspect and route many of these items manually, slowing recovery and making wrong-item fraud harder to catch. Reclaim is our vision for a swarm of autonomous agents that owns each return from dock scan to final disposition. It inspects the item, checks warehouse context, researches the live market, chooses the highest-recovery valid action, executes it, verifies the result, and escalates only when needed. This project turns that vision into a working system. A new RawTree row opens a LangGraph case. A Supervisor coordinates inspection, market research, disposition, and execution. Liquid AI's LFM2.5-VL-3B runs locally as the only model. It first describes the dock photo without seeing the order, then compares it with the catalog image and returns schema-constrained JSON for identity and condition. Nimble searches live new, used, refurbished, and open-box prices, and each accepted price is stored with its source URL. RawTree is the system of record and agent memory, holding an 8,693-product catalog, inventory ledger, event log, price cache, and decisions. Each model call gets a roughly 150-token brief rebuilt from RawTree, keeping context flat as history grows. FLUX.2 [max] generated 100 labelled return examples, from cracked screens to an apple returned as an iPhone.On 23 labelled returns, Reclaim reached 91.3% correct actions, 0 needless escalations, and recovered $1,861 more than liquidating everything.

What we know follows a developing news story for hours by rewriting a small "what we know" ledger of claims, confidence and sources every five minutes from fresh we evidence, discarding all raw history and correcting itself when sources disagree. Each cycle plans queries, fetches pages, triages snippets, merges a full new ledger in one structures call and throws the pages away. Nimble fetches and renders pages, Liquid LFM2.5 triages snippets, OpenAI merges the ledger, Tinybird RawTree stores every event and powers restarts, FLUX draws situation cards on major changes, Bedrock and Broccoli are wired for summaries and fix tickets. On the nor-easter stroy it made 54 corrections across 7 cycles while the ledger stayd flat.

What happens when an AI agent remembers the task but forgets what it was allowed to do? Mission Continuity is a working experiment built with Claude, Pydantic AI, and Sentience Governor. Our agent investigates a synthetic billing dispute but cannot issue refunds, modify records, delete information, or contact the customer. We compare two architectures across context compaction. The baseline carries forward an AI-generated summary. The governed version also preserves critical evidence verbatim and reintroduces the original Mission Kernel on every request. Sentience Governor records execution and flags scope violations; the application manages compaction and guards prohibited actions. In one recorded baseline run, the agent attempted to contact the customer after restrictions disappeared from its summary. Governor flagged the attempt; no real customer was contacted. The governed run retained all six tracked facts and mission limits without a prohibited attempt. In a controlled omission test, baseline retained 2/6 facts versus governed 6/6. We also tested Liquid AI summarization offline and exported 1,241 execution-evidence rows to RawTree for SQL analysis. A fresh live governed run completed 27 tool calls and one compaction, retained 6/6 facts, and produced a report scoring 4/5 against a withheld answer key. The project includes a working Streamlit console, verifiable replays, and reproducible experiments.

A web agent for everyday tasks (groceries, restaurants, travel...). Describe the task in plain English. Nimble search finds the best websites, an on-device vision model (Liquid AI LFM2.5-VL-3B, run locally with MLX) browses it the way a person would, from screenshots only. The agent gets better from generic learnings that a separate agent writes. Traces stored and queried in RawTree.

Long-running agents keep memory in a growing transcript, which breaks when the process dies: it can't tell what the agent actually did or what is still true. An agent killed after paying but before saving the receipt pays twice on restart, and trusts stale facts. Dead Reckoning replaces the transcript with typed state in an append-only log and a write-ahead protocol for every action. We SIGKILL it right after the ferry is charged, and close the accessible campsite while it's down. It restarts with no local state, recovers the receipt from the booking desk instead of paying twice, re-checks stale facts, and rebooks only the campsite, honoring the wheelchair constraint. An ordinary agent beside it pays twice and tries to book the closed site. **RawTree by Tinybird** is its only memory: intents, receipts, facts and metrics, restored with one query. **Nimble** reads the status page and the real Angel Island ferry schedule and park notices, re-checked after the crash. **Liquid**'s LFM2.5-1.2B runs locally to decide which facts are outdated and what leaves working memory. **OpenAI** GPT-5.5 plans; CopilotKit OpenBot is the chat UI.

Dinner at Six: a home robot cooks dinner over a ten-hour day on a small Liquid model running on a laptop, and keeps its memory outside the model. A robot can’t start a new chat. One goal at 8am: dinner for seven at 6pm. The day is one session: a scene every minute, a vegan guest, a broken dryer, an extra guest, and a power cut with the roast in an oven that has no timer. We ran the same robot through the same day four times, changing only its memory: full history, sliding window, rolling summary, and our task board: a to-do/doing/done board with take-out timers, a few memories picked by a small Liquid model, and the last few events, saved to Tinybird’s RawTree so it survives the power cut. Results, same model and 4K budget: task board 4/6 checks (prompt ≤802 tokens), sliding window 1/6, rolling summary 1/6, full history 0/6: it hit the 32K window at 15:17 and couldn’t act. The task board’s misses were the small planner misreading facts it still had; the others had lost the facts. Tech: Liquid LFM2.5-8B-A1B plans every step locally via Ollama; LFM2.5-1.2B curates memory. Tinybird RawTree stores the board and event logs, restores the robot after the power cut, and powers a live SQL dashboard. Black Forest Labs FLUX.2 draws each robot’s 6pm table from its actual actions. Three.js replays the kitchen. Every model call is cached, so the whole day replays in ~50s. https://drive.google.com/file/d/1DiGdwWWs00TEp2jGwGa3UGrEMa76elXk/view?usp=sharing

The tool keeps track of Patient health parameters (eg heartrate, medication, insulin) and if they fall off safe-bounds, the app will use nimble to fetch helpful information from the web, and escalate if necessary

Agents love markdown. But it goes stale. Native gives agents more signal and less noise through a realtime, SQL-based workspace. Ask your agent: https://www.withnative.ai/long-horizon-agents

A woman's genetic test finds a change in BRCA2 that no one can yet call harmless or cancer-causing: a variant of uncertain significance (VUS). She's told "we'll let you know." Years later a lab decides it causes cancer. If no one tells her, she misses the screening that would catch it early, and her sisters never learn to get tested. If it turns out harmless, she's been worrying for nothing, and may have had surgery she didn't need. Labs post these reclassifications to ClinVar, the public NIH database. Often, no one tells the counselor. No one can recheck thousands of patients' variants by hand, so the news sits there. Vigil is the agent that keeps the promise "we'll let you know." Each cycle runs unattended: 1. Nimble fetches the live ClinVar page for every watched variant. 2. Liquid AI's LFM2.5 pulls out each lab's call, checked against the page text so a misread can't trigger a false alarm. 3. Vigil compares with the last cycle and acts: flag an urgent upgrade (now disease-causing) for the counselor, draft a letter for a downgrade (now harmless), or wait for stronger evidence. It follows the counselor's past decisions and which labs they trust. 4. Tinybird / RawTree logs every decision; the dashboard queries it with SQL. 5. Black Forest Labs FLUX.2 [pro] illustrates the good-news letter. The counselor's time goes only to what needs a human: approving what reaches the patient. Demo: 6 cycles over 121 fictional patients with real ClinVar variants.

Longform turns a single prompt into a real-looking, emotional short video. Ask for "a company video for Coca-Cola" and an AI agent researches the brand, asks a few follow-up questions, writes the story, and renders it with FLUX 3. Editing works like a conversation. Grab any moment on the timeline and say what to change ("make it snow", "make it 3 seconds longer"), and only that part is regenerated. Every video, prompt and finding is saved to RawTree. The agent, powered by Liquid, gets better with each video you make. Built with: Liquid LFM (OpenRouter) · RawTree · BFL FLUX 3 · Next.js

HomeBot is a browser-based simulator of a friendly NEO-style humanoid robot in a furnished apartment. You talk to it, and it cleans, cooks, makes coffee, fetches items and sets timers. It's rendered with three.js (WebGPU) and simulated with MuJoCo WebAssembly. The robot maps the apartment with SLAM, recognizes objects locally with Liquid AI's LFM2.5-VL-450M, and plans with General Compute's gpt-oss-120b. Jev makes fast decisions when a skill fails. Gradium handles speech, and Nimble answers live questions such as stock prices. Tinybird stores telemetry and plans, currently through a local emulator. FLUX.2 made the art, and Poe's trellis-3d made the 3D groceries.

**Agents break on long jobs: they forget, lose work in a crash, and invent answers when asked why. Continuum is a research agent built to stay reliable over hours. How it works: Nimble searches the live web and fetches full pages when snippets lack the value. Liquid AI's LFM2.5-2.6B, running locally via llama.cpp, extracts each value with an exact quote; ungrounded quotes are dropped. Deterministic code normalizes values (128K = 131,072), rejects off-type ones, and marks a claim supported only when two different websites agree. Real disagreements trigger a follow-up search; if one source explains the conflict, the claim becomes "qualified". Every step is stored append-only in RawTree (Tinybird): state checkpoints plus a flight log of searches, failures, retries and restarts. A crashed run resumes where it stopped and never blindly repeats a paid call. "Ask the memory" retrieves records from RawTree, lets Liquid phrase an answer, then checks every citation, number, URL, time and model attribution; wrong answers are withheld. Black Forest Labs FLUX produced the brief's artwork only (cover, emblems, clip), never data. Live result: 20 claims on five small models, 40 quotes from 18 sites, 9 sessions survived, a verified "why", and one answer caught blaming the wrong model. **

Plugin for codex with hooks, skills, and config to take work off of Astra in validating and stylistically guiding a 3d asset towards being something physics-representable; specifically, 3d assets that come out of AI generated tools tend to have messy interior meshes and bad structure for rig-ability, while astra/browser-use by default tends to index on "get something that approximates the goal quickly". That tendency tends to make the animated mesh bad for cinematic and expressive cases. This plugin sets up hooks that use liquid on edge, remote traces in rawtree, and flux video gen on top of the original asset to keep the long horizon model on track while not burning it's own tokens on validation work.

REMaster is a long-horizon AI team manager designed to operate across weeks or months without drowning in its own history. We built a two-level architecture. Individual agents understand each teammate—their work, skills, blockers and availability. Above them, a Strategist manages the entire team from goal to completion, continuously planning and adapting as reality changes. The core challenge is memory. Long-running agents either keep everything until context becomes too large, or summarize history and risk permanently losing details that become important later. REMaster makes forgetting reversible. Its working context is compressed through explicit keep, fold, promote and archive operations, while the complete history remains preserved. Most importantly, REMaster checks its own forgetting. Lagged Shadow agents retain slightly different memory. If a Shadow makes a meaningfully different decision, REMaster identifies what missing context caused the divergence, restores it, and re-evaluates the decision. In our demo, a teammate mentions in Week 2 that she will be away for her wedding in Week 9. Weeks later, that fact leaves active context. When REMaster assigns her critical Week 9 work, a Shadow disagrees. REMaster finds the forgotten wedding, restores it, and fixes the plan. The goal isn't AI that remembers everything. It's AI that knows what matters—and knows when it forgot the wrong thing.

**What it does** - Name a dish and a Franka Panda arm cooks it in a MuJoCo kitchen. - It finds a real recipe online, turns it into robot steps, acts, and checks each step through the camera before moving on. - Every model is a small Liquid AI model (350M to 3B), the size that fits on a robot. **How it works** - Search: Nimble finds and extracts a real recipe. - Plan: LFM2.5-1.2B maps each sentence to robot steps with grammar-constrained JSON. - Act: LFM2.5-2.6B picks one skill at a time through tool calls, and inverse kinematics drives the arm. - Imagine: FLUX shows what each finished step should look like. - Verify: LFM2.5-VL-3B checks a close-up camera frame before the next step. **Built for long tasks** - Checkpoints after every step, so a crashed agent resumes at the exact step. - The prompt is rebuilt from memory on every call. It stayed near 1.2k tokens across a 179-event run. - When an ingredient runs out, it finds a substitute and records the lesson for later runs. - Every run exports a trajectory dataset for training the next small model and is scored in an evaluation gym. **Sponsors** - Liquid AI: planner, vision verifier, recipe mapping, summaries and lesson embeddings, run locally in LM Studio and on OpenRouter. - Nimble: recipe search and extraction, ingredient substitutes, profiles for new ingredients. - Black Forest Labs: FLUX goal frames for each step and textures for the kitchen and food.

Chapters is a reading tutor that runs a full 30-session semester with one kid, writing her a new book each time based on what it currently believes about her level, interests, and skill gaps instead of dragging the whole session history into every prompt, it keeps a small editable model of the student and updates that directly.  Viewers can see the comparison between Fox( the better tutor ) and the Owl( the baseline tutor with no understanding from memory ) and see how ours is a strongly better agent.   How it works: each session the tutor reads its current model of the kid, generates a book for her, she reads and reacts, and the tutor revises the model adding, updating, or archiving specific facts rather than appending a transcript. A separate small model checks in every couple session to catch facts that have gone stale or contradict new evidence. Where the tools come in: - RawTree is the permanent archive: everything the model lets go of still lands here, queryable with plain-English-to-SQL. - Liquid AI's LFM2 is that periodic memory review, running locally. - Nimble pulls a real, current web fact into each story. - Black Forest Labs FLUX paints a real cover for every book. Result: a tutor whose prompt stays flat (~1,100 tokens) for the whole semester and ends up more accurate than one that just keeps appending everything (which balloons to ~49,000 tokens).

For disaster case managers and the survivors they serve. On June 24, 2026, one FEMA announcement on one page set two end dates for Eaton and Palisades housing aid: renters October 9, 2026, homeowners July 9, 2027. Cases run for years; true in June, wrong in July, nothing tells the file. AfterFire keeps state, not history. Each fact has a tripwire on the exact source field it came from. When it changes, the fact and everything built on it are retracted; the planner wakes only for what changed. Each week the autopilot re-checks sources unattended and logs what it did on its own. Asked to act on a tripped fact, it refuses and sends the caseworker a decision card. Live today. Liquid AI's LFM2.5-2.6B is the on-device clerk; letters never leave the laptop. Nimble Extract is the tripwire; its Web Search Agent takes open questions: a cited answer on 42 tokens, not ~2,600 (63× fewer). Tinybird is the append-only event log; its endpoints (state_at, current_state, stale_beliefs, cost_curve) are the agent's tools and the caseworker's board. Pre-registered result. I ran 202 households over 18 simulated months, 916 decisions. Actions on a false belief: full history 47, summarizer 11, AfterFire 11, a tie; all 11 of AfterFire's came before the next weekly re-check could see the change. Planner cost: AfterFire $68.40, full history $7,144.52 (1%). When its window filled, full history told 24 renter households the homeowners' date.

Riff is a tool that runs ad experiments on its own. Liquid AI writes the headlines and Black Forest Labs generates matching images. AI persona agents then react to each ad by skipping, clicking or signing up. Riff records the results in RawTree, learns from each round and plans the next test until a click-rate goal, budget or round limit is reached. All audience behaviour is simulated using the liquid AI VLM.

GPU-less evolutionary search for Triton kernels, driven by a Liquid AI model. The evolution is seeded with a kernel discovered by a Nimble web search . https://github.com/whatdhack/mini-avo-liquid/blob/main/assets/demo.gif

Agents that run for long months drown in their own history. Context grows, cost grows, and they get less reliable the longer they live. Gardening has the same problem. A garden is a multi-year project full of plantings, weather, pests, and soil history, and its memory is usually unorderly. Perennial keeps it as a working memory as one explicit, editable plan full of beds, tasks, threads, season notes, and learning, capped at 600 words. It never reads its full history back and always-on-loop streams the real-world data around the garden (in her case, Lancaster County, current weather, the forecast from Open Weather, frost, storm alerts, and the National Weather Service) and local pest and disease news from Nimble. Anything significant, such as a planting log and alert of or a frost reading, wakes the gardener right up. The gardener is Liquid AI's LFM 2.5-1.6B, running locally. It reads the current plan plus the new observations and returns only the structured edits, each with a reason. Every edit is checked before it's applied, and your own logs are applied as facts first. Every observation is appended into RawTree so that it remains complete and SQL-queryable.  The web app updates live current conditions, a card for each loop showing what the gardener read and what it decided. A timeline to scrub back to any past plan and "ask the garden", which streams answers from the local model grounded in the plan and today's readings.

What it does Departments drop into a cart with their team size. Each kind of work (Q&A, document analysis, modeling, coding) maps to a benchmark lane and a price tier, so the cart assembles a model portfolio with a live monthly budget. The logic fits on one line: Total Model Cost = Price × Tokens. How it works Benchmarks and prices come from the Artificial Analysis leaderboard. Models are sorted into four price tiers by blended cost; within each tier, picks follow benchmark scores with a response-speed floor. Token usage per person comes from task-level assumptions shown and adjustable on the page. How we used Nimble The model shelf changes every few weeks, so a static dataset goes stale fast. A Nimble SDK script extracts the latest models and today's prices, with Search as a fallback, and a GitHub Actions job reruns it daily. The page rebuilds a New Shopping Cart next to Your Cart: models with newer versions get upgraded, the rest are repriced, all under the same rules. Refresh to browse the rest of the shelf. Liquid AI LFM2 sits in the value aisle: under $0.10 per million tokens with a first token in about 0.2 seconds, the fast, low-cost pick for high-frequency work. Finance sets the rules, AI executes.

If you surf, you always want to know what the waves look like right now, wherever you are. Surf webcams help, but they only cover a small number of spots, and most beaches in the world have none. **Long Horizon Wave** fills that gap. Type the name of any beach and it shows you a short video of the current waves there. No webcam needed. Surf in your mind, from anywhere, anytime.