Bonbonnetje is an AI Agent running in production helping Xebians submit expense claims. The Agent is built with Agent Development Kit and is running on Google Cloud Platform. Bonbonnetje is in active use by multiple internal departments and successfully completes hundreds of submissions monthly, helping save both employees and back-office valuable time.
Why an Agent for expense claims?
Why, you might ask - create an Agent to help you submit your expense claims? Let us explain:
- Less effort. Any task you can do in under two minutes, do it immediately. With Bonbonnetje, we reduce the time spent on processing your expenses to less than a minute. This way, you don't need to add more todo items to your todo list - because we understand you - it is already long enough.
- Reduced back-office stress. Our Agent performs policy checks and notifies the employee before they submit. This helps reduce submission errors before they even reach our back-office Finance team, saving time.
- Cost saving. Time is money. Bonbonnetje helps save precious time for 1) Xebia employees and 2) Xebia back-office alike. This implies a significant yearly cost saving.
- Learning. What's a better way to learn than to actually build and deploy? Building- and maintaining production Agents is hard- which is the exact thing making it a good practice for our team and beyond.
- Authority. At Xebia we are shipping production Agents for clients. It is straightforward, then, to build internal Agents too. So, let's practice what we preach and Show Our Work! 😉
... and, besides the above, maybe even the most important reason of all: making submitting expenses more fun! 🍬 How valuable is that, to take an otherwise tedious process in your workweek and turn that into something more enjoyable?
Building an Agent that runs and keeps running
Running Agents in production in a reliable, available and observable fashion is not trivial. It requires one to think on how to do session- and state management, artifact storage, Agent observability and Agent evaluation. We choose Gemini Enterprise Agent Platform for this, formerly known as Vertex AI Agent Engine. Our setup can be visualised as follows:
Let's dive into several components in more detail.
An Agent in production: the necessary ingredients
To build Agents several ingredients are needed. We need to define tools, track user conversations in sessions which each have a state, be able to handle artifacts like images, PDFs and other files, and we need to stream responses to the user. That needs to be powered by a model we can pull in, like Gemini 3.1 Flash Lite. That needs to execute in a loop of our choosing and be able to tap into Sub-Agents we define, an orchestrator if you will. We need to be able to plug in custom callbacks into tool calls, LLM calls and other lifecycle events happening, to control the full flow of the Agent. I think you get the gist by now - this can be quite a lot to manage.
That's where an Agentic framework comes in - an Agentic framework can help us build faster by providing us reusable components. There are many Agentic frameworks by now. We chose Google's Agent Development Kit (ADK) for this use case. ADK has concepts of sessions, state, memory, artifacts and more. It allows for easy local development with a web interface you can spin up by running adk web. But, most importantly, we are creating a production Agent here. That means we need for each of those concepts a scalable solution that can run Cloud-native in a stable manner. We also need proper observability around all our Agent-interactions.
This is where ADK maps towards Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine), allowing you to consume a SessionService, ArtifactService and an observability stack consisting of Cloud Trace, Cloud Logging and Cloud Monitoring. This is what the stack and the mapping towards the managed offering look like:
Awesome! We now have the core of the Agent set. To make things operational we do need some Ops. We are using GitHub Actions as a driver for our CI/CD needs, combined with Terraform to spin up relevant Cloud resources:
Tip: the google/agents-cli skills have been very useful in this process.
Agent Observability
Agents are far from deterministic and having proper instrumentation in place so your Agent can be monitored is key. Gemini Enterprise Agent Platform integrates tightly with offerings like Cloud Trace and Cloud Logging. Specifically Cloud Trace comes in very handy, allowing us to instrument all Agent interactions happening in a session. Tool calls, Sub-Agent handoffs, latencies and such. The essential concepts here are traces and spans- where a trace is made up of multiple spans. We can visualise our instrumentation and the managed offerings for observability they target as follows:
Please observe in the diagram OTel. This is OpenTelemetry- which conveniently integrates with Cloud Trace. One such trace can look like the following:
... which visualises, in a trace/span view, one typical Agent interaction with Bonbonnetje. This allows for pinning down latency bottlenecks and easy debugging.
Concluding
Bonbonnetje is an Agent built to help Xebians both save time in submitting their expenses and making it more fun 🍬. Because the Agent also feeds back to the user policies that apply to the expense, errors are caught earlier in the ERP pipeline making for back-office time savings too. Bonbonnetje is running stably in production for several months on Gemini Enterprise Agent Platform and was built with Agent Development Kit with an AI team at Xebia Data.
Important aspects of running an Agent in production are an Agent framework, scalable solutions for session-, state- and artifact management, and proper observability mechanics.
Having built something techy that actually saves time makes us very happy. But more than anything- it was also awesome to build. Happy days!
Written by
Jeroen Overschie
Machine Learning Engineer
Jeroen is a Machine Learning Engineer at Xebia.
Our Ideas
Explore More Blogs
Contact