AI Engineer World's Fair 2025
Conquering Agent Chaos
Loading slides…
Read the talk
Conquering Agent Chaos: From Local Handler to Deployed Agent
Long-running, stateful agents need more than an HTTP endpoint. Rick Blalock walks through project creation, local tracing, deployment and channel routing—and a deployed invocation that fails.
From a talk by Rick Blalock
Before you start: Familiarity with request handlers, command-line development and basic cloud deployment will help you follow the walkthrough.
When the agent outgrows its deployment model
At the University of Florida, Rick Blalock asked professors and students building agents what caused them the most trouble. Their answer was deployment. Students put their projects on AWS Lambda, then encountered timeouts when their agents needed to work for fifteen or thirty minutes. Those numbers describe workloads, not supported invocation limits: AWS Lambda’s maximum configurable execution timeout was fifteen minutes.
Blalock reports that an internal agent at Agentuity runs for roughly forty minutes a day. The students could not simply move their projects onto VMs or EC2, which their classes prohibited. They also faced gateway configuration and the work of wiring agents together. Even with enough execution time, a deployment still has to make agents reachable and let them communicate.
State adds another mismatch. Much of the web assumes that a request can be handled without preserving an active process between requests; agents may need to retain working state through a longer task. Blalock had already encountered this with a set of qualitative research agents. He initially built them on serverless infrastructure, then had to rearchitect when synthesis took longer than the deployment model accommodated. Runtime duration, state and connectivity are separate deployment problems.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What the infrastructure needs to provide
The first requirement is an execution lifecycle suited to the work: agents should run as long as necessary and be able to pause, stop and resume. The second is to separate input and output channels from application code. An agent should be able to receive work through several channels without rebuilding its core logic for each one. These are the requirements motivating the platform, rather than guarantees established by the short demo.
Observability has two audiences. OpenTelemetry traces and spans help a developer inspect what happened during execution. Self-observability asks for something further: the agent must be able to understand execution information itself, supporting reflection on its behavior. A human inspecting a trace does not demonstrate autonomous reflection. Blalock also includes memory, improvement over time and code execution in the capabilities agents need; the walkthrough that follows concentrates on deployment and developer-facing inspection.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Create the project and choose its boundaries
The walkthrough starts in the CLI:
bash
agentuity create
After selecting an organization, the wizard offers Bun, Python with uv, and Node.js. Blalock chooses Bun and encourages Python users to choose uv. The commands and handler conventions here follow the recording’s SDK generation; the older JavaScript SDK is now archived, and current Agentuity APIs have evolved.
The template menu includes Mastra, but Blalock selects Vercel AI SDK with Groq. He says that much of Agentuity’s internal code—roughly fifty agents at this point in the walkthrough—does not use an agent framework. Framework choice is nevertheless independent of deployment: he describes CrewAI, LangChain, Pydantic and Vercel-based agents communicating through internal networking. Bun with Vercel AI SDK and Groq is his preferred combination for speed, not a benchmark result presented here.
The remaining choices define the deployment boundary:
- Name the project
Hello. A project groups agents and can correspond to a GitHub repository. - Name its initial agent
agent-1-hello. More agents can live in the same project. - Choose protection. The platform handles routing to individual agents, while access can be protected at the project level or with an API key for each agent. Blalock deliberately chooses no protection for this demo.
- Optionally connect GitHub so that merging to
mainautomatically deploys the project.
The agent is therefore an addressable infrastructure object, rather than just a function hidden behind an application’s routing code.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Run locally and inspect a session
With the scaffold created, local development starts with:
bash
agentuity dev
The agent executes locally. If multiple projects are running, they receive assigned ports. Routing identifies the individual agent by its ID, and a managed public tunnel lets an external service reach that local agent. This makes it possible to test service-to-agent interactions while keeping the executing code on the development machine.
The development simulator supports more than a chat box. Blalock shows input choices for text, JSON, HTML and PDFs. He also mentions email support, while explicitly distinguishing it from the inputs available in this simulator. After sending several test requests, he opens the resulting logs, which are available both in the interface and in the terminal.
A session connects those interactions to execution telemetry. In the human-facing trace view, Blalock follows a call through the AI gateway. The gateway removes the need to configure separate model or service keys in this workflow, and call inspection exposes cost, prompt and response. He describes the development interface as mirroring the corresponding production capabilities: the same kinds of logs and session details remain available after deployment.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A small handler contract connects the infrastructure
The generated project has a YAML file for deployment configuration and an agents folder containing entry points. In JavaScript, an agent exports a default function as its request handler. The editor shows that handler with request, response and context parameters, a streaming model call and error handling. The platform takes responsibility for routing incoming data onto the request object.
That request need not originate from a conventional API client. An agent can have an email address or phone number, and incoming content can include JSON or a PDF. The application receives routed input through its handler rather than implementing a separate deployment for every channel.
Streaming and calls to other agents extend the same contract. Blalock describes ctx.get_agent as resolving an agent by ID or name. For example, a JavaScript agent could resolve another agent implemented with Pydantic. The platform supplies an ephemeral token that, in his account, authorizes communication for the duration of execution; the caller can execute the other agent and return or stream its response. This agent-to-agent call is explained verbally, rather than shown in the displayed handler.
The integration boundary remains narrow:
| Concern | Demonstrated convention |
|---|---|
| Deployment settings | YAML configuration |
| Agent entry points | agents folder |
| JavaScript handler | Default-exported function |
| Python handler | run function |
| Framework logic | Constructed normally inside the handler |
Mastra code can retain its usual construction inside the entry point. Likewise, a Python handler can contain a crew or several crews and call another agent implemented with Pydantic. The hosting contract supplies routing and infrastructure access without requiring all agents to adopt the same framework.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Deploy the runtime, then attach channels
Blalock deploys the project, and the upload completes during the walkthrough. He explains that the platform wraps the agent in a specialized container for its selected runtime—Bun in this case. The deployed view shows runtime and deployment information. A project can contain multiple agents, though this demonstration still has only one.
Cost inspection is available at several levels: project, agent and individual run, alongside the session spans already shown in development. The displayed AgentHello dashboard includes runtime details, connections, Total Cost, LLM Cost, input and output token cards, and Recent Activity. A deployed container is not yet evidence of a successful agent run; the next steps configure how work reaches it.
To add email, Blalock selects a new channel and saves it. The interface assigns an email address to the agent. He also describes SMS, APIs and cron jobs as options; a cron schedule can wake an agent to perform work. This is the concrete payoff of separating channels from code: someone can deploy the project from its GitHub repository and then attach their own email address or other inputs. Slack and Discord are described as future additions at the time of the recording.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The webhook creates a session, but execution fails
The deployed endpoint is public because the project was created without authentication. Blalock invokes the webhook with a greeting. A session appears with an ID, and he waits for the execution logs. Routing has accepted the invocation and created an execution record.
The run then reports an error rather than a completed response. Blalock attributes the failure to the configured memory footprint and points to YAML as the place to change the allocation. He does not show a configuration repair or a successful rerun. The demonstration therefore reaches deployment, channel configuration and session creation, but its deployed invocation does not complete successfully.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From deployment infrastructure to operational agents
Returning to the broader platform, Blalock reiterates GitHub integration and describes additional integrations as forthcoming. He reports fifty to sixty internal agents and says the team is getting better development velocity, without giving a measured productivity comparison. He presents this deployment platform as the first product in a planned cloud suite for agents.
The next planned work brings the earlier observability requirement back into focus: infrastructure agents that watch logs and surface emerging issues for developers and the Agentuity team. Blalock jokes about calling this AgentDuty rather than PagerDuty. The name is a joke, but the intended operational role is specific—agents consuming execution information and helping identify problems. It remains roadmap work in this account.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Tool calls within reasoning and a shared services layer
An audience member closes with a question about adding tool calls into reasoning, specifically into reasoning tokens. Blalock affirms interest but does not describe a mechanism for integrating tools into the reasoning process. Instead, he returns to the product criterion used at the start: what capabilities does an agent need to succeed?
His proposed boundary is an infrastructure services layer that supplies capabilities out of the box, while letting developers connect them through Vercel AI SDK tools or another framework. He grounds that interest in a CRM agent the team is building and for which he says he needs these capabilities. The direction is to make shared infrastructure available through the agent’s existing tool interface, leaving framework and application choices with the developer.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Official explanation of distributed traces and the spans that describe individual operations.
Further reading
- AWS Lambda execution-timeout historyDocumentation
AWS's release history records the fifteen-minute maximum execution timeout introduced in October 2018.
Rick Blalock expands on infrastructure designed for agents, including machine-consumable logs, observability and governance.
Updates since the talk
Current Agentuity source repository with CLI tooling, service clients and framework integrations.
Current documentation for using Agentuity services from application code and supported frameworks.
Full transcript
Loading transcript…