Shotgun

Commute used to be dead time. Shotgun turns your car into an AI agent that rides... shotgun. Plug in, say what you need, and it's handled before you park.

Comment

Inspiration

I'm a sophomore, and a lot of my friends and I drive cheaper, temporary cars. No Tesla screen, no built-in assistant, no tech. What they almost all have is a USB port and CarPlay.

At the same time, everyone around me is talking about AI agents. Watching new agent startups launch and the OpenAI DevDay announcements, I noticed that nearly all the innovation is in what the agent can do, and almost none is in how we actually interact with it. A chat window is a great place to talk to an agent when you're at your desk. But to me, actually intelligent means AI that fits seamlessly into the rest of your life too, wherever you are and whatever you're doing. That makes the medium, how and where you reach it, the next big step for agents. I considered a watch, a ring and other wearables, but the most feasible and useful place to start was the car.

Lots of people are a few minutes late to work or class because they had one more thing to get done first: reply to someone, look something up, fix a small thing. You can't do any of that while driving. With Shotgun you can, because everything happens by voice and the agent does the work for you.

What it does

Shotgun is an AI agent saved as a phone contact.

  1. Plug in your phone and within about 10 seconds the car rings with "Shotgun" on the dash.
  2. Say what you need. Quick questions ("what's the score of the Michigan game?") are answered on the call. Bigger jobs ("fix the login bug Sarah filed") are handed to background workers, and the agent asks for any "yes" up front: "Merge it if the tests pass?"
  3. Drive. Workers run in parallel while you're on the road. The coding worker opens a GitHub issue, Claude Code writes the fix, and a pull request opens.
  4. About 3 minutes before you arrive, the car rings once more with a batched summary: what's done, what's waiting on you, what failed. Nothing irreversible (sending, merging, ordering) happens without a spoken "yes". There are at most two calls per drive, so it never becomes a distraction.

How I built it

I spent the first hours just on system design: what was actually possible in 24 hours, which stack to use, and where the limits were. Then I split the whole project into 26 small build steps, each with its own test that proves it works, and built them up one at a time: phone call → plug-in trigger → job table → workers → arrival call.

  • Trigger: an iOS Shortcuts automation, "When CarPlay connects", posts the phone's location to my server.
  • Voice: an ElevenLabs agent on a Twilio number, running Claude Haiku 4.5 for fast voice turns.
  • Brain: a Claude Sonnet orchestrator turns what you said into jobs.
  • Server: Python + FastAPI on Railway, with a Neon Postgres job table shared by every agent. The agents never talk to each other directly. They coordinate through the table.
  • Workers: coding (GitHub issue → Claude Code GitHub Action → PR, merged only if the tests pass) and research (Claude with web search).
  • ETA: Google Routes API, computed once at departure.
  • Recap: when you unplug, the drive closes and a push notification summarizes it.

Voice has a hard latency budget, so the tools are split in two. Inline tools (search, drafts) answer in under 8 s, and background tools answer in under 500 ms by writing a job row and returning, never waiting on a worker.

I built Shotgun solo on purpose. I'm already building real hardware with a team on another project, Plug X, and this weekend I wanted to find my own limits, strengths and weaknesses.

Challenges I ran into

The biggest challenge was scope. I originally wanted to show far more than code: DoorDash orders, messages, even connecting to a camera. A lot of those needed high-level access or approval I couldn't get in a weekend (DoorDash's agent CLI, for example, is waitlist-only). I had to cut them and put everything into making one flow really good: fixing real code from the driver's seat.

Designing for the car was its own challenge. My first version called you back every time a job finished. That's fine at a desk and terrible on the road. I redesigned it around two calls per drive (departure and arrival), with approvals asked up front so the work can finish without interrupting you. Getting a voice agent to stay on the line until you say goodbye, handle voicemail on the arrival call, and never take an action without a clear "yes" took a lot of iteration in a real car.

Accomplishments that I'm proud of

  • It works in a real car: plug in, the car rings, you speak, and a pull request gets fixed and merged before you park.
  • The safety model: nothing irreversible happens without a spoken "yes", and a result that breaks what you approved stops and calls you instead of going ahead.
  • A tested, deployed system built solo in 24 hours, with hundreds of offline tests behind it.

What I learned

I learned a lot about how AIs interact with each other: one agent planning, others doing the work, and a voice agent sitting in front, all coordinating through shared state instead of talking to each other directly.

The bigger lesson was about focus. With limited time and resources, it's better to take what I can do and make it great than to half-build ten features. That's why Shotgun's demo is all about code.

What's next for Shotgun

  • More workers: messages, email, and food ordering once I have API access.
  • Calendar awareness, so it knows where you're headed before you say it.
  • New mediums beyond the car

Built With

Share this project:

Updates

Submission history