AWS Builder Center
Pizza Bot: The AI Inbox 2,000+ Amazonians Use, Quietly

Pizza Bot: The AI Inbox 2,000+ Amazonians Use, Quietly

A hands-on look at Pizza Bot, an open-source inbox for background AI agents born inside Amazon, plus why AWS barely talks about it.

Cloud Engineer

An inbox for agents that work while you don't watch

AWS's Open Source Blog recently introduced a project called Pizza Bot: a client application for AI agents that treats every task like an email thread. You send it off, you don't babysit it, and you check back on your own schedule.
That framing caught my attention enough to clone the repository and actually run it. This post covers what Pizza Bot does, why the inbox metaphor works, a theory on why AWS keeps it low-key despite heavy internal adoption, and a walkthrough of getting it running end to end, including a real deployment to the public internet.

What Pizza Bot actually is

Pizza Bot is a self-hosted client for background AI agents, released under the Apache License 2.0. The architecture splits into four layers:
  • Client: an Electron desktop app, a browser, or a terminal
  • Server: an HTTP process that manages agent run state
  • Runtime: DeepAgents/LangGraph
  • Storage: local SQLite plus files (checkpoints, threads, attachments)
The interface has three views instead of a chat window:
  • Unread, for threads the agent has finished
  • Action, for threads waiting on a human decision
  • All, for the full history
Model support isn't locked to any single vendor. Anthropic, Amazon Bedrock, Google Gemini, OpenAI, OpenRouter, and Ollama are all options, and Anthropic Claude is the default recommendation rather than Bedrock. Tools come in through MCP servers, and custom capabilities are added with  Skill.md  files.



Why the inbox framing is the actual feature

A chat window only does work while you're staring at it. Anything that takes a few minutes, needs an approval step midway, or should run on a schedule doesn't fit that shape well.
Pizza Bot's mental model is closer to handing a task to a coworker. They walk off, do the work, and report back. You keep doing your own thing and check the inbox when it's convenient, not the moment the agent starts.
That matches how it's reportedly used inside Amazon: meeting prep, drafting emails, summarizing Slack threads, logging into a CRM. Tasks that are too fiddly for constant back-and-forth chat, but not simple enough to fully automate unattended.

Why AWS isn't shouting about it

This is the part I found most interesting. A tool with 2,000+ internal users got a comparatively quiet rollout. It's not on the AWS News Blog or What's New page, only on the Open Source Blog, and there was no re:Invent-style spotlight.
A few reasons seem plausible:
  • It ships as an Apache-2.0 community project, explicitly outside AWS Support
  • It isn't tied to Amazon Bedrock. Every major model provider is a first-class option, and the default recommendation is Anthropic directly, not Bedrock
  • It's a self-hosted client app, not a billable managed service
AWS marketing usually points back at an AWS service. Pizza Bot's design deliberately avoids that lock-in, so it doesn't fit the usual "look what you can build on AWS" pitch. My best guess is that a genuinely useful internal tool got open-sourced out of good OSS hygiene, without becoming a marketing vehicle. That's a read from the outside, not something AWS has stated.

Running it for real

Getting it up locally

git clone https://github.com/pizza-bot-app/pizza-bot.git
cd pizza-bot
npm install
npm run build && electron .
It's a monorepo:  api-server  runs the backend under  tsx ,  web  is a Vite dev server on port 5273, and Electron just renders that inside a window.

Wiring it to Amazon Bedrock

The settings screen lets you pick a provider. I already had an active AWS SSO session, so I pointed it at Amazon Bedrock using the cross-region inference profile  us.anthropic.claude-sonnet-4-6  in  us-east-1 . No IAM surprises, it connected on the first try.

The one thing that went wrong

Restarting the Electron app repeatedly during testing made the window keep popping back to the front, which got in the way of everything else I was doing on the machine. The fix was to leave the app running and just hide the window:
osascript -e 'tell application "System Events" to set visible of process "Electron" to false'
Everything kept running underneath. I switched to hitting the API directly for the rest of the verification instead of touching the GUI.

Confirming it actually works

I sent a harmless request through the API — a three-line summary of AWS, nothing with external side effects — and it came back through Bedrock correctly, showing up in the thread list as unread. Unread, Action, and All behaved exactly as described.

Deploying it to the public internet

Once the local setup worked, I took it further and deployed a real, internet-reachable instance:
  • Frontend: Vercel, serving the static build of  apps/web 
  • Backend: a single AWS EC2 instance ( t3.small ) running the official Docker image. The backend owns local SQLite files and is explicitly not horizontally scalable, so one always-on VM is the natural fit
  • Infrastructure as code: a CDK app scaffolded with nx-plugin-for-aws's  ts#infra  generator, deployed with  cdkd , a CDK-compatible CLI that calls the AWS SDK directly instead of going through CloudFormation
  • TLS: rather than buying a new domain, I used sslip.io (a free public DNS service that resolves a hostname embedding an IP address back to that IP) with Caddy handling automatic Let's Encrypt certificates
  • Bedrock credentials: the project's own docs flag that an AWS SSO session isn't suitable for an unattended backend, since it expires. I created a dedicated IAM user scoped to  bedrock:InvokeModel  only
One real mistake along the way: the EC2 boot script logged the access key and API token in plaintext during setup. Once I noticed, I rotated both credentials and re-verified everything after reconfiguring the instance and the Vercel project. The project's own security notes call this exposure model "unsupported / discouraged" — no rate limiting, authorization down to a single shared bearer token — and that warning turned out to be accurate. Getting it running and running it safely are two different problems.
I'm not linking the live URL in this post. Anyone who found it could call Bedrock through it without limit, which is a billing risk I'd rather not create.

Adding a language toggle

The original UI is English-only, so I added a Japanese/English switch as a small experiment on top:
  • A plain React context plus a dictionary object, no i18n library
  • Coverage across the main inbox views and the settings screens
  • The chosen language persists in  localStorage , with  navigator.language  picking the initial default


This lives only in my local fork, not upstream. It was less about contributing back and more about seeing how far I could push the app once I already had it running.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article