BELL: The personal assistant stack

Introduction

Personal assistants are moving from conversation to action.

A request like “order me a bag of coffee” sounds simple. However, to do that the assistant has to receive a message, plan the task, navigate a merchant’s website, authenticate to the right account, complete checkout and return to the user.

A model is one part of that equation, the rest of it is infrastructure that lets an assistant operate in the real world. This is the stack behind BELL, our reference architecture and sample app for building personal assistants that can operate in the real world.

The request starts in a message

It starts with a text, which feels simple from the outside, but iMessage and RCS are separate ecosystems with different APIs, delivery behavior and capabilities. An assistant has to receive the message reliably and keep the responses in the same conversation, even if the protocol changes.

Linq maintains the infrastructure that enables this messaging layer, allowing an assistant to communicate with any user all within a single thread.

The next step is coordinating all the moving parts that come next.

The message becomes a plan

Now that the coffee request has reached the assistant, it has to decide what to do and more importantly have a way to do it.

In Eve, you define the assistant’s instructions and expose tools as functions. Those tools connect a model to services like Browserbase, 1Password, and Stripe Link to carry out the task. For our coffee order, that means giving the assistant ways to browse the internet, access a user’s account and make payments.

The work may also pause along the way to fetch a user’s credentials or get approval for a payment. Eve checkpoints execution so the task can wait and resume with its context intact.

The assistant’s first action takes it out of the conversation and onto a merchant’s website, where it needs to find a bag of coffee and work through the steps to buy it.

The plan goes global

The assistant opens the merchant’s website to find a bag of coffee which means it needs to search through available products, find the right one, and add it to the cart while honoring the users $30 limit.

That means working through an interface built for people. A product might require selecting a size, a pop up might cover the page, shipping costs might only appear during checkout. The assistant has to observe at every step to decide what action comes next.

Browserbase is the last mile of the internet, and helps to connect agents to services that don’t have proper agentic endpoints.

The coffee is now in the cart, but completing the order brings us to the next boundary.

The merchant wants to know who is acting

An agent may be well-intentioned, but the merchant still needs to know which customer is placing the order. In practice, this has two parts.

First, merchants need to understand the relationship between the customer and the agent. Web Bot Auth (WBA) can help access providers such as Cloudflare and reCAPTCHA identify the company operating an agent, but it does not tell the merchant who the customer is. Baselayer works with merchants to attach tokenized KYC data to requests, helping them verify the customer behind the agent and combat chargeback and refund fraud.

Second, the assistant needs secure access to the customer’s account. Every valuable service is protected by credentials, but storing those credentials creates significant liability. 1Password’s agentic autofill lets an agent request scoped access to credentials in the customer’s vault without exposing the underlying secrets to the model.

The assistant can now sign in with the appropriate account, while the merchant has a way to verify the customer and the agent’s authority to act.

The request reaches checkout

The item is in the cart, the customer is authenticated, and the merchant has a way to verify who is acting. Now the easy part, making a payment.

Link by Stripe lets the agent create a spend request to the user for a merchant and amount. The user approves that request through Link, and the agent receives a payment credential scoped to the purchase rather than access to the customer’s underlying card details.

Visa’s work on Visa Intelligent Commerce (VIC) and Trusted Agent Protocol (TAP) address the network problem by helping merchants and payment systems recognize and safely process purchases initiated by an agent.

Finally, the merchant confirms the order, and the assistant sends a short message back through Linq with the final details.

You can just build a personal assistant

The user experienced a simple exchange. They sent a message via iMessage and a receipt came back.

Behind that exchange, the assistant coordinated messaging, planning, browser execution, identity, credentials and payment. Each layer helped the assistant connect with the rest of the world.

BELL brings those pieces together in a reference architecture and sample app for coding agents.

GitHub: https://github.com/browserbase/bell-stack