# Conquering Agent Chaos

Rick Blalock, Agentuity

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/yASxPZ-tZe0-conquering-agent-chaos) · [Video](https://www.youtube.com/watch?v=yASxPZ-tZe0)

## 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.

Familiarity with request handlers, command-line development and basic cloud deployment will help you follow the walkthrough.

### When the agent outgrows its deployment model

[0:25](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=25s)

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](https://docs.aws.amazon.com/lambda/latest/dg/lambda-releases.html) was fifteen minutes.

Blalock reports that an internal agent at [Agentuity](https://agentuity.com/company) 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.**

![Slide titled “Agent deployment headaches” lists six challenges, with a presenter inset partly covering the final bullet.](https://ai.engineer/api/talk-essay-media/dc27a46397c9972d8dd796ebedafaf60e61ce785544b68c02bb05408bbb2b40c)

Agent deployment headaches: timeouts, inefficient VMs, networking, scaling and state.

### What the infrastructure needs to provide

[1:59](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=119s)

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](https://opentelemetry.io/docs/concepts/signals/traces/) 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.

### Create the project and choose its boundaries

[3:52](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=232s)

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](https://github.com/agentuity/sdk-js) 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.

![Agentuity project wizard on Select Template, highlighting Vercel AI SDK + Groq, with Mastra also visible.](https://ai.engineer/api/talk-essay-media/5be49d105907ce91e35768d9e2618f788d6dddf43f57fe01c7ea37a2ae99f84a)

Choosing the Vercel AI SDK + Groq template for a Bun project.

The remaining choices define the deployment boundary:

1. Name the project `Hello`. A project groups agents and can correspond to a GitHub repository.
2. Name its initial agent `agent-1-hello`. More agents can live in the same project.
3. 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.
4. Optionally connect GitHub so that merging to `main` automatically deploys the project.

The agent is therefore an addressable infrastructure object, rather than just a function hidden behind an application’s routing code.

### Run locally and inspect a session

[5:59](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=359s)

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.

### A small handler contract connects the infrastructure

[8:07](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=487s)

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.

![Code editor showing an agent handler with request, response and context parameters, a streaming model call, and error handling beside the project file tree.](https://ai.engineer/api/talk-essay-media/85f65e7f7e172e3bd50072fdf6b70edbf29dc95f4949685e3eee6e9cca1a90b5)

The agent request handler streams a model response and logs errors.

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.

### Deploy the runtime, then attach channels

[10:09](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=609s)

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.

![AgentHello detail panel with Active status, Bun runtime, a connection diagram, Total Cost, LLM Cost, input and output token cards, and Recent Activity.](https://ai.engineer/api/talk-essay-media/f9da977238ed77b363b0e81d7235229a287b02ed4a74ef0d225774cd4a2c53dd)

AgentHello’s dashboard shows runtime details, connections and Cost & Usage.

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.

### The webhook creates a session, but execution fails

[11:47](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=707s)

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.

### From deployment infrastructure to operational agents

[12:34](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=754s)

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.

### Tool calls within reasoning and a shared services layer

[13:37](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=817s)

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.

## Resources

- [AWS Lambda execution-timeout history](https://docs.aws.amazon.com/lambda/latest/dg/lambda-releases.html) — AWS's release history records the fifteen-minute maximum execution timeout introduced in October 2018.
- [An Agent-Native Cloud Does Not Mean a Faster Horse](https://agentuity.com/blog/agent-native) — Rick Blalock expands on infrastructure designed for agents, including machine-consumable logs, observability and governance.
- [Agentuity platform SDK](https://github.com/agentuity/sdk) — Current Agentuity source repository with CLI tooling, service clients and framework integrations.
- [Agentuity SDK reference](https://agentuity.dev/reference/sdk-reference) — Current documentation for using Agentuity services from application code and supported frameworks.
- [OpenTelemetry traces and spans](https://opentelemetry.io/docs/concepts/signals/traces/) — Official explanation of distributed traces and the spans that describe individual operations.

## Slides

### Conquering Agent Chaos

Rick Blalock of Agentuity introduces a talk about running and deploying agents.

[0:16](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=16s) [Title slide reading Conquering Agent Chaos with the Agentuity logo.](https://assets.ai.engineer/sites/aiecode2025/sha256/44bcaa2c336bcfc3602aca85c8455c713d04943570d2d8246a7b470e727ce7b1.webp)

Conquering Agent Chaos

agentuity

AIE
Microsoft
smol ai

### Building what agents need

Agentuity has been building for agent needs since February. The speaker names memory, improvement and code execution, then chooses a live demo.

[3:17](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=197s) [Slide says that Agentuity has been building what agents need since February.](https://assets.ai.engineer/sites/aiecode2025/sha256/af4e3b19f5251c7b9c1a9097e3144498a1ca37f4e25728d01f12acb7b7f7b05b.webp)

Since February, we’ve been building what agents need

agentuity

Interface text:
AIE
aws

### Starting an Agentuity project

The presenter runs agentuity create to start a project; the CLI begins loading templates.

[4:00](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=240s) [Terminal shows the Agentuity create command and a loading templates message.](https://assets.ai.engineer/sites/aiecode2025/sha256/71b9c05e3ea466190daef662ddd038ff2a56c9f2ddb2993bb03a36d81f660133.webp)

agentuity/agents/demos
❯ agentuity create

Agentuity Agent Cloud
Loading templates...

Interface text:
agentuity

### Select a runtime

The presenter selects Bun from three runtime options. The Python option pairs Python with uv.

[4:06](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=246s) [Project creation wizard offers Bun, Node.js and Python with uv, with Bun selected.](https://assets.ai.engineer/sites/aiecode2025/sha256/317b807a948caf7d025b08a31648c830bf78ba38b3114ae8ba123c15a402a960.webp)

Create New Agentuity Project

Select Runtime:

Choose the runtime environment for your project

> Bun
Bun is a fast, modern runtime for TypeScript.

Node.js
Node.js is a runtime for JavaScript and TypeScript.

Python + uv
Python with uv, the extremely fast Python package and project manager.

↑ up • ↓ down • pgup/pgdn scroll • ctrl+c quit

Interface text:
agentuity

### Select a template

After choosing Bun, the presenter selects Vercel AI SDK + Groq as the starting template. Mastra is another visible option.

[4:20](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=260s) [Project creation wizard highlights the Vercel AI SDK and Groq template and also shows Mastra.](https://assets.ai.engineer/sites/aiecode2025/sha256/69cb9faeccd62b2265f0b20ecfc9f200d62da8b4abb124ecf410cd4db8a32a47.webp)

Create New Agentuity Project

Select Template:

Choose a framework template for your Bun project

Vercel AI SDK is a TypeScript SDK for building AI powered applications. This template adds the Google provider.

> Vercel AI SDK + Groq
Vercel AI SDK is a TypeScript SDK for building AI powered applications. This template adds the Groq provider.

Mastra
Mastra is a TypeScript agent framework that provides primitives to build AI applications and features.

↑ •
○ ● ○ ○ ○

↑ up • ↓ down • pgup/pgdn scroll • ctrl+c quit

Interface text:
agentuity
+

### Create New Agentuity Project

The demo names a project and its initial agent. A project groups agents; for this demo, the presenter selects no authentication instead of a project or agent API key.

[5:05](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=305s) [Project creation wizard shows a project name, availability confirmation and optional description field.](https://assets.ai.engineer/sites/aiecode2025/sha256/ca0291f3c25f1acb7df1786babb7e8a874edd08a84609e3f4a829a85dcdd8ad2.webp)

Create New Agentuity Project

Project Details:
Enter your project details

Project Name (required)
> ProjectHello
✓ name is available

Description (optional)
> A cool project using...

○ ○ ● ○ ○

↑ up • ↓ down • enter/→ next • ctrl+c quit

Interface text:
agentuity

[5:16](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=316s) [Agent configuration form with a name, description, and authentication options.](https://assets.ai.engineer/sites/aiecode2025/sha256/b1b7baf32c61e2783d6898344e06ab9eee39f520b7a435845750c57810061197.webp)

Create New Agentuity Project

Agent Details:
Configure your initial agent

Agent Name (optional)
> Agent1Hello

Agent Description (optional)
> An agent that does...

Authentication
[•] None    [ ] Project API Key    [ ] Agent API Key

○ ○ ○ ● ○

↑ up • ↓ down • ←/→ select • enter confirm • enter/→ finish • ctrl+c quit

Interface text:
agentuity

### Deployment options

The wizard highlights GitHub App alongside GitHub Actions and manual deployment. The presenter says a GitHub integration can automatically deploy the project when changes merge to main.

[5:49](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=349s) [Deployment options showing GitHub Action, GitHub App, and no integration.](https://assets.ai.engineer/sites/aiecode2025/sha256/39c66d80415c35d595ed0d5e97b3d660dee26b1eae59a817eed95d6361f6b5ea.webp)

Create New Agentuity Project

Deployment Options:

Choose how you want to deploy your project

GitHub Action
Deploy using GitHub Actions workflow for automated deployment and CI/CD integration.

> GitHub App
Deploy using a GitHub App for enhanced security and seamless integration with repositories.

None
Skip GitHub integration and configure deployment manually later.

○ ○ ○ ○ ●

↑ up • ↓ down • ←/esc back • ctrl+c quit

Interface text:
agentuity

### Testing an agent in Dev Mode

The presenter tests an agent with a question about Groq streaming. Its response appears beside the prompt, while the Sessions table is empty.

[7:06](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=426s) [Dev Mode shows an agent prompt, a partially generated response, and an empty sessions table.](https://assets.ai.engineer/sites/aiecode2025/sha256/6cd74eb09214555e9655f7285d02f39979a7064e05b1dde441ebb03df715cfa4.webp)

How do I implement streaming responses with Groq?

Groq is a query engine that allows you to execute SQL-like queries on large datasets. However, it does not natively support streaming responses.

To implement streaming responses with Groq, you would typically need to use a combination of Groq and a streaming library in your programming language of choice. Here's a general outline of the steps you could follow:

Step 1: Choose a Programming Language and Streaming Library

Select a programming language that you're comfortable with and a streaming library that supports it. Some popular options include:
• Python with asyncio and aiohttp for asynchronous HTTP requests
• Java with java.nio and java.util.concurrent for asynchronous I/O
• Node.js with stream and

Interface text:
app.agentuity.com/devmode/[illegible]
Agentuity Demo
Dashboard
Projects
Agents
Sessions
Deployments
Services
Logs
Settings
Dev Mode
CLI Connected
https://dev-[illegible].agentuity.run/[illegible]
Text
Agent1Hello
Run
Sessions
Logs
Filters
Search by ID...
Status
Agent
Duration
Total Cost
Started
No Sessions Available

### Inspecting Dev Mode logs

After running the agent, the Logs tab shows POST requests alongside server startup and agent registration events. The presenter notes that logs are also available in the terminal.

[7:27](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=447s) [Dev Mode displays the agent response above a table of request and server logs.](https://assets.ai.engineer/sites/aiecode2025/sha256/c860e18398453486cd9cc97de8f1907fa616e0834502f07cff6c6fe9dd6995d1.webp)

How do I implement streaming responses with Groq?

Groq is a query engine that allows you to execute SQL-like queries on large datasets. However, it does not natively support streaming responses.

To implement streaming responses with Groq, you would typically need to use a combination of Groq and a streaming library in your programming language of choice. Here's a general outline of the steps you could follow:

Step 1: Choose a Programming Language and Streaming Library

Select a programming language that you're comfortable with and a streaming library that supports it. Some popular options include:
- Python with asyncio and aiohttp for asynchronous HTTP requests
- Java with java.nio and java.util.concurrent for asynchronous I/O
- Node.js with stream and express for asynchronous HTTP requests

Logs
Time | Level | Source | Message
Less than a minute | DEBUG | ProjectHello | request: POST /agent_[illegible]
Less than a minute | DEBUG | ProjectHello | request: POST /agent_[illegible]
1 minute ago | INFO | ProjectHello | Bun server started on port 3500
1 minute ago | INFO | ProjectHello | registered Agent1Hello at /agent_[illegible]
1 minute ago | DEBUG | ProjectHello | connected to Agentuity Agent Cloud

Interface text:
app.agentuity.com/devmode/[illegible]
Agentuity Demo
Dashboard
Projects
Agents
Sessions
Deployments
Services
Logs
Settings
Dev Mode
CLI Connected
https://[illegible].agentuity.run/[illegible]
Text
Agent1Hello
Run
Sessions
Logs
Filters
Search log messages...

### Viewing agent sessions

Dev Mode lists two successful Agent1Hello sessions, with durations of 8ms and 17ms. The presenter introduces sessions as a way to inspect agent observability.

[7:37](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=457s) [Dev Mode shows two successful agent sessions with their durations and costs.](https://assets.ai.engineer/sites/aiecode2025/sha256/504304d7b8f20135f197805fde91a6a0f697b08fd36e093105d4d9dbc290bb33.webp)

How do I implement streaming responses with Groq?

Groq is a query engine that allows you to execute SQL-like queries on large datasets. However, it does not natively support streaming responses.

To implement streaming responses with Groq, you would typically need to use a combination of Groq and a streaming library in your programming language of choice. Here's a general outline of the steps you could follow:

Step 1: Choose a Programming Language and Streaming Library

Select a programming language that you're comfortable with and a streaming library that supports it. Some popular options include:
• Python with asyncio and aiohttp for asynchronous HTTP requests
• Java with java.nio and java.util.concurrent for asynchronous I/O
• Node.js with stream and express for asynchronous HTTP requests

Sessions
Status | Agent | Duration | Total Cost | Started
OK | Agent1Hello | 8ms | $0.00000 | Less than a minute
ID e4e740
OK | Agent1Hello | 17ms | $0.00000 | Less than a minute
ID 196b1e

Interface text:
app.agentuity.com/devmode/6b3a0b6d2b5ac262
Agentuity Demo
Dashboard
Projects
Agents
Sessions
Deployments
Services
Logs
Settings
Dev Mode
CLI Connected
https://dev-bb8oucf7b.agentuity.run/[illegible]
Text
Agent1Hello
Run
Sessions
Logs
Filters
Search by ID...

### Session trace timeline

The session timeline nests streaming operations under Agent1Hello, with an AI gateway call inside them. The gateway took 283 ms in a 1.543 s session.

[7:43](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=463s) [A session detail view shows nested agent, streaming, and gateway operations on a timeline.](https://assets.ai.engineer/sites/aiecode2025/sha256/5c3de22b6cdb3546860f72bcad6e5ebd50db7082f07b66cc0229a5a91febc33a.webp)

Session ID
sess_be4df4d2c5a7b4698996ff4f39e4e740

Status: OK
Total Spans: 4
Total Duration: 1.543s
Start Time: 6/5/2025, 1:10:11 PM

Data for this session is still being processed. Refresh to view the latest available data.
Refresh

Timeline
Legend: Root, API/HTTP, AI Services, Vector, KV, LLM, Other
Operation | Duration
Agent1Hello | 1.543s
  ai.streamText | 1.538s
    ai.streamText.doStream | 1.536s
      ai.gateway | 283ms

Interface text:
app.agentuity.com/devmode/6b3a0b6d2b5ac262

### Inspecting a gateway span

The ai.gateway span shows a 283ms call using llama-3.1-8b-instant, with token costs and HTTP status. The speaker says the same observability works in production.

[7:49](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=469s) [A gateway span details panel lists model, cost, project, and HTTP information.](https://assets.ai.engineer/sites/aiecode2025/sha256/36c04ca187357d369f7726cfedf8dfed3708da14c1b7915fc26cc4877ed7a3d0.webp)

Span 7bc8ce225f6c26ca

Operation: ai.gateway
Project: ProjectHello
Duration: 283ms

Metadata

Agentuity
Deployment: 6b3a0b6d2b5ac262
Dev Mode: true
Org: [illegible]
Project: [illegible]
SDK Version: 0.0.121
View Logs

LLM
Cost: $ 0.00000000
Input Cost Per Token: $ 0.00000030
Input Tokens: 0
Mode: chat
Model: llama-3.1-8b-instant
Output Cost Per Token: $ 0.00000120
Output Tokens: 0

Project
Name: ProjectHello
Version: 0.0.1

HTTP
Host: agentuity.ai
Method: POST
Path: /gateway/groq/chat/completions
Status Code: 200
URL: https://agentuity.ai/gateway/groq/chat/comple...

Background:
Timeline
Operation
Duration
[illegible]

Interface text:
app.agentuity.com/devmode/6b3a0b6d2b5ac262

### Development server logs

The terminal shows two agent requests completing before the development server shuts down. The speaker then moves on to deploy the agent.

[10:11](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=611s) [Terminal showing agent development-server requests and shutdown.](https://assets.ai.engineer/sites/aiecode2025/sha256/dc5dd178606152aa6da2ab4d0f9b896b4fd51b4661711d017f232e9a00c6b39b.webp)

ProjectHello main
❯ agentuity dev

[DEBUG] connected to Agentuity Agent Cloud
[INFO] registered Agent1Hello at /agent_8f912b6be85fb8211a9633cf12fbbbe5
[INFO] Bun server started on port 3500
[INFO] 🚀 DevMode ready
[DEBUG] request: POST /agent_8f912b6be85fb8211a9633cf12fbbbe5
[INFO] processed sess_cc7b17250712269d6c5a088012196b1e in 2.002525375s
[DEBUG] request: POST /agent_8f912b6be85fb8211a9633cf12fbbbe5
[INFO] processed sess_be4df4d2c5a7b4698996ff4f39e4e740 in 1.54675875s
^C[DEBUG] server stopping
[INFO] server stopped
[DEBUG] shutting down OpenTelemetry
[DEBUG] shut down OpenTelemetry
^[i

ProjectHello main 1m50s
❯ ^P^[[200~nvim .^[[201~
nvim .

Interface text:
...nts/demos/ProjectHello
1m59s

### Project deployment overview

After deploying the Bun-based agent, ProjectHello shows a completed, active deployment alongside a sessions chart for the last 30 days.

[10:35](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=635s) [Project dashboard showing an active deployment and sessions chart.](https://assets.ai.engineer/sites/aiecode2025/sha256/48bb4c47ed9e35bfaafa555ce3c683035ca797e3f8fb04e350dd4cd6414b193a.webp)

ProjectHello
proj_3ab47590454aa8b966cd870ea730ff0a

Latest Deployment
View All →
Status
Completed  Active
Deployed By
Rick Blalock
Origin
71ac28e  main
[chore] Initial commit 🐳
Created
Jun 5, 2025, 1:13 PM

Sessions per Day (Last 30 Days)
View All →

Interface text:
app.agentuity.com/projects/proj_3ab47590454aa8b966cd870ea730ff0a
Agentuity Demo
Dashboard
Projects
Agents
Sessions
Deployments
Services
Logs
Settings
ProjectHello
Project
Agents
Sessions
Deployments
Logs
Settings

### Project agents

ProjectHello’s Agents tab lists the one agent created in the demo, Agent1Hello, with $0.00 total cost. The speaker notes that a project can contain multiple agents.

[10:43](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=643s) [Project agents tab listing one agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/d5ebe8ffaf4cb72e2a8b120814d570ed9b1622433a1491d744f50992bf2aa6f0.webp)

Name | Description | Total Cost | Created
Agent1Hello | | $0.00 | 4 minutes ago
ID fbbbe5

Interface text:
app.agentuity.com/projects/[illegible]/agents
Agentuity Demo
Dashboard
Projects
Agents
Sessions
Deployments
Services
Logs
Settings
ProjectHello
Project
Agents
Sessions
Deployments
Logs
Settings

### Agent details and usage

The agent page combines deployment details and cost metrics with an input/output diagram. The presenter opens the input menu and describes giving the agent an email address.

[10:49](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=649s) [Agent detail page showing status, input visualization, cost and usage.](https://assets.ai.engineer/sites/aiecode2025/sha256/393bbd71baf84dcb177c048a7747ef4004e48ab0f9a4aaaa798e47d7366bb65f.webp)

Agent1Hello
agent_[illegible]

Status
Active

Created
Jun 5, 2025, 1:08 PM

Last Updated
Jun 5, 2025, 1:13 PM

Last Deployed
Jun 5, 2025, 1:13 PM

Runtime
Bun

LLM Models
llama-3.1-8b-instant

IO Visualization
Limit of 1 inbound webhook

Cost & Usage
Total Cost: $0.00000
LLM Cost: $0.00000
Input Tokens: 0
Output Tokens: 0

Recent Activity
Sessions
Logs
Storage
AI Gateway
Status
Agent
Duration
Total Cost
Started

Interface text:
View Project
app.agentuity.com/projects/[illegible]/agents/[illegible]

### Session memory error

The webhook-created session fails after exceeding 263Mi of memory. The speaker says the memory setting needs changing in the YAML file.

[12:15](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=735s) [A session page shows an error indicating that the memory limit was exceeded.](https://assets.ai.engineer/sites/aiecode2025/sha256/2e800448a27c9a186cac07c194578dcd2b1620638bda6bc6f1914edbf1f60254.webp)

Session ID
sess_ebe9d420dfe041dd857d64e3a8b413c6

Status: Error
Total Spans: 1
Total Duration: —
Start Time: 6/5/2025, 1:14:44 PM

out of memory error (exceeded 263Mi)

Interface text:
app.agentuity.com/projects/proj_3ab47590454aa8b966cd870ea730ff0a/sessions/sess_ebe9d420dfe041dd857d64e3a8b413c6

### Project integrations

The project page offers configuration for cron, webhooks, API, email and SMS. GitHub connects through Settings.

[12:35](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=755s) [Project integrations page showing options for cron, webhooks, API, email, SMS, and GitHub.](https://assets.ai.engineer/sites/aiecode2025/sha256/512ca6539adebed18004fff9fe577e7ddab06b00e8dd84ff37c60161f81660b7.webp)

Project Integrations
Connect ProjectHello with external services for enhanced functionality.

Cron
Establish cron jobs for automated tasks.
Configure

Webhook
Connect external systems using webhooks.
Configure

API
Connect external systems using REST APIs.
Configure

Email
Enable email communication to agents.
Configure

SMS
Enable SMS communication to agents
Configure

GitHub
Link a GitHub repository for automated deployments.
Connect in Settings →

Interface text:
app.agentuity.com/projects/proj_3ab47590454aa8b966cd870ea730ff0a/settings/integrations
Agentuity Demo
Dashboard
Projects
Agents
Sessions
Deployments
Services
Logs
Settings
ProjectHello
Project
Agents
Sessions
Deployments
Logs
Settings
Env & Secrets
Integrations

## Full transcript

[0:00](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=0s) [upbeat music] My name's Rick Blalock.

[0:16](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=16s) I'm from Agentuity, and, uh, that you're all wearing the, the logo around your necks. So stop by our booth, please. But, uh, today I wanna talk about, um, conquering agent chaos.

[0:25](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=25s) But really, I'm talking about deployment, running and deploying agents. Um, and just to give you an example, I was, uh, I was at University of Florida. I'm from South Florida, and I was at University of Florida about a month and a half ago, and I was talking to a bunch of professors and their students on projects that

[0:41](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=41s) they were deploying. Almost all of them were working on some type of agents in their class projects. And, uh, I asked all of them, "What was the number one problem?"

[0:49](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=49s) They all said, including the professors, "Deploying agents." And, um, they... Sim- similar problems that I, I had before we, we started Agentuity, which was like you, you build this thing, you deploy it on serverless.

[1:00](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=60s) In their case, they were using AWS Lambda, and then they, you know, timeouts, right? [laughs] "Uh-oh, my agent runs for fifteen minutes," or, "My agent runs for thirty minutes."

[1:09](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=69s) We have an internal agent at Agentuity that runs for forty minutes a day, something like that. So they're running into that, and then, uh, they weren't allowed to use VMs or EC2 for their projects, so, uh, for obvious reasons. [laughs]

[1:20](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=80s) You don't want a s- bunch of students running EC2s. And, um, a bunch of other things are running into the gateway issues, you know, wiring up agents, talking to agents and things like that.

[1:30](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=90s) So it's very, very common thing. And the other one is, you know, the whole web is built, like, for a stateless type concept, right? Agents are not stateless necessarily.

[1:39](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=99s) They're stateful in a lot of cases. Um, and so those are the deployment headaches that I was hearing over and over with the students, and that mapped to a problem I had about a year ago building a qualitative research agent, set of agents.

[1:51](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=111s) Same thing. I built it on serverless not thinking, and then I realized, "Ah, crap, I gotta rearchitect this whole thing," 'cause it's doing synthesis and it takes a while.

[1:59](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=119s) Very common he- um, headaches. Has, has anybody experienced that headache before? I'm curious. Yeah? Deploying agents? So that led us to talk about, like, well, what do, what do agents need to be successful?

[2:12](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=132s) So they need to li- they need to run as long as they need to run, um, and they need to be able to pause and stop and resume. They also have, de- decoupled from your code, they need to have different inputs and outputs and, um, actually multiple, various ones, right?

[2:28](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=148s) We... I, I think we understand that, hopefully. And then I put this up here: introspection, self-observability and self-reflection. They need those two. Um, and we have that in the product.

[2:38](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=158s) We have, like, OTel tracing things. Um, hopefully you've all seen that, some of those types of things where you're doing introspection and, and traces across. But I put self-observability and self-reflection here 'cause this is important.

[2:50](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=170s) So the, the, the observability things that we're used to are human-based, where we see, like, these traces and spans, and, um, the agents need to understand that as well.

[3:00](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=180s) There's a, there's a, there's a difference there. There's a nuanced difference there. And of course, it needs memory. It needs to get better, evolution, code execution. So that's what agents need to be successful.

[3:09](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=189s) And so when I was, again, talking to those UF students, personal experience, um, we need those things, and that's what we started to build at Agentuity. And so I just wanna give you a demo.

[3:20](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=200s) I'm trying to decide, should I do a live demo or should I do the, the slides just in case? I don't know. Uh- Live. Live? Everybody says live? Yeah.

[3:27](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=207s) Y'all just wanna watch the train wreck. [laughs] All right. We'll, we'll try it live. So I'll... Wow. It's all live. Live. Wow. Yeah, it is. All right. We'll do that.

[3:38](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=218s) So, um, I'm gonna... Let's do this. Let's do this. Let's blow this baby up. Can you see this okay? Yeah. Yeah. All right. Good. I was told I had to do it in light mode because that's what you do, so.

[3:52](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=232s) Um, all right, so we have a CLI. So if you're gonna start, you run agentuity create to create a project. Um, when you run it, drum roll... Okay, in this case, I'm logged into a bunch of organizations, so I'm gonna do our Agentuity, uh, demo one.

[4:08](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=248s) We have three runtimes that we support: Bun, Python with uv. You notice we, we put uv. We're trying to bias people towards uv. Please don't use pip. Um, [laughs] and then Node.js, of course.

[4:18](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=258s) So those are our three runtimes. I'm gonna pick Bun.

[4:22](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=262s) And then, uh, you can pick several templates, um, th- as a starting place. Now we're, we're, uh, framework agnostic. You notice there's Mastra here. Mastra's pretty good if you're going down the TypeScript route.

[4:33](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=273s) Um, I'm, I'm gonna pick Vercel AI SDK and Groq. I, a lot of our stuff internally, we have 50 agents or so, and they're... We don't use a framework.

[4:41](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=281s) Um, but we're framework agnostic, so you can bring CrewAI and then deploy another one in LangChain, another one in Pydantic, and then Vercel, a- and then they can all talk to each other.

[4:51](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=291s) Um, internal networking, talk to each other and that kind of thing. We'll show you that here in a minute.

[4:55](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=295s) I'm trying to leave enough time so we can have questions and answers. So I'm gonna pick Vercel AI SDK with Groq. Honestly, that's my favorite combo with Bun 'cause of the speed.

[5:03](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=303s) It's amazing. Um, and then I'm gonna name a project. Let's just call that project Hello. A project is a grouping of agents. It's also, um... You can think of it as like a one-to-one to a repo, 'cause you can hook it up to GitHub.

[5:17](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=317s) An agent, again, multiple agents in a project. You get your default one here, so let's just call this, uh, agent-1-hello. Uh, very creative name. Now, one of the things we give you...

[5:27](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=327s) Agents are a first-class citizen. Again, back to deployment problems. Agents are a first-class citizen, infras- infrastructure citizen, um, in Agentuity. So that means we handle all the routing and all that to that agent, and you can decide how you want to protect it.

[5:41](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=341s) So you can protect it via the whole project. Each agent in your project can have an API key. I'm gonna do none right now 'cause it's a demo.

[5:50](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=350s) There's more to that, but, um, I'll skip over that right now. Then you can hook it up to GitHub, uh, so then if you merge to main, it'll automatically deploy your project.

[5:59](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=359s) And that's it. So then we create this. I'll show you the code here in a second. I'm gonna show you dev mode real quick, and then I'll, we'll, we'll do the code.

[6:05](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=365s) All right. So- Rock and roll. So let's do Project Hello. And before I show you the code,

[6:13](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=373s) we have now this Vercel AI SDK Bun, you know, Groq template, right? So we have this command that you can run any of your agents with, agentuity dev. If you have multiple projects, you can run them and then they'll have, they'll have, uh, ports assigned to them.

[6:27](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=387s) And so now we're running this locally, as you would expect. Very... What you're n- used to, I'm sure. But, um, one of the things I wanna, I wanna show you is...

[6:36](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=396s) So this is the, is routing to the agent. We only have one agent, so that's the, that's the agent ID. But we have this public routing, so we do tunneling for you.

[6:44](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=404s) So if you wanted to hit it through another service or something while you're deving, you can do this, uh, publicly too. All right. But let me just show you the dev mode real quick.

[6:52](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=412s) So, um, click this. This... Oh, of course I got logged out. Ugh. [laughs]

[7:04](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=424s) Who expired the token? Um, okay. So, um, we give you, like, this kinda simulator for your agent. Um, some agents don't take just text, right? So you can, you can pick JSON, HTML, you can...

[7:17](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=437s) PDFs. Um, actually, we do emails and things like that too. That's not in this dev mode. But this is where you can interact with your agent, test it out, and then when you do that...

[7:26](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=446s) Like, I'm just gonna run it a few times. What? I'm sorry?

[7:31](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=451s) Somebody say something? Oh, okay. Um, when you do that, you can get your logs. Of course, you can see it in terminal too. Um, you can in- inspect the logs, get more information.

[7:41](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=461s) And then the sessions are back to the... Remember the observability thing? So we have the human version of this here, where you can look and you can see, like, oh, this hit the, this hit our AI gateway, which we have an AI gateway so you don't have to set up keys for any of these models or any

[7:53](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=473s) of these services. And you can get the cost for that call, um, what the prompt was, what the response was and all that. And it... This works in production too.

[8:00](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=480s) It's the, it's a mirror image of production. So that's the dev mode. I don't wanna spend too much time on it 'cause we don't have much time, but that's...

[8:07](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=487s) So put a pin in that. Now I'm gonna kill that, and you're like, "Well, Rick, what does the code look like?" And we're trying not to be too opinionated here, but we do have a few conventions.

[8:17](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=497s) Um, let's do that. Let's do that. Um, so really the conventions we have in a project are you have a YAML file. Surprise. And, um, that's to help configure your agent when it's deployed.

[8:29](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=509s) And then, um, there's an agents folder. Python, it, it works the same way. And, um, you have an entry point, and so this is, this is the simple, simple template that we, we created here.

[8:42](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=522s) And, uh, the entry point in, in this case, in, in JavaScript would be, um, you export a default function, and that's your request handler. If you guys have used Next.js or have used Knatives or whatever, everybody should be familiar with that hopefully.

[8:54](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=534s) But what we do is we handle all that routing that comes into your agent, and we put it on that request object. And so that, that could be an email.

[9:01](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=541s) You can add a email to your agent. You can add a phone number to your agent. You can, uh, send a JSON, a PDF, whatever. We have all those things that we route to it.

[9:08](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=548s) You can stream it. Um, and then also you have, you have things that are, like, first kinda... first class citizens like ctx.get_agent, and then that... And then you can pass in an ID or a name.

[9:19](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=559s) So we have another agent. Maybe it's a Pydantic agent over here, and we can actually get it. We'll get an ephemeral token so it's allowed to talk to it for as long as it runs, and then you can execute it, send it back.

[9:30](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=570s) You can stream it back. There's a bunch of different things you can do here. Um, so that's on this context object. So there's... I'm not gonna spend a lot of time on this right now, but there's a, there's a lot of, like, infrastructure we give you in this really simple handler, um, uh, which is pretty cool.

[9:45](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=585s) All right. And that's it. That's the only convention. So again, like you can imagine if you're using Mastra, and we have a bunch of examples and templates that you can go look at Mastra.

[9:52](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=592s) You're, you create Mastra template... or, uh, models the way you would, you, you would normally do it, and you can drop them in right here. Same thing in Python.

[10:00](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=600s) Um, there's a run function in Python, and that's what you have to declare. And then you can drop in a crew or a couple crews, and then have it call Pydantic two and a never- another agent.

[10:09](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=609s) Um, and that's it. That's, that's, that's the code in a nutshell. Now let's deploy it really quick. YOLO. [laughs]

[10:19](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=619s) All right. And it should... It- Internet's fast, it should upload pretty quick. There, boom. All right. So we took, we took that agent, we wrapped it in a container, a specialized container that's...

[10:29](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=629s) In this case, it's a Bun runtime, and now it's live. So if I, if I click on that and jump to it,

[10:37](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=637s) you can see, um, this is when it was deployed. There's our little happy Bun. And, um, let me show you something really quick that you haven't seen yet. So in a project, again, you have multiple agents.

[10:48](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=648s) I only have one agent that you saw me create. And then this is where you can get, you can get cost breakdown by project, by agent, by run. You saw the session spans.

[10:58](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=658s) So we, we try to surface that up in all different ways to help understand how much an agent is costing. But this is where... Remember when I said you can decouple inputs and outputs from your agent if you want to?

[11:10](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=670s) And this is where I can hit plus here, and I can say, "Hey, I wanna give my agent an email." I hit save, and now I can email my agent.

[11:18](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=678s) So there's the email address right there. And I can do that with SMS. Um, I can do that with APIs. I can do a cron job. Wakes up, does a bunch of things.

[11:28](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=688s) Um, and that's inputs and outputs. So it's a nice way to build an agent, and then if somebody wants to use it, they can hit deploy now from your GitHub repo, drop it in, and like, "Okay, let me wire this email up.

[11:38](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=698s) Let me wire this up. Let me wire..." Later we're gonna get Slack and Discord and all that stuff too. Um, so that's inputs and outputs. Um, actually, let me just go ahead and try to hit this right here.

[11:47](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=707s) So this is our... Remember, we didn't secure it, so it's public. So actually, if you took a picture and hit this, it probably would work. No, don't do that.

[11:54](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=714s) Um, let's just... I don't know if this is gonna work. Hello.

[12:01](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=721s) All right. So I, I hit the webhook. It created this session. There's the session ID. Now it's... The agent's off running, and I should start getting logs here. Got three minutes. [laughs]

[12:14](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=734s) There it is. Oh, it's an error because I probably... Oh, I- okay, so this is in your YAML file, you can change the, uh, the memory and I d- I need to change the memory footprint for this, so it didn't run.

[12:24](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=744s) It's like, nope. That's something we're working on too. So in a nutshell, that is, that's what you get. Of course, you can wire up some integrations and, and, uh...

[12:34](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=754s) Actually, I think I just lost internet. Okay, there we go. There we go. You can wire up some integrations, GitHub, and a bunch of other stuff that's coming. So, um, to k- to kinda wrap up, this is, this was, like, the thing that we wanted to build, not just for everybody, but for us- [laughs] ...

[12:49](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=769s) 'cause we wanted b- we have now 50, 60 agents internally built on this, and it's like finally we're getting really good velocity, and I'm really excited about. So this is our first product in our agent native cloud suite that we plan on working on.

[13:02](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=782s) Um, this summer we're working on, um, infrastructure agents that watch our logs and, uh, surface things that are coming up for, for, um, for developers and us. And, uh, w- we kinda...

[13:12](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=792s) We were joking last night, we should call it AgentDuty, not PagerDuty. Like, the agent's gonna do that stuff [laughs]. [laughs] Uh, right? Exactly.

[13:19](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=799s) It's a thing right there.

[13:19](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=799s) So yeah. So there's a bunch of stuff coming, but that's where we're at right now. Stop by the booth. Um, we got one minute and 50 seconds, so if there's any questions, we got about a minute and 50 seconds.

[13:29](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=809s) Any, any questions? Jokes, stories, anecdotes? Try to leave just enough room. Yes.

[13:37](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=817s) One thing that I've been hearing about recently is the idea of adding tool calls into reasoning. Um, like into the, the reasoning tokens. Um, is that something you've been thinking about at all recently?

[13:50](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=830s) Yeah. Uh-huh. And, and I mean, yeah, for sure [laughs]. Yeah [laughs]. Um,

[13:58](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=838s) the, the... Now there's a, uh, for us, like I said, from a product perspective, there's a thing we always ask ourselves, which is what does an agent need to be successful?

[14:06](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=846s) And, and some of that is what... Like, we wanna offer that as a services layer from an infrastructure services perspective, where a lot of that stuff you just get out of the box, and then you can hook it up to a Vercel AI SDK tool thing, or you can hook it up to something else.

[14:20](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=860s) Like, we, we wanna do some of those kinda service level things.

[14:24](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=864s) Gotcha.

[14:24](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=864s) But I mean, like, on a tactical level, yeah, I, I think it's... I mean, I need them actually for a CRM agent that we're working on, so yeah.

[14:32](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=872s) Cool.

[14:32](https://www.youtube.com/watch?v=yASxPZ-tZe0&t=872s) All right. Thanks everybody for coming. [outro music]
