Nxt

Inspiration

Most Toyota owners with a loan or lease don't know where they stand. Is my car worth more than I owe? Should I buy out my lease or return it? I missed a payment, so what happens now? The answers are buried in contracts and dealer jargon, so people decide too late, under pressure, or not at all. Customers leave money on the table, TFS loses customers it could have kept, and payment stress shows up only once it has turned into a problem.

At HackTX, Toyota Financial Services asked one question: "Given my situation today, what's the smartest next move for me and my Toyota?" We didn't want to build another chatbot that waits to be asked. We wanted a co-pilot that watches your situation, reaches out at the right moment, shows your real options with exact numbers in plain language, and points you to one clear next step.

Building on Toyota's track

We designed NextMove directly around the four pillars of the challenge:

• Personalize: a synthetic profile for each customer covering contract, vehicle, mileage, payment history and life events. 1,200 simulated customers drive every insight.
• Simplify: every eligible option sits next to a "do nothing" baseline, with monthly payment, total cost and trade-offs. Options a customer can't take are explained ("Buyout opens 180 days before your lease ends").
• Guide: one recommended move with a single action button. Start a buyout, book a follow-up, send a deal packet to a dealer, or talk to a human.
• Value: an employee console ranks every customer by expected dollar value and retention odds, so TFS knows who to reach and what to offer.

And the "Innovate Responsibly with AI" piece is built into the architecture, not added afterwards.

Building on the "Platform Behind the Agent" track

Building NextMove's six agents showed us that every agent needs the same plumbing: tools, models, instructions, guardrails and monitoring. So we built that plumbing once and made it reusable.

• One tool registry, any model: 12 tools defined once, each with an input schema generated automatically. The same registry runs as an MCP server for Claude or in OpenAI-style function-calling format, so new agents pick from existing tools instead of rewiring them.
• Least-privilege by default: each agent gets only the tools it needs. The Hardship agent can look up a customer and run scenarios, but it can't book appointments or draft offers.
• Autonomy levels built in: every tool has a level from L1 to L4. A shared gate decides whether an action runs, waits for consent or employee approval, or escalates to a human. An agent can never approve its own action.
• Guardian as a shared safety layer: one deterministic checker runs on every agent's output. It verifies that numbers trace back to tool results and checks tone, consent, disclosures, fairness and prompt injection. Any new agent gets it automatically.
• Monitoring out of the box: every run writes a trace with the plan, tool calls and their timings, the Guardian verdict, the action taken, and the model and prompt version. Traces are stored in Supabase and stream live to the console.
• Reliability patterns: cached data, pre-checked fallback answers and labeled degraded modes, so an agent stays useful when the model is slow or down.
• Evals: live evals per persona test agents end to end, and saved results refresh the fallback answers.
• Agent Studio (prototype): a console page for creating agents from templates (Recall Notifier, Lease-end Nudge, Rate-drop Alert, or Custom) with preset tools. A prompt-injection check must pass before an agent deploys.

The result is that the next agent TFS needs is mostly configuration rather than new code.

What it does

NextMove has two surfaces running on one decision engine.

Customer App (phone + dealership kiosk)

