Baton

Our tagline
Session menu
Working on agent code together
IDE and code output

Inspiration

All four of us have professional software development experience (including at Google, NASA, Suno, and Michelin) and compete in hackathons recreationally. When working with AI code development tools throughout these experiences, we've desired being able to collaborate together in the same code agent session, much like how you can have multiple people type in the same Google Doc simultaneously. Our business-to-business software-as-a-service startup idea is a novel layer between high output engineering teams and their AI development tooling of choice, allowing for developers to collaborate on code in the same agent session. For specific details relating to the Boyd Innovation Center Startup track, check the "BIC Startup Challenge" header below.

What it does

Baton runs an AI coding agent on a server instead of in one person's terminal, so the whole team can work in the same agent session. Anyone with the link can join and see every token, tool call, diff and test run stream in as it happens. If you join late, you get a catch-up card that tells you the goal, what's been done, what other people changed, and any open questions.

One person drives at a time. The driver can steer the agent, interrupt it, and answer its decision points, and handing the baton to someone else takes one click. Everyone else can comment on any step or suggest a direction, and the driver can pass the good suggestions to the agent with both names attached. Baton also has a shared code view (file tree, editor and terminal) where you can watch the agent's edits land live, along with a scrubber for rewinding, replaying or forking the session from any step. It works with Claude, Gemini, OpenAI models or local weights, and you can switch models mid-session. People can even join from their phones by scanning a QR code.

How we built it

The backend is Python with FastAPI. Everything that happens in a session goes into an append-only event log stored in SQLite, and clients subscribe to that log over WebSockets. Watching live means streaming new events, and joining late means replaying the log from the start. Steering means queuing a message that the agent picks up at its next turn boundary, and forking means copying the log up to a given step. We wrote our own provider layer for Anthropic, OpenAI, Grok, and Gemini, plus any OpenAI- or Anthropic-compatible endpoint, which is what lets the model change partway through a session. The frontend is React with Vite, Tailwind, Zustand and CodeMirror for the editor. We deployed on AWS Lightsail and added billing through Stripe.

Challenges we ran into

Switching models mid-session was harder than we expected. Claude and Gemini both return signed reasoning blocks that have to go back to the exact model that produced them, so we had to track which model wrote each message and only send those blocks back to that model. Interrupting and steering the agent while a tool call was still running was tricky too, because the message had to land cleanly at the next turn boundary without corrupting the agent's state. We also wanted sessions to survive a server crash, so we made the event log durable and runs pick up where they left off on restart. Finally, getting the agent's shell commands to behave the same on Windows as on Mac and Linux took more work than we planned for.

Accomplishments that we're proud of

We're proud that Baton feels like a Google Doc for coding agents. Several people can watch the same agent, comment on its steps and pass control around without stepping on each other. We're also proud that it doesn't depend on any one model: you can start a session with Claude, switch to Gemini halfway through, and keep going. We built an offline demo model as well, so anyone can try Baton without an API key.

What we learned

We learned that the hard part of working with AI agents as a team isn't the agent, it's the collaboration layer around it. Once everything is an event in a shared log, features like replay, forking, hand-offs and catch-up summaries become much simpler to build. We also learned a lot about how different model providers handle streaming, tool use and reasoning, and how small differences in their APIs matter when you want them to be interchangeable.

What's next for Baton

Next, we want to add real authentication and team workspaces, since identity in Baton is currently demo-grade. We also want to expand the bring-your-own-agent API so tools like Claude Code and Cursor can stream directly into a Baton session. Beyond that, we plan to build deeper GitHub integration, such as opening pull requests straight from a session, and to grow the insights page so teams can see where and how people step in to correct their agents.

BIC Startup Challenge

Problem & Customer

The industry-observed issue that Baton solves is the difficulty of collaboration in AI-accelerated software engineering teams. Whiteboarding and prototyping that was previously done in open conversations with other engineers has largely shifted to iterating design plans with a coding agent, taking other human engineers out of a loop. Thus, when a problem is encountered, recontextualizing a domain expert engineer is very time intensive, as you need to bring them up to speed from scratch. Baton solves this by bringing human collaboration back into software engineering, without sacrificing any of the efficiency brought about by AI-aided development, showing invited collaborators the full planning and context in which the original engineer ran into issues, and allowing the expert to prod the reasoning carefully.

Our target customer base is fast-shipping software startups. To ground this decision, our team has observed the need for a Baton-like product in such startups. One of our team members interned as a software engineer a rapidly growing AI startup this summer, where they noted that an internal collaboration/sandboxing AI-native platform had been a roadmap develop item for platform and infra teams for the past 3 quarters, but it never got acted upon as it was too much of an investment to put a team of engineers on building and maintaining a usable and scalable system for the AI/human collaboration layer. Additionally, in fast-shipping cultures, documentation and planning often falls behind the scope of what is shipped, making the "recontextualization" even more time-consuming, and often incorrect or incomplete.

