Anthropic just ran a set of live demos showing how to build production agents on Claude Opus 4.8, featuring two partners that solve the hardest parts of agent work: Letta for persistent memory and Browserbase for web automation. According to Anthropic, the session focused on moving past chatbot-style prototypes toward agents that remember what they did and can actually act on the open web. That combination is where a lot of real agent value lives, so it’s worth walking through how the pieces fit.
What stands out is the division of labor. Opus 4.8 handles reasoning and tool use. Letta handles long-term memory so the agent doesn’t forget between sessions. Browserbase gives the agent a real, cloud-hosted browser to navigate sites, fill forms, and pull data. Here’s a practical way to approach building with this stack.
Quick Start
You’ll learn how to assemble a memory-equipped, web-capable agent on Claude Opus 4.8. What you need:
- An Anthropic API key with access to Claude Opus 4.8
- A Letta account or self-hosted Letta server for memory
- A Browserbase account for hosted browser sessions
- Basic Python or Node, and comfort with API calls
Step 1: Start with the model and a clear job
Pick Opus 4.8 as your reasoning engine and define one concrete task the agent owns, like researching a topic or filling out a recurring report. This matters because agents drift when the goal is vague. A tight job description keeps tool calls focused and cheaper.
Step 2: Give the agent tools, not just a prompt
An agent earns its name by taking actions. Wire up tool definitions so Opus 4.8 can call functions, and let the model decide when to reach for each one. The reasoning quality here is the whole point of using a frontier model rather than scripting every branch yourself.
Step 3: Add persistent memory with Letta
Connect Letta so the agent stores facts, past decisions, and context across sessions. This is the difference between an assistant that restarts cold every time and one that builds on prior work. Letta manages what stays in the active context window versus what gets archived, so you don’t blow your token budget holding everything in memory at once.
Step 4: Give it a browser with Browserbase
Plug in Browserbase to hand your agent a real, sandboxed browser running in the cloud. The agent can then navigate pages, click, type, and extract content like a person would. This unlocks tasks that have no clean API, which is most of the web. Running the browser remotely also keeps the heavy, flaky parts off your own machine.
Step 5: Close the loop and watch it run
Let the agent plan, call a tool, read the result, update memory, and decide the next step. Observe a full run before trusting it. Anthropic’s live format underscores the point: you learn the most by watching the agent actually execute, not by reading the spec.
Tips and Cautions
- Scope memory deliberately. Store what the agent needs to recall, not every token. Bloated memory raises cost and slows reasoning.
- Sandbox the browser. Real web access means real risk, so keep credentials and permissions tight.
- Test on narrow tasks first. A reliable agent doing one thing beats a fragile one attempting ten.
- Log every tool call. When an agent misbehaves, the trace is your fastest path to the cause.
Why this matters
Memory and web action are the two capabilities that separate a demo from a deployable agent. Letta and Browserbase package both as services, which means you’re integrating rather than building infrastructure from scratch. Pairing them with Opus 4.8’s reasoning is a credible blueprint for agents that do useful work without constant hand-holding.
Next steps
Start small: build a single-task agent with memory, then add browser actions once the core loop is stable. From there, layer in more tools, tighten your prompts, and measure cost per run as you scale. Anthropic shares more on the full demos at the original source, and both Letta and Browserbase publish docs to get your first integration running.