• My situation → My next move → Why this → Decide + act → Ask NextMove: a guided five-step flow.
• Lease-end photo pre-inspection: snap photos of your car, AI spots the wear items, and you see estimated charges before you return it. (Maria: lease ends in 90 days and she's over on miles, so a buyout beats returning.)
• Best-time-to-move optimizer: month-by-month equity and fees, plus "act now vs. wait 3 months" in dollars. (James: positive equity, don't wait.)
• True cost + CO₂: payment, fuel, maintenance and insurance compared against a hybrid, plus the CO₂ saved.
• 3D showroom: explore your possible next Toyota in 360°.
• Deal-ready dealer packet: your numbers and eligibility, pre-filled and sent to a dealer.
• Hardship path: after a missed payment, it offers a due-date change that lines up with your paycheck and a callback from a real person, not an automated denial. (Priya: missed a payment after a job change.)
• Advisor chat with voice, in English and Spanish.
• Kiosk mode: large touch targets, numbers blurred for privacy until tapped, and a reset after 60 seconds idle.

Employee Console (TFS and dealer staff)

• Command Center and an Opportunity Queue ranked by expected value and retention odds.
• Customer 360, NextMove Review (approve or override with a reason), Live Activity with real-time handoffs, alert approvals and deal packets.
• Agent Traces show every AI decision: its plan, the tools it called, the Guardian verdict and the action taken.
• Market Intel shows live comps and recalls, each with its source and an "as of" timestamp.

How we built it

• Decision engine (Python, FastAPI): pure finance formulas, a builder for each option, and readable eligibility rules in TOML. The engine computes every number. The AI only explains.
• Agents: six agents, each with one job.
  • Orchestrator routes each request.
  • Advisor answers customer questions.
  • Hardship handles payment stress.
  • Sentinel scans daily for triggers and drafts outreach.
  • Market Intel refreshes vehicle values and recalls.
  • Guardian checks every answer before a customer sees it.
• Advisor, Hardship and the vision inspector run on the Claude Agent SDK, locked down to a registry of 12 tools served over MCP. Everything else is deterministic code.
• Guardian: every number in an AI answer must appear in that run's tool output. It also checks tone ("guaranteed," "no-brainer"), consent, disclosures, protected attributes and prompt injection. A failed answer gets one send-back, then falls back to a pre-checked answer.
• Autonomy levels:
  • L1: reading and analysis run automatically.
  • L2: drafts run automatically and appear in the console.
  • L3: anything customer-facing needs consent or employee approval.
  • L4: money and credit decisions are never made by an agent.
• Market data: SerpApi for comps, recalls and dealers. Results are cached in Supabase with a committed snapshot, so the demo works offline.
• Synthetic data: a deterministic generator (1,200 customers, seed 42) that never uses protected attributes.
• Frontends: two Next.js apps in TypeScript and Tailwind. The customer side is a PWA with Framer Motion, React Three Fiber for 3D and the Web Speech API for voice. The console uses shadcn/ui, TanStack Table and Recharts.
• Realtime: Supabase Realtime carries handoffs, traces and alerts between the customer app and the console live.
• Contract-first: one OpenAPI spec generates both the TypeScript types and the Pydantic models. With MSW mocks, our four-person team could build the frontend and backend in parallel from hour one.
• Tests: about 100 pytest tests across finance, scenarios, tools, agents and Guardian, plus lint and typecheck on everything.

Challenges we ran into

• Keeping AI from making up numbers. Language models are bad at arithmetic and great at sounding confident. We split "do the math" from "explain the math" and built Guardian to block any figure that doesn't trace back to the engine. Even the vision model is rejected if it mentions money: charges come only from our own table.
• Agent sprawl and cost. Running an LLM call on all 1,200 customers every day would burn through our quota. Sentinel and Market Intel became deterministic code, and only the conversational agents use the LLM.
• Demo resilience. Hackathon Wi-Fi plus API rate limits is a recipe for failure, so we added cached market data, pre-generated Guardian-checked fallback answers, and a canned inspection result for when the model is slow.
• Explaining finance simply. We kept cutting "residual value," "negative equity" and "amortization" down to sentences anyone can follow, without losing accuracy.
• Coordinating four people across three apps. We froze the API contract early and built against mocks, so nobody was blocked waiting on someone else.

Accomplishments that we're proud of

• A working end-to-end system: customer app, kiosk, employee console and a real decision engine, all connected.
• Three full personas, each with a different "smartest next move": buyout, upgrade timing and hardship support.
• Zero AI-generated numbers reach customers. Every figure is engine-computed and Guardian-verified.
• Responsible AI that's enforced in code, not just promised in a slide: no protected attributes, a hard L4 rule against agents making credit decisions, PII masking and a full audit trail.
• A reusable agent foundation (tool registry, autonomy gates, Guardian, traces) that any future agent plugs into.
• Kiosk privacy blur, bilingual support and voice, so it works for customers beyond the tech-savvy ones.

What we learned

• How auto loans and leases actually work: residuals, payoff, equity, lease-end charges and why timing matters so much.
• The most useful AI here explains well, while the trustworthy logic stays deterministic.
• Guardrails belong in the architecture. The decision to make Guardian plain code shaped everything else.
• Contract-first development and mocks are a superpower for a hackathon team.

What's next for AgenticBabies

• Wire the console's Proof dashboard, fairness report and Agent Studio to the live API (they currently run on mock data), including a simulation of baseline vs. NextMove KPIs across all 1,200 customers.
• One-click agent deploys: take Agent Studio from prototype to production, so TFS can launch a Recall Notifier or rate-drop alert from a template in under 60 seconds.
• Connect to real TFS accounts with consent, plus live vehicle valuations.
• Loyalty credits, offer A/B testing and synthetic connected-car data for proactive maintenance-aware advice.
• A pilot at a dealership kiosk.

Built With

• claude-agent-sdk
• fastapi
• framer-motion
• gemini
• mcp
• msw
• next.js
• openapi
• pnpm
• postgresql
• pydantic
• pytest
• python
• react
• react-three-fiber
• recharts
• serpapi
• shadcn-ui
• supabase
• tailwindcss
• tanstack-table
• three.js
• typescript
• uv
• web-speech-api