cabbie

Cabbie is your agentic ride-booking concierge that checks multiple cab apps at once, compares live price & ETA, and books the best option for your needs, so you never overpay or app-hop under pressure

Comment

Inspiration

Booking a cab during rush hour often means juggling multiple apps, watching prices change in real time, and still not knowing if you picked the best option. We wanted to remove that stress by building one system that compares apps for you and helps you book quickly. Cabbie started as a “why is this still manual?” hackathon problem: if agents can navigate software, they should be able to navigate ride apps too.

What it does

Cabbie is a ride-booking co-pilot that:

  • Accepts pickup, dropoff, and rider priorities (cheapest, fastest, comfort, etc.)
  • Checks multiple ride apps in parallel through Android emulators
  • Extracts live options (price, ETA, category), ranks them, and returns the best matches
  • Lets users confirm a selected option for booking
  • Supports voice-first interaction with text fallback in the frontend

How we built it

  • Backend: TypeScript + Node.js + Express with endpoints for request, confirm, and health.
  • Data layer: MongoDB for user/app configuration and runtime orchestration context.
  • Automation: ADB + Android emulator orchestration (launch, snapshot restore, boot checks, app launch).
  • Agent orchestration: Parallel sub-agents run across apps, return structured results, and feed a deterministic ranking layer.
  • Frontend: React + Vite + TypeScript interface with voice interaction (ElevenLabs), typed fallback, loading states, and booking confirmation flow.
  • Infra: Dockerized services for backend, emulators/ADB, and MongoDB; deployed on Vultr with Nginx reverse proxy.

Challenges we ran into

  • Portability: Initial hardcoded local paths for tooling caused environment-specific failures.
  • Runtime stability: Emulator orchestration is heavy and sensitive to startup timing.
  • Long request windows: Real app automation takes time, so we had to design around long-running operations and clear user feedback.
  • Contract drift: Frontend and backend payloads changed during rapid iteration, which created integration bugs.
  • Testing difficulty: End-to-end automation involving emulators and agents is harder to test reliably than standard APIs.

Accomplishments that we're proud of

  • Built a working end-to-end flow from user request to ranked ride options and booking confirmation.
  • Successfully orchestrated multi-app checks in parallel instead of manual app-hopping.
  • Delivered a polished frontend experience with voice + text interaction.
  • Containerized and deployed the full stack to a cloud server.
  • Turned a complex orchestration pipeline into a demoable product under hackathon constraints.

What we learned

  • Agent systems need strong guardrails, explicit contracts, and deterministic orchestration logic.
  • Reliability engineering matters as much as model capability in real-world automation.
  • Clear loading/progress UX is critical when intelligent workflows take minutes, not milliseconds.
  • Cloud deployment quickly exposes hidden local assumptions.
  • Good ranking is a product decision, not just a technical one: users care about tradeoffs between price, ETA, and comfort.

What's next for cabbie

  • Harden orchestration reliability with retries, health checks, and better observability.
  • Improve portability by fully externalizing runtime/tooling configuration.
  • Add stronger session persistence and recovery beyond in-memory state.
  • Expand app coverage and improve extraction quality for edge UI cases.
  • Ship production-grade auth, analytics, and feedback loops to personalize ride recommendations.

Built With

Share this project:

Updates