TripOwner

An AI agent that owns your cab trip: plans from your calendar, answers the driver's calls, negotiates delays and watches over you at night. NVIDIA Nemotron on Nebius.

Comment

Inspiration

In Bengaluru, getting a cab to a meeting is a part-time job. The driver cancels. The next one can't find you, doesn't share your language, asks for your phone number, and then says he'll be thirty minutes late. And at night, being alone in a cab that has stopped moving is genuinely frightening. Ride apps book the cab, and then you're on your own. We wanted an agent that owns the whole trip, from the calendar invite to the door.

What it does

  • Plans from your calendar. Reads your next meeting (Google/Outlook/Apple via iCal), checks traffic for the departure time, works out when to leave, and asks you once: book this cab?
  • Recovers when things go wrong. Driver cancels? It rebooks in the same minute. A driver who stops moving gets replaced. If cabs keep failing, it compares the metro and offers to switch (in our demo: 15 minutes early, ₹30).
  • Answers the driver's phone calls. TripOwner picks up, gives the exact pickup landmark, and politely refuses to share your number, pay cash, or accept extra charges. Guardrails check every reply, whatever the model says.
  • Negotiates late drivers. If the driver needs more than 10 minutes, it asks him to make it within 10, or it will cancel and book another cab. Then it asks "anything else?" before hanging up, and refuses a sneaky fare bump. You get a one-line summary on Telegram.
  • Warns the people you're meeting, before you're late, not after.
  • Night safety. It compares routes with real OpenStreetMap data (shops still open, longest dark stretch, CCTV, street lamps) and picks the busiest, best-lit road. If the cab stops moving it asks "Are you OK?"; no answer in 60 seconds alerts your emergency contacts on Telegram and email with your location.

How we built it

  • Reasoning: NVIDIA Nemotron 3 Super on Nebius Token Factory. It makes the judgement calls (driver chat, cancellations, calendar changes) only through tools (request_ride, cancel_ride, message_driver, notify_attendees), never free text. Routine minute-by-minute ticks run on deterministic rules, so tokens go only to decisions that need judgement, and the rules take over if the model errors.
  • Guardrails between the model and the world: no phone number, email or address to drivers; a spend cap; a booking limit; no cancellation that would make the rider later. The 10-minute rule and the safety alerts are fixed code, not model decisions.
  • Voice: Sarvam AI for Indian-language speech-to-text, translation and voices (Kannada, Hindi, English). Real phone calls go through Twilio: on our free trial we used Twilio's own English speech recognition, answering instantly with "One moment" and polling for Nemotron's reply, because the trial proxy drops slow requests.
  • Maps: OSRM routes and an OpenStreetMap extract for night-route scoring.
  • Rides: a ride simulator with chaos (cancellations, no drivers, stalled drivers, jams); a Namma Yatri / ONDC buyer app over Beckn (signed requests, full ride lifecycle) against a mock network; an Uber Guest Rides adapter tested against a fake Uber server; and a one-tap Telegram mode that pre-fills real Uber/Ola links.
  • Backend: Python, FastAPI, a single-page dashboard; 137 automated tests; Docker; a public demo on Render.

Results

  • Chaos eval, 200 random trips (seed 42), simulator: on time 75.0% vs 57.8% for a typical rider; average lateness 1.9 vs 5.7 min; 0 phone numbers leaked vs 37; you touch your phone 1.0 times vs 2.2.
  • Nemotron vs rules, 100 unseen trips: Nemotron was on time 74.2% vs 71.0% for the rules; on the 17 trips that came out differently, Nemotron arrived earlier on all 17. 512 decisions, 0 fallbacks, about $0.003 per trip.
  • Call bench: 30 English driver scenarios (delays, cash, extra charges, OTP, wrong callers, rude drivers) through the real call pipeline: 60/60 passed with Nemotron.
  • Real world: a real phone call answered on a Twilio trial line (negotiated a 30-minute delay down to 10 and kept the ride), and the safety alert tested on a real phone with real GPS (Telegram + email).

Challenges we ran into

  • Keyword rules misread drivers. "Your building number?" isn't a phone-number request; Nemotron understood it, the rules didn't.
  • The model needed guardrails. Nemotron once cancelled a ride that was already coming to "rebook for an earlier meeting", making the rider later. A deterministic check now blocks any cancellation that leaves the rider later.
  • Phone calls on a free trial: the trial strips Twilio's signature (we verify the call with Twilio's API instead), forces a shared trial number, and drops replies that take more than a second or two, so we answer instantly and poll for the reply.
  • Honest numbers: our first eval had too many false "running late" alarms; holding warnings until 30 minutes before the meeting cut them from 21 to 4.

Accomplishments that we're proud of

  • An agent that handled a real phone call end to end: understood the delay, negotiated, kept the ride.
  • Zero phone-number leaks across every eval, enforced in code.
  • A safety check-in that fires on distance, not ETA, so traffic jams don't trigger false alarms (0 check-ins in 300 normal trips).

What we learned

  • Let the LLM make judgement calls, but keep hard rules (privacy, money, safety, the 10-minute limit) in code.
  • Test agents like you test software: we built a chaos simulator and a call bench, and every bug they found became a test.

What's next for TripOwner

  • Registering as an ONDC buyer app to book Namma Yatri rides for real.
  • An Indian telephony number (e.g. Exotel) so the driver's call forwards straight to TripOwner.
  • Sarvam voices on live calls (Hindi and Kannada), and Google Routes for live traffic.
  • A phone app with background location for the safety check-in.
Share this project:

Updates

Submission history