Business Model

We will market to our customers on a per-seat enterprise and team plan, billed monthly (annual billing is an option, but for our growth stage startups, monthly will often make more sense, as they will have more accurate estimations of how many seats they need month-after-month instead of per year). We will offer a free plan that allows for 1 active session (any actual team will need far more sessions, so there is no way for teams that would use this to skimp by on the free tier), with limited log retention (so sessions can only resume within a few days of creation), and further feature limitations (a full chart is provided on our billing page). We then offer team-based pricing at $25/seat/month, with longer but still capped log retention, unlimited sessions, and some additional features (for example, Slack notifications). Finally, we offer enterprise pricing at $50/seat/month, with unlimited log retention, unlimited sessions, and a full bevy of features (SSO, audit log export, etc.). In all of our plans, we allow people to view for free--we gate on session count.

Since Baton is the only existing collaboration tool for software development, and we have demonstrated need from our customer base, we want to heavily index on early adoption--we provide a no-strings-attached free way for engineers to test the product, and then a cheaper tier (Team) that startups can use to determine fit before elevating to our premier option with a full feature suite.

GTM

Since we allow free viewers, there is an intuitive to convert people who have seen it used in real-time to purchasers. We would offer training sessions for how to use it at free webinars, which directly feeds our audience of viewers, who can then convert. We could offer first-month discounts to particularly relevant startups (ie, fields that are commonly audited, where stored logs are especially important). We can announce on Hacker News, and build out our Slack and Teams integrations more complete.

Validation, Competition, and Edge

We have spoken directly to people in cutting edge tech startups who have desired the exact type of tooling (collaborative AI usage) that Baton is made for. Furthermore, we have collected first-hand testimony from various computer science students verifying that they would use this technology. The change is supported in other mediums: Microsoft Word's prevalence has waned as Google Docs (collaborative and online, as is Baton vs. existing coding agents), and similarly Figma (collaborative) has supplanted Photoshop (singular) as the go-to design option for many startups and companies.

Baton is a one-of-a-kind technology, in that it truly allows collaboration between developers in interacting with AI tools. Existing technology can offer broadband observability (ie, Github Agent HQ or Slack Code), but these are only for allowing multiple developers to watch an agent executing tasks. Baton improves upon this by allowing multiple developers to be concurrently in the loop, actively iterating on prompts and requests, instead of just monitoring an agent run.

Next Steps and Scalability

Our Total Addressable Market (TAM) consists of every software engineer in the world, billed at Team pricing--an estimation in total value here would be 36.5 million developers (per SlashData in early 2025) * $300/year/developer =$11 billion/year in revenue. The Serviceable Addressable Market (SAM), as an approximation, would be large (50+ developer) software companies, where agent use is common, in North America and Western Europe. We can approximate this to be 22 million developers (large companies) * 0.4 (share of developers in North America and Western Europe) * 0.5 (share of developers that frequently use agentic coding, per StackOverflow's April server) * $300/year/developer = $1.3 billion/year approximately in revenue. Our Serviceable Obtainable Market (estimated for a 5 year goal) would be 1000 paying companies averaging approximately 70 seats, and averaging $400/year/seat (with a target of 2/3 Team, 1/3 Enterprise pricing) yields $29 million ARR. All of these estimates are based on developers, but this type of tooling is something we plan to scale towards other usecases (ie, legal document review or marketing design iteration).

To scale our product to something that can achieve these market shares, we have a roadmap of big ticket items we'd like to integrate. First, we would want to foster close relationships with early purchasers, so we can adapt targets based on real uses. User feedback aside, we plan to add in support for existing coding harnesses (Claude Code, Codex, Pi, etc.), instead of just model variability, to integrate seamlessly into existing workflow. We would want concrete integration with Slack, Teams, Jira, and other product management tools. Once we have these integrations, we would want to expand our sales team, to start reaching towards our 1000 company goal.

As we scale, we need to consider what costs grow as we scale. The most obvious one is our current server and storage Lightsail usage, which is cheap to run for 4 students at a hackathon ($7/month for any reasonable usage we would achieve), but does not scale across hundreds to thousands of teams generating constant logs. As such, we would rent a private network and server from a B2B compute distributor, which is an easy switch to make (but something we didn't want to invest an upfront cost for out-of-pocket for a hackathon). We would also need to hire more engineers to support maintenance--the limiting factor preventing startups from greenfielding this is often the maintenance cost, as model APIs and harnesses constantly change, which is a cost we need to keep in mind--it is on us to update our layer to keep compatibility with harness and model changes. We also need to be cognizant of developments to related tools (as previously mentioned, Github Agents HQ and Slack Code address a subset of Baton's functionality), but we are confident that our multi-provider ecosystem will still be a draw (for example, Github Agents use Copilot, but Baton allows usage of any model provider).