# Building agents is trivial now, context is the next frontier

Jeff Ng

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/HvMyYLTfvhg-building-agents-is-trivial-now-context-is) · [Video](https://www.youtube.com/watch?v=HvMyYLTfvhg)

## Building agents is trivial now, context is the next frontier

A Linear enrichment agent finds a plausible fix in the code—and recommends repeating an outage. The missing input is the organization’s memory of why that code was disabled.

Familiarity with tool-using agents, issue trackers, and code repositories will help; the TypeScript example illustrates how context enters an agent’s planning step.

### Why an easy-to-build agent can still be confidently wrong

[0:15](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=15s)

What remains difficult when building an agent becomes easy, but its answers are still confidently wrong? Jeff Ng, a founding engineer at Unblocked, starts with that mismatch. He recalls that six months earlier, building a production agent could occupy a team for roughly a quarter. Selecting a model and attaching tools was only part of the work; the surrounding production systems could each amount to a company or a substantial engineering function.

**Durable state** is one of those requirements. Agent runs are long-lived and stateful, while the infrastructure executing them can disappear. A useful checkpoint must preserve message history, tool calls, and the current position in the agent loop. Without those, a crash leaves the service unable to resume the session.

![Slide highlighting checkpoint and state persistence beside the text: Persist agent state across requests, or lose all progress on every crash or deploy.](https://ai.engineer/api/talk-essay-media/5cc0d8c19ad95cb3bd70bacb82e9bfbc54b08a7babc59ebd4bbfdb2760e3ed5d)

Checkpointing preserves agent state across requests, crashes, and deploys.

Restarting is not equivalent to resuming. It repeats token expenditure and makes the user wait through work already performed. It can also repeat side effects: an action taken before the crash may happen again when the run starts over. Persistence therefore protects more than the conversation transcript; it preserves the execution history needed to continue responsibly.

Two other requirements sit alongside persistence:

- **Sandbox isolation:** Agent-generated and third-party code execute on the operator’s infrastructure. Isolated sandboxes help restrict access to environment secrets and unnecessary network destinations, while protecting the shared host.
- **Observability:** When something fails, logs and traces must make it possible to locate the failure across the systems involved.

These are necessary production capabilities, but none gives the agent better knowledge of the task. They are the cost of getting an agent into service.

### Infrastructure primitives shrink the agent definition

[2:56](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=176s)

Cloud infrastructure providers such as Cloudflare, Vercel, and AWS increasingly supply the underlying primitives, while frameworks such as [Flue](https://blog.cloudflare.com/agents-platform-flue-sdk/), [Vercel’s eve](https://vercel.com/blog/introducing-eve), and [Mastra](https://mastra.ai/docs) assemble them into an agent runtime. That moves effort away from supporting infrastructure and toward the logic that serves a team or customer.

Ng’s example combines Flue with Cloudflare. Once the runtime handles the supporting systems, defining an agent becomes a small set of choices:

| Choice | What it determines |
|---|---|
| Model | Which model performs the reasoning |
| Instructions | The agent’s task and system prompt |
| Tools | The operations it can invoke |
| Skills | The capabilities available for its work |
| Sandbox | Where execution takes place |

The compact configuration is meaningful because the runtime supplies the machinery behind it. It does not, by itself, supply the facts the agent needs to make a correct decision.

![Agent Runtime slide with nine checked infrastructure responsibilities and an enlarged code excerpt showing model, instructions, tools, skills, and sandbox configuration.](https://ai.engineer/api/talk-essay-media/6521f26c728df90edb93ee376eab7294f428a5251c8ffd85a552c1b60466fb1f)

Agent configuration alongside nine infrastructure responsibilities handled by Flue on Cloudflare.

### The code suggests a fix that repeats an outage

[4:25](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=265s)

The demonstration is a Linear issue enrichment agent with access to a code repository. Its workflow is straightforward:

1. Fetch the Linear ticket.
2. Determine whether it describes a feature or a bug.
3. Search the repository for relevant code.
4. Pass the findings to the agent.
5. Produce a plan of next steps.

This is a useful background task: turn a short issue report into something an engineer can act on.

The input is a support engineer’s report about degraded responsiveness in the internal agentic QA pipeline. Ng reports time to first character of three to four seconds, against an expected hundreds of milliseconds. That is the incident’s reported symptom, not a measured comparison between agent frameworks.

The agent fetches the ticket, uses its code retrieval and search capabilities, reasons over the results, and writes a recommendation back to Linear: re-enable async dispatch. The reasoning sounds sensible. Async dispatch allows more QA pipeline work to run in parallel on a single machine, so enabling it appears to address the latency problem.

But async dispatch had caused an outage a few days earlier. A support engineer had explicitly disabled it before this ticket was presented. The agent has successfully completed its workflow and updated the issue, yet its proposed fix would reverse an intentional operational decision. **A plausible explanation of the code is not enough to establish that a change is safe.**

### The missing input was the team’s history

[6:10](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=370s)

The missing evidence lived outside the repository and the current ticket. Engineers had discussed the outage in Slack: what went wrong, what fixed it, and what should happen next. That discussion also produced a Linear postmortem ticket. Neither source was part of the enrichment agent’s input. The agent could inspect the implementation without seeing the explanation for its current state.

This becomes especially dangerous in a background agent. There may be nobody watching the recommendation appear, so missing organizational knowledge becomes a silent failure. The resulting ticket can misinform teammates and potentially other agents that later treat it as context.

Interactive coding sessions often conceal this dependency because the engineer supplies the missing context turn by turn. The person asks questions, catches errors, adds facts, and steers. They know why the code looks the way it does, what broke previously, and what the team decided afterward. The agent has only its instructions, its supplied tools and skills, the code, and the ticket in front of it.

![The human was the missing piece slide contrasts human knowledge of decisions, ownership, and history with the agent's instructions, tools, code, and ticket.](https://ai.engineer/api/talk-essay-media/c03f1425af60cfc0c5fa06d29396a24f0ad1d948c7d6915095ab6e24dab0019a)

The human supplies history and intent that the agent lacks.

Removing the human from the loop also removes that source of history and intent. Easier deployment makes unattended agents more common, but it does not replace the knowledge their users were quietly contributing. Something else has to carry that responsibility.

### From connected sources to actionable context

[8:14](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=494s)

Ng calls the replacement a **context engine**: a system that provides task-relevant information, accounts for the identity and access roles of the person or agent asking, and reconciles conflicting sources. Its output should be a synthesized understanding the agent can act on, rather than a list of documents it must independently interpret.

The inputs extend beyond source code because engineering work does too. Slack contains decisions; documentation contains best practices; tickets record problems and follow-up work. The context engine connects documentation, code, tickets, and conversations, then builds a model of how the organization and its systems fit together. For a particular task, it returns a slice of that model that has been reconciled, ranked, and scoped to permissions. The intended transformation is from scattered information to grounded context.

Why not simply connect Slack, Linear, and GitHub through MCP? Those connectors make the sources accessible, but separate source results still leave the agent responsible for deciding what to believe. The distinction is between retrieving information and preparing it for a decision:

| Responsibility | Separate source connectors | Context engine |
|---|---|---|
| Retrieval | Return source results | Gather relevant evidence |
| Relevance | Agent filters the results | Return a ranked task-specific slice |
| Conflicts | Agent reconciles sources | Reconcile before delivery |
| Output | Results to interpret | Synthesized understanding |

In Ng’s account, irrelevant results consume context-window space and increase context costs. When Slack and Linear disagree, the local agent must resolve that disagreement ad hoc.

This is a distinction between system responsibilities, not a restriction of MCP: [Unblocked itself serves synthesized context through MCP](https://docs.getunblocked.com/unblocked-mcp/mcp-overview). Two implementation boundaries matter. Its [later architecture explanation](https://getunblocked.com/blog/inside-the-unblocked-context-engine/) allows unresolved disagreements to be surfaced rather than silently settled. Permission scoping also depends on authentication and configuration: [current installation guidance](https://docs.getunblocked.com/unblocked-mcp/install-other) warns that a token-based connection can expose team-source documents, including private Slack content. A connector alone therefore guarantees neither reconciliation nor the intended access boundary.

### Repeat the task with the outage history included

[10:32](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=632s)

Ng returns to the same file and the same agent, now with the context engine connected. The additional step asks Unblocked to research the Linear ticket before the agent completes its reasoning. During the repeated run, the context engine finds the relevant Linear postmortem and the Slack conversation containing the engineering discussion. It returns a synthesized summary to the agent, so the agent no longer has to reconstruct that history from the source documents itself.

The integration boundary can be expressed in TypeScript as a function that assembles the inputs to planning. Here, `researchContext` represents the context service and `proposeNextSteps` represents the agent; neither is a particular SDK method. The important dependency is that planning receives organizational context alongside the ticket and code findings:

```typescript
type Ticket = {
  id: string;
  description: string;
};

type EnrichmentServices = {
  fetchTicket(id: string): Promise<Ticket>;
  searchCode(ticket: Ticket): Promise<string>;
  researchContext(ticket: Ticket): Promise<string>;
  proposeNextSteps(input: {
    ticket: Ticket;
    codeFindings: string;
    organizationalContext: string;
  }): Promise<string>;
};

async function proposeIssueEnrichment(
  ticketId: string,
  services: EnrichmentServices,
): Promise<string> {
  const ticket = await services.fetchTicket(ticketId);
  const [codeFindings, organizationalContext] = await Promise.all([
    services.searchCode(ticket),
    services.researchContext(ticket),
  ]);

  return services.proposeNextSteps({
    ticket,
    codeFindings,
    organizationalContext,
  });
}
```

For the async-dispatch ticket, the additional input carries the outage discussion and postmortem that were missing from the first run. This function returns a proposal; publishing it to Linear is a separate operation.

The demonstrated recommendation then changes. Ng describes the revised advice as preventing another outage instead of causing one. The demonstrated result is a changed recommendation, not a production fix with a measured outcome. What changes the decision is the newly available history of the system, rather than a different model or a different repository.

### Institutional knowledge beyond ticket enrichment

[11:53](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=713s)

Ticket enrichment is one application of the same underlying requirement. Ng extends it to several other workflows:

- **Coding plans:** Supply organizational context to Claude Code or Codex before the agent proceeds with its plan. Ng claims this can save context and tokens, without providing measurements.
- **Code review:** Give the reviewer the history and intent that would inform an experienced teammate’s review.
- **Customer success and sales:** Surface answers grounded in the organization’s knowledge for people responding to customers.

The application slide also includes code generation, triage operations, and incident management. Across these uses, the shared input is institutional knowledge that is difficult to recover from the immediate task alone.

![Slide with six cards covering agent plans and code, code generation, triage operations, incident management, code review, and customer success and sales.](https://ai.engineer/api/talk-essay-media/7145795b7ab259dc03d2f9e7fd7bae1236f4f4097dfbc12f93cecec9c66e125b)

Six uses for a context layer beyond ticket enrichment.

An agent can have the tools to inspect a system and still lack the reason that system was built—or deliberately changed—that way. As deployment becomes easier, supplying that reason becomes a larger part of making unattended agents useful. Ng closes with the distinction his demonstration makes concrete: “The gap isn't intelligence, it's context.”

## Resources

- [Introducing eve](https://vercel.com/blog/introducing-eve) — Vercel's introduction to its agent framework, covering durable sessions, isolated execution and human approvals.
- [Flue and Cloudflare's agent infrastructure](https://blog.cloudflare.com/agents-platform-flue-sdk/) — Explains how Flue combines declarative agent definitions with Cloudflare's execution and storage primitives.
- [Deploy Flue agents to Cloudflare](https://flueframework.com/docs/ecosystem/deploy/cloudflare/) — Deployment walkthrough covering Workers, Durable Object sessions and sandbox configuration; updated July 2026.
- [Unblocked MCP documentation](https://docs.getunblocked.com/unblocked-mcp/mcp-overview) — Installation guidance and the current tools for retrieving organizational context and synthesized answers with citations.
- [Inside the Unblocked context engine](https://getunblocked.com/blog/inside-the-unblocked-context-engine/) — A later technical explanation of retrieval scoping, expertise signals, conflicting sources and permission enforcement.
- [Mastra documentation](https://mastra.ai/docs) — Official starting point for building agents with Mastra.

## Slides

### Your Agents Lack Context

Jeffrey Ng argues that building agents has become easier, but they still get things confidently wrong. He identifies context as the next frontier.

[0:13](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=13s) [Title slide stating that building agents is trivial and context is the next frontier, presented by Jeffrey Ng.](https://assets.ai.engineer/sites/aiecode2025/sha256/3d2c7fe6dd8d3de91d2dbb77786d2dd1ec8e4a6901c2cd49143cef72e13cede4.webp)

YOUR AGENTS LACK CONTEXT

Building agents is trivial now.
Context is the next frontier.

Jeffrey Ng

Unblocked

### What It Takes to Build an Agent: Six Months Ago

Six months earlier, building an agent took a team roughly a quarter, Jeff says. The work extended beyond models and tools to production infrastructure, from session management to debugging.

[0:25](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=25s) [A list of nine agent infrastructure requirements, from session management through replay and debugging.](https://assets.ai.engineer/sites/aiecode2025/sha256/e7ddadc6fe4e0c050c8b4199736137b03f47e5fe8be9f6088eac492933629a81.webp)

What it takes to build an Agent
6 months ago...

• Session management
• Checkpoint / state persistence
• Orchestration
• Retry logic
• Sandbox infrastructure
• Execution isolation
• Observability
• Multi-chanel adapters
• Replay and debugging

Unblocked

### Checkpoint and State Persistence

Persisting message history, tool calls, and loop position lets an agent resume after a crash. Restarting can add latency and repeat side effects.

[0:58](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=58s) [The requirements list highlights checkpoint and state persistence, explaining that agent state must persist across requests to avoid losing progress.](https://assets.ai.engineer/sites/aiecode2025/sha256/4e78da040299dc4fa777583ca550ed8da79213afc61f31eda80059104303c914.webp)

What it takes to build an Agent
6 months ago...

• Session management
• Checkpoint / state persistence
• Orchestration
• Retry logic
• Sandbox infrastructure
• Execution isolation
• Observability
• Multi-chanel adapters
• Replay and debugging

Persist agent state across requests, or lose all progress on every crash or deploy.

Unblocked

### Sandbox Infrastructure

Six months ago, sandboxing meant writing isolation or managing Docker container lifecycles. The speaker says isolation limits access to secrets and networks and protects the shared host.

[1:59](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=119s) [The requirements list highlights sandbox infrastructure and describes managing isolation or Docker container lifecycles.](https://assets.ai.engineer/sites/aiecode2025/sha256/8275c4d37ac27c232838f46f5357910d2d31c56990ec9cad8ed04d0206393748.webp)

What it takes to build an Agent
6 months ago...

• Session management
• Checkpoint / state persistence
• Orchestration
• Retry logic
• Sandbox infrastructure
• Execution isolation
• Observability
• Multi-chanel adapters
• Replay and debugging

Write your own isolation, or shell out to Docker container and manage their lifecycle yourself

Unblocked

### What It Takes to Build an Agent Today

Cloud infrastructure primitives and frameworks such as Flue, Vercel Eve, and Mastra remove much of the setup complexity, letting developers focus on agent logic.

[2:57](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=177s) [A slide displaying the names and logos of Flue, Vercel Eve, and Mastra.](https://assets.ai.engineer/sites/aiecode2025/sha256/277e73fa4af467526c1ee30e7da01ffc78bd2b1508786d75c0bcc4100cb91cd5.webp)

What it takes to build an Agent
Today...

Flue
Vercel Eve
Mastra

Unblocked

### Agent Runtime

Flue on Cloudflare handles nine runtime responsibilities, from session persistence and retries to isolation, observability, and replay.

[3:32](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=212s) [Nine agent runtime capabilities handled by Flue on Cloudflare.](https://assets.ai.engineer/sites/aiecode2025/sha256/c3d257c55a7226820711804f062f409e8d3dc93ea0a59d6692ad7c5d246126ef.webp)

Agent Runtime
Flue on Cloudflare handles all 9

✓ Session management
  Durable Object holds it
✓ Checkpoint / state persistence
  SQLite, automatic
✓ Orchestration
  Durable execution + queue
✓ Retry logic
  Requeues unapplied input
✓ Sandbox infrastructure
  Cloudflare sandbox / shell
✓ Execution isolation
  Per-instance worker isolate
✓ Observability
  AI gateway + event stream
✓ Multi-chanel adapters
  Flue add channel
✓ Replay and debugging
  Durable streams replay

Unblocked

### Agent Runtime Code Example

The example configures a bug-triage agent with a model, instructions, GitHub tools, a triage skill and a local sandbox. A new ticket starts a session and becomes the prompt, with Brief as the result type.

[3:49](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=229s) [Runtime capabilities alongside code defining and running an agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/3772237279200c9576868952d284c57d144733c47bb1b563c160b0da9b11815b.webp)

Agent Runtime
Flue on Cloudflare handles all 9

✓ Session management
  Durable Object holds it
✓ Checkpoint / state persistence
  SQLite, automatic
✓ Orchestration
  Durable execution + queue
✓ Retry logic
  Requeues unapplied input
✓ Sandbox infrastructure
  Cloudflare sandbox / shell
✓ Execution isolation
  Per-instance worker isolate
✓ Observability
  AI gateway + event stream
✓ Multi-chanel adapters
  Flue add channel
✓ Replay and debugging
  Durable streams replay

import { defineAgent, init, local } from '@flue/runtime';
import triage from '../skills/triage/SKILL.md' with { type: 'skill' };
import github from '../tools/github.ts';
import { buildUserMessage } from '../core/prompt.ts';
import { Brief } from '../core/schema.ts';

const agent = defineAgent(() => ({
  model: 'anthropic/claude-sonnet-4-6',
  instructions: 'Triage a bug: reproduce, root-cause, fix.',
  tools: [...github],   // what it can DO
  skills: [triage],     // expertise, on demand
  sandbox: local(),     // secure + durable
}));

// a new ticket triggers the run
const session = await init(agent).session();
const { data } = await session.prompt(buildUserMessage(ticket), {
  result: Brief,
});

Unblocked

### Agent Definition

The example defines a bug-triage agent by choosing its model, instructions, tools, skills, and sandbox. Flue on Cloudflare supplies the runtime capabilities listed alongside it.

[3:58](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=238s) [An enlarged agent definition highlights its model, instructions, tools, skills and sandbox.](https://assets.ai.engineer/sites/aiecode2025/sha256/3a7df63dbba4ff2dbca9215d120c304d6076edf64b4b65508b3945f698bc054b.webp)

Agent Runtime
Flue on Cloudflare handles all 9

✓ Session management
  Durable Object holds it
✓ Checkpoint / state persistence
  SQLite, automatic
✓ Orchestration
  Durable execution + queue
✓ Retry logic
  Requeues unapplied input
✓ Sandbox infrastructure
  Cloudflare sandbox / shell
✓ Execution isolation
  Per-instance worker isolate
✓ Observability
  AI gateway + event stream
✓ Multi-chanel adapters
  Flue add channel
✓ Replay and debugging
  Durable streams replay

import { defineAgent, init, local } from '@flue/runtime';
import triage from '../skills/triage/SKILL.md' with { type: 'skill' };
import github from '../tools/github.ts';

const agent = defineAgent(() => ({
  model: 'anthropic/claude-sonnet-4-6',
  instructions: 'Triage a bug: reproduce, root-cause, fix.',
  tools: [...github],   // what it can DO
  skills: [triage],     // expertise, on demand
  sandbox: local(),     // secure + durable
}));

const { data } = await session.prompt(buildUserMessage(ticket), {
  result: Brief,
});

Unblocked

### Issue Investigation Demo

The agent fetches a Linear issue and searches the code. It attributes the production latency to synchronous dispatch and proposes enabling async dispatch in the production configuration.

[4:23](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=263s) [An issue describing slow production dispatch appears beside an agent investigating it in a terminal.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d631242c8f76c7c3eace477b95e82b017ba01e8ab52347aac40be49e81ff825.webp)

Answer posting slow in prod — staging is fine.

Summary
Answer-posting latency in production has been climbing over the last few days — p95 on the message-dispatch step is ~3–4× what we see in staging. Staging runs the same load profile without issue.

What we’re seeing
• prod: dispatch p95 ~2.1s (was ~0.6s last week)
• staging: dispatch p95 ~0.5s, stable
• no recent deploys to the dispatch service in that window

/cc whoever owns answers dispatch

Terminal:
npx flue run augment-ticket --target node --env .dev.vars \
  --payload '{"issue":"UNB-5661","mode":"without","post":true}'

flue run
workflow augment-ticket
starting...
[illegible]
info Fetching ticket from Linear - no org context
info Ticket UNB-5661 — Answer posting slow in prod — staging is fine.
info Reading the issue
info Drafting the plan
thinking
  Let me activate the augment skill and investigate the codebase to understand the issue.
tool activate_skill
tool search_code
tool done activate_skill (1959 chars)
tool done search_code (772 chars)
thinking
  The evidence is very clear:
  - `config/environments/production.yaml` has `async_dispatch: false` which diverges from the schema default (`true`) and the staging config (`true`)
  - The docs explicitly state that `async_dispatch` MUST be enabled in production
  - The code shows that when `async_dispatch` is false, it uses `dispatchInline` (synchronous path) which blocks the request
  - This explains the 3–4x latency increase in production vs staging
  The fix is clear: set `async_dispatch: true` in production config.

Interface text:
My issues > UNB-5661 Answer posting slow in prod — staging is fine.
Properties
Backlog
High
Assign
Set estimate
Labels
Bug
Performance
Project
AI Engineer World’s Fair ...
Add sub-issues
Activity
Unsubscribe
jeff created the issue · 1w ago
jeff changed team from Unblocked [DEV] to Unblocked · 1w ago
jeff added to project AI Engineer World’s Fair — Demo · 1w ago
jeff added related issue UNB-5662 [Postmortem] async_dispatch disable... · 6d ago
jeff changed title to Answer posting slow in prod — staging is fine. · 5d ago
UNB-5662 removed from related issues · 32min ago
Leave a comment...
Create issues from document
Ask Linear
cmux  File  Edit  View  Notifications  Window  Help
Tue Jun 30 2:30 PM

### Agent Recommendation

The agent posts a recommendation to re-enable async dispatch. The speaker says it is wrong: a support engineer had disabled it after an outage, context the agent missed from a Slack discussion.

[5:36](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=336s) [The agent posts a recommendation to the issue after completing its investigation.](https://assets.ai.engineer/sites/aiecode2025/sha256/44433f0616b50173632649599dab934d70943f145e677a66c496735e8947b731.webp)

Answer posting slow in prod — staging is fine.

Summary
Answer-posting latency in production has been climbing over the last few days — p95 on the message-dispatch step is ~3–4x what we see in staging. Staging runs the same load profile without issue.

What we're seeing
• prod: dispatch p95 ~2.1s (was ~0.6s last week)
• staging: dispatch p95 ~0.5s, stable
• no recent deploys to the dispatch service in that window

/cc whoever owns answers dispatch

Activity
jeff created the issue · 1w ago
jeff changed team from Unblocked [DEV] to Unblocked · 1w ago
jeff added to project AI Engineer World's Fair — Demo · 1w ago
jeff added related issue UNB-5662 [Postmortem] async_dispatch disable… · 6d ago
jeff changed title to Answer posting slow in prod — staging is fine. · 5d ago
UNB-5662 removed from related issues · 33min ago

jeff just now
<!-- ctx-agent -->
TL;DR — Set message.async_dispatch: true in production config — it's false, forcing slow synchronous dispatch that violates the latency SLO.

Recommended action

Terminal:
npx flue run augment-ticket --target node --env .dev.vars \
  --payload '{"issue":"UNB-5661","mode":"without","post":true}'

flue run
workflow augment-ticket
starting...
(node:47761) ExperimentalWarning: SQLite is an experimental feature and might change at any time
(Use `node --trace-warnings ...` to show where the warning was created)
run [illegible]
info Fetching ticket from Linear - no org context
info Ticket UNB-5661 — Answer posting slow in prod — staging is fine.
info Reading the issue
info Drafting the plan
thinking
Let me activate the augment skill and investigate the codebase to understand the issue.
tool activate_skill
tool search_code
tool done activate_skill (1959 chars)
tool done search_code (772 chars)
thinking
The evidence is very clear:
- `config/environments/production.yaml` has `async_dispatch: false` which diverges from the schema default (`true`) and the staging config (`true`)
- The docs explicitly state that `async_dispatch` MUST be enabled in production
- The code shows that when `async_dispatch` is false, it uses `dispatchInline` (synchronous path) which blocks the request
- This explains the 3-4x latency increase in production vs staging
The fix is clear: set `async_dispatch: true` in production config.
tool search_code
tool done search_code (772 chars)
tool finish
tool done finish
info Updating the Linear issue

{
  "ok": true,
  "issue": "UNB-5661",
  "withContext": false,
  "relevance": "high",
  "type": "Investigation",
  "tldr": "Set `message.async_dispatch: true` in production config — it's `false`, forcing slow synchronous dispatch that violates the latency SLO.",
  "posted": true,
  "comment":

<!-- ctx-agent -->
TL;DR — Set `message.async_dispatch: true` in production config — it's `false`, forcing slow synchronous dispatch that violates the latency SLO.

Recommended action
Set `message.async_dispatch: true` in [`config/environments/production.yaml` line 18](config/environments/production.yaml#L18). The flag is currently `false`, which routes every dispatch through the blocking `dispatchInline` path instead of the queue. This is the direct cause of the 3-4x latency regression.

Related incidents
- [`config/environments/production.yaml:18`](config/environments/production.yaml#L18) explicitly has `async_dispatch: false`, diverging from the schema default (`true`) and from staging (`true`) — this is the root cause.
- [`services/messages/dispatch.ts:113`](services/messages/dispatch.ts#L113): when `async_dispatch` is `false`, the code falls through to `dispatchInline`, which blocks the request thread for the full dispatch duration, explaining the p95 jump from ~0.6 s to ~2.1 s.

Decisions & constraints
- [`config/messages.schema.yaml:42`](config/messages.schema.yaml#L42): schema default is `true`; the comment reads "async is the supported production mode".
- [`docs/services/messages.md:77`](docs/services/messages.md#L77): "In production, `async_dispatch` MUST be enabled. The synchronous path is intended for local development only and will not meet latency SLOs."

Watch-outs
- No recent deploys to the dispatch service were noted, so the flag was likely flipped outside a normal deploy (config-only change). Audit the config change history to identify when and why it was set to `false` so it isn't silently reverted again.
- After re-enabling, confirm p95 returns to ~0.5 s; if a queue backlog built up during the synchronous period, there may be a brief catch-up spike before metrics stabilise.
}
done workflow completed

Interface text:
cmux  File  Edit  View  Notifications  Window  Help
Tue Jun 30 2:31 PM
My issues > UNB-5661 Answer posting slow in prod — staging is fine.
Properties
Backlog
High
Assign
Set estimate
Labels
Bug  Performance
Project
AI Engineer World's Fair …
Add sub-issues
Unsubscribe
Create issues from document
Ask Linear

### What your agent can’t see

Compiling code is the visible tip; intent, decisions and incident learnings sit below. In the demo, the agent missed the outage’s Slack discussion and postmortem ticket, leaving it with a narrow picture.

[6:11](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=371s) [An iceberg contrasts compiling code above water with organizational knowledge and decisions below.](https://assets.ai.engineer/sites/aiecode2025/sha256/819028d909d930e7e2d86252417946b7035075f6ed049ad4ceaff35b2634069b.webp)

CODE THAT COMPILES

ORIGINAL INTENT
TEAM CONVENTIONS
PAST DECISIONS
WHY WAS IT BUILT THIS WAY
MIGRATION PLANS
TESTING STANDARDS
REJECTED APPROACHES
SLACK DECISIONS
ARCHITECTURE RATIONALE
DESIGN DOC WITH TRADE OFFS
INCIDENT LEARNINGS

What your agent can’t see

imgflip.com
Unblocked

### The human was the missing piece

Humans supply an agent with history, intent and decisions while catching errors and steering its work. Without a human in the loop, missing context can become a silent failure.

[7:07](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=427s) [Two columns compare the context humans supply with the instructions, tools, code, and ticket available to an agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/cf173873fecde30427d11f94a301a83f4ecca171d056ce2897084c6503c4b6ab.webp)

The human was the missing piece

What the human fed the loop
The why, the history, the intent
• Why the code is the way it is
• What broke last time, and what we agreed to do about it
• What was actually decided in that meeting
• Who owns what, and who to ask
• The unwritten tribal knowledge

What the agent has alone
The code, the tools, the ticket
• Its instructions
• Its tools and skills
• The code it can read
• The ticket in front of it

Unblocked

### Why your team needs a context engine

A context engine selects relevant information, resolves conflicts and respects access permissions. The speaker says it delivers a synthesized understanding an agent can act on.

[8:13](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=493s) [A slide lists relevance, reconciliation, governance, and delivery as context engine functions.](https://assets.ai.engineer/sites/aiecode2025/sha256/941bd97d78906fb2e0044d3ecdaa8cf7f5dde485f4698713d5854c3d7a860c72.webp)

Why your team needs a context engine

• Relevance - Knows who’s asking and which information actually matters
• Reconciliation - Resolves conflicts across sources
• Governance - Respects permissions and access
• Delivery - The right context, at the right time

Unblocked

### How the context engine works

Unblocked connects development and communication sources into an organizational model, then delivers reconciled, ranked, permission-scoped context to agents and other workflows.

[8:46](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=526s) [A diagram routes information from development and communication sources through a context engine to agent and review workflows, with six capabilities listed below.](https://assets.ai.engineer/sites/aiecode2025/sha256/d216216098b80fcac60e3bda28207defceac8513fc1787ce6c40a2c0dd784ef4.webp)

How the context engine works

Sources
Code + PRs
Planning Tools
Docs
Conversations
Incident Management

Workflows
Coding Agents +
Code Review
Messaging Apps
MCP
CLI
API

Unified system context
Merges signals from all sources before delivery to the agent.

Targeted retrieval
Retrieve only the information agents need from the graph.

Conflict resolution
Recency + authority signals resolve contradictions automatically.

Personalized relevance
Scoped to your repos, teammates, and work history.

Token optimization
Ranked, compressed context — no waste in the prompt window.

Permission enforcement
Permissions and policies enforced automatically across systems.

Unblocked

### Can’t I just connect it all with MCP?

The speaker contrasts MCP’s source access with a context engine that synthesizes sources, ranks information for the task, and resolves conflicts before delivering context to an agent.

[9:43](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=583s) [A table contrasts source access and raw results with synthesized, ranked context and conflict resolution.](https://assets.ai.engineer/sites/aiecode2025/sha256/82faa6bd2ab3f5a9454836739d8d1ce4f4e3744577311415de4917cc6a807d61.webp)

“Can’t I just connect it all with MCP?”

MCP
✓ Connects your agents to every source - genuinely great at this
✕ Returns raw matches; the agent picks what to believe.
✕ Ranks by keyword similarity, not your task.
✕ Sources disagree? It serves both and moves on.

CONTEXT ENGINE
✓ Synthesizes every source into one picture
✓ Ranks by task at hand, not keyword overlap.
✓ Decision grade context, not a pile of raw results.
✓ Resolves contradictions - recency, authority, provenance.

Unblocked

### Same agent, same ticket – one line of context

The triage agent asks Unblocked to research the ticket, then passes that context into its prompt. The second build highlights those two lines.

[10:30](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=630s) [A code example configures a triage agent, retrieves context for a ticket, and includes it in the agent prompt.](https://assets.ai.engineer/sites/aiecode2025/sha256/8c14bdfd343bf8cb999623ac18a61be9654fc753ea78650224bcfa1d014ecb3c.webp)

Same agent, same ticket – one line of context.

import { defineAgent, init, local } from '@flue/runtime';
import triage from '../skills/triage/SKILL.md' with { type: 'skill' };
import github from '../tools/github.ts';
import { buildUserMessage } from '../core/prompt.ts';
import { Brief } from '../core/schema.ts';
import { unblocked } from '@getunblocked/sdk';   // the context engine

const agent = defineAgent(() => ({
  model:        'anthropic/claude-sonnet-4-6',
  instructions: 'Triage a bug: reproduce, root-cause, fix.',
  tools:        [...github],   // what it can DO
  skills:       [triage],      // expertise, on demand
  sandbox:      local(),       // secure + durable
}));

// a new ticket triggers the run
const session  = await init(agent).session();
const context  = await unblocked.research(ticket);   // ← what your company KNOWS
const { data } = await session.prompt(buildUserMessage(ticket, context), { result: Brief });

Unblocked

[10:38](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=638s) [Code slide highlights researching a ticket for organizational context and passing it to an agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/1d199040ae09bcf4d5ac346dcf851ed7ae6359bca572fe02458fc2cba72d1c6d.webp)

Same agent, same ticket – one line of context.

import { defineAgent, init, local } from '@flue/runtime';
import triage from '../skills/triage/SKILL.md' with { type: 'skill' };
import github from '../tools/github.ts';
import { buildUserMessage } from '../core/prompt.ts';
import { Brief } from '../core/schema.ts';
import { unblocked } from '@getunblocked/sdk';   // the context engine

const context  = await unblocked.research(ticket);   // ← what your company KNOWS
const { data } = await session.prompt(buildUserMessage(ticket, context), { result: Brief });

  tools:        [...github],   // what it can DO
  skills:       [triage],      // expertise, on demand
  sandbox:      local(),       // secure + durable
}));

// a new ticket triggers the run
const session  = await init(agent).session();

Unblocked

### Context engine investigates a ticket

The context engine finds a postmortem and Slack decision: async dispatch was disabled after duplicate posts. It advises fixing consumer idempotency before re-enabling it.

[11:07](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=667s) [A ticket and terminal show an agent retrieving incident context while an earlier recommendation remains visible.](https://assets.ai.engineer/sites/aiecode2025/sha256/00a278079294d50b86f6d44f2760e0ea702697cf99b1d73e371f3232b21f1c34.webp)

Answer posting slow in prod — staging is fine.

Summary
Answer-posting latency in production has been climbing over the last few days — p95 on the message-dispatch step is ~3–4x what we see in staging. Staging runs the same load profile without issue.

What we're seeing
• prod: dispatch p95 ~2.1s (was ~0.6s last week)
• staging: dispatch p95 ~0.5s, stable
• no recent deploys to the dispatch service in that window

/cc whoever owns answers dispatch

Activity
jeff created the issue · 1w ago
jeff changed team from Unblocked [DEV] to Unblocked · 1w ago
jeff added to project AI Engineer World's Fair — Demo · 1w ago
jeff added related issue UNB-5662 [Postmortem] async_dispatch disable... · 6d ago
jeff changed title to Answer posting slow in prod — staging is fine. · 5d ago
UNB-5662 removed from related issues · 38min ago

jeff · 6min ago
<!-- ctx-agent -->
TL;DR — Set message.async_dispatch: true in production config — it's false, forcing slow synchronous dispatch that violates the latency SLO.

Recommended action

Terminal:
npx flue run augment-ticket --target node --env .dev.vars \
  --payload '{"issue":"UNB-5661","post":true}'

flue run
workflow augment-ticket
starting...
[illegible]
Fetching ticket from Linear - with org context
Ticket UNB-5661 — Answer posting slow in prod — staging is fine.
Reading the issue
Querying the Unblocked context engine
  ↳ consulted Linear - UNB-5662 — postmortem: async_dispatch disabled after Sev1
  ↳ consulted Slack - #answers — decision thread (2026-06-14): "keep it OFF in prod"
Reasoned answer from Unblocked:
  → Verdict: `message.async_dispatch` is OFF in prod by design — do NOT flip it to `true`.

The schema default (`true`), the service docs ("enable in production"), and a healthy staging environment all argue for turning it on. Every one of those signals predates the incident the flag itself caused, so each one is actively misleading here:

1. 9 days ago, enabling async dispatch in prod let it double-publish to the message queue under load (publish-before-commit, then retry-on-slow-ack). The consumer is not idempotent, so answers posted twice — ~40 min of duplicate notifications and duplicate emails to askers at peak. Sev1, UNB-5662.
2. On-call disabled the flag as the mitigation. In #answers the team agreed to keep it OFF until the consumer-side idempotency fix ships — and explicitly called out "re-enabling to match staging or the schema default" as the exact thing that caused the outage.
3. The docs recommending it in production are stale — flagged for correction in that thread.

The idempotency fix has not shipped, so the risk is still live. The 3–4x latency is the known, accepted cost of the safe synchronous path — track it as its own problem; do not re-enable async to "fix" it. Owner: answers team. Ping #answers before touching this flag.

Drafting the plan
thinking
Let me activate the augment skill and then search the codebase for relevant context.
tool activate_skill
tool search_code
tool done activate_skill (1959 chars)
tool done search_code (772 chars)
thinking
Now I have all the context I need. Let me synthesize the information:
1. The issue is about slow answer-posting in production vs staging.
2. The root cause is that `message.async_dispatch` is intentionally `false` in prod (while staging has it `true`).
3. This was deliberately set to `false` after a Sev1 (UNB-5662) where async dispatch caused double-publishing and dup[illegible]
4. The latency difference is explained by the sync path blocking requests vs async path queuing them.
5. The fix is NOT to re-enable async_dispatch — that would reintroduce the Sev1.
6. The real solution is to strengthen idempotency on the consumer side so we can safely turn async_dispatch back on w[illegible] without risking duplicates.
tool finish
tool done finish
Updating the Linear issue

Interface text:
cmux  File  Edit  View  Notifications  Window  Help
Tue Jun 30 2:36 PM
My issues > UNB-5661 Answer posting slow in prod — staging is fine.
Properties: Backlog; High; Assign; Set estimate
Labels: Bug; Performance
Project: AI Engineer World's Fair ...
Add sub-issues
Unsubscribe
Create issues from document
Ask Linear

### Updated recommendation

The updated ticket recommends fixing consumer-side idempotency before re-enabling async dispatch, which was disabled after duplicate answer posts.

[11:36](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=696s) [The ticket recommends fixing consumer idempotency before re-enabling asynchronous dispatch.](https://assets.ai.engineer/sites/aiecode2025/sha256/dc44c400c5c114988deec0788476f60632930cc21917cde7138963b9271267f5.webp)

Answer-posting latency in production has been climbing over the last few days — p95 on the message-dispatch step is ~3–4× what we see in staging. Staging runs the same load profile without issue.

What we’re seeing
• prod: dispatch p95 ~2.1s (was ~0.6s last week)
• staging: dispatch p95 ~0.5s, stable
• no recent deploys to the dispatch service in that window

/cc whoever owns answers dispatch

<!-- ctx-agent -->
🧠 Organizational context · Investigation — via Unblocked

TL;DR — Latency is caused by intentional sync dispatch in prod; fix the consumer idempotency bug before re-enabling async.

Recommended action
Prioritise and ship the consumer-side idempotency fix (idempotency keys, tracked in UNB-5662 [Postmortem] async_dispatch disabled in prod — duplicate message-queue events (Sev1)), then re-enable message.async_dispatch in production. Do not [cut off]

Terminal:
[Beginning cut off] emails to askers at peak. Sev1, UNB-5662.
2. On-call disabled the flag as the mitigation. In #answers the team agreed to keep it OFF until the consumer-side idempotency fix ships — and explicitly called out “re-enabling to match staging or the schema default” as the exact thing that caused the outage.
3. The docs recommending it in production are stale — flagged for correction in that thread.

The idempotency fix has not shipped, so the risk is still live. The 3-4× latency is the known, accepted cost of the safe synchronous path — track it as its own problem; do not re-enable async to “fix” it. Owner: answers team. Ping #answers before touching this flag.

Drafting the plan
Let me activate the augment skill and then search the codebase for relevant context.
activate_skill
search_code
activate_skill (1959 chars)
search_code (772 chars)

Now I have all the context I need. Let me synthesize the information:
1. The issue is about slow answer-posting in production vs staging.
2. The root cause is that message.async_dispatch is intentionally false in prod (while staging has it true).
3. This was deliberately set to false after a Sev1 (UNB-5662) where async dispatch caused double-publishing and duplicate answers.
4. The latency difference is explained by the sync path blocking requests vs async path queuing them.
5. The fix is NOT to re-enable async_dispatch — that would reintroduce the Sev1.
6. The real solution is to strengthen idempotency on the consumer side so we can safely turn async_dispatch back on without risking duplicates.

Updating the Linear issue
ok: true
issue: UNB-5661
withContext: true
relevance: high
type: Investigation
tldr: Latency is caused by intentional sync dispatch in prod; fix the consumer idempotency bug before re-enabling async.
posted: true

Comment:
<!-- ctx-agent -->
🧠 Organizational context · Investigation — via Unblocked (https://getunblocked.com)

TL;DR — Latency is caused by intentional sync dispatch in prod; fix the consumer idempotency bug before re-enabling async.

Recommended action
Prioritise and ship the consumer-side idempotency fix (idempotency keys, tracked in UNB-5662, https://linear.app/unblocked/issue/UNB-5662), then re-enable message.async_dispatch in production. Do not flip the flag before that fix lands.

Decisions & constraints
• message.async_dispatch is intentionally false in production — this is the direct cause of the latency regression. The synchronous dispatchInline path blocks each request (services/messages/dispatch.ts:113); the docs explicitly call out that the sync path “will not meet latency SLOs” (docs/services/messages.md:77) and is intended for local dev only.
• The flag was disabled on-call as a mitigation for UNB-5662 (https://linear.app/unblocked/issue/UNB-5662) (duplicate answer posts). The team resolved in #answers (2026-06-14) (https://acme-eng.slack.com/archives/[illegible]): “Keep it OFF in prod ... do not re-enable it to match staging or the schema default.”
• Re-enabling async to match staging or the schema default (default: true in config/messages.schema.yaml:42) reintroduces the Sev1 — the consumer is not idempotent and will double-publish under load.

Related incidents
• UNB-5662 (https://linear.app/unblocked/issue/UNB-5662) — ~40 min of double-posted answers (duplicate notifications + emails) caused by the async double-publish race. Root cause (missing idempotency keys) is not yet fixed.

Watch-outs
• Staging running async_dispatch: true (config/environments/staging.yaml:18) makes the perf gap look like config drift — it is not; the divergence is deliberate.
• Any automated config-sync or “match staging” tooling will silently re-enable the flag and trigger duplicate answers again.

Who to ask
• #answers — owns the flag decision and the idempotency fix timeline. Ping before any change to message.async_dispatch.

workflow completed

Interface text:
My issues > UNB-5661 Answer posting slow in prod — staging is fine.
Properties: Backlog; High; Assign; Set estimate
Labels: Bug; Performance
Project: AI Engineer World’s Fair ...
Relations: Related; [Postmortem] async_disp...
Activity
jeff created the issue · 1w ago
jeff changed team from Unblocked [DEV] to Unblocked · 1w ago
jeff added to project AI Engineer World’s Fair — Demo · 1w ago
jeff added related issue UNB-5662 [Postmortem] async_dispatch disable... · 6d ago
jeff changed title to Answer posting slow in prod — staging is fine. · 5d ago
UNB-5662 removed from related issues · 38min ago
jeff · 6min ago (edited)
Create issues from document · Ask Linear

### Context layer use cases

A context layer can hydrate agent plans before coding and ground code reviews in team conventions and prior PRs. It can also help with triage, incident response, and customer-facing knowledge.

[11:51](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=711s) [Six cards cover agent planning, code generation, triage, incident management, code review, and customer success and sales.](https://assets.ai.engineer/sites/aiecode2025/sha256/ab92b534b78f7f07f8fd2c1804a48b421c629dd884b32391a5657bede8f7e1e3.webp)

Use cases of a context layer beyond ticket enrichment

AGENT PLANS & CODE
Hydrate context before planning to improve codegen quality.

CODE GENERATION
Grounding generated code in your conventions, prior art, and decisions.

TRIAGE OPERATIONS
Routing issues, enriching tickets, validating bug reports.

INCIDENT MANAGEMENT
Improving response and identifying root cause.

CODE REVIEW
Grounded findings that cite team conventions and prior PRs.

CUSTOMER SUCCESS & SALES
Surfacing relevant knowledge in Slack / Teams.

Unblocked

### The gap is context

Jeffrey Ng closes with a quote attributed to Andrej Karpathy, framing organizational context as the problem Unblocked is trying to solve.

[12:35](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=755s) [A slide attributes the quotation “The gap is not intelligence. It’s context.” to Andrej Karpathy.](https://assets.ai.engineer/sites/aiecode2025/sha256/7285274ad3ce4f1d75eb1d5b4df16b29ea5dd92c9104eaab4f2f1c708d044dca.webp)

The gap is not intelligence.
It's context. - Andrej Karpathy

### Thanks!

Jeffrey Ng invites questions at Booth P16 and mentions breakout sessions on the context engine, which he believes are scheduled for the following day.

[12:44](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=764s) [Closing slide reads “Thanks!” and “Jeffrey Ng,” with the Unblocked logo.](https://assets.ai.engineer/sites/aiecode2025/sha256/370d8463e3c8764922c22e4934200ffdeaab857030dd05235a32bafe31d9334a.webp)

Thanks!

Jeffrey Ng

Unblocked

## Full transcript

[0:00](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=0s) [upbeat music] Hi, all. Uh, my name is Jeff.

[0:15](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=15s) I'm a founding engineer at Unblocked, and I'm here to talk to you about how building agents has actually gotten pretty easy. But unfortunately, they still get things confidently wrong.

[0:27](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=27s) So six months ago, it required a team's effort and basically a quarter to build out an agent. Um, an agent is more than just models and tools. It's the models, the tools, and everything required to build out a production service.

[0:42](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=42s) Uh, here are some examples of the different systems were necessary in order to build something out. Each one of these was basically its own company or at least a company function.

[0:54](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=54s) Not gonna go through each one of these, but, you know, a few that stood out to me.

[0:59](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=59s) First one, checkpoint and state persistence. Agent runs, they're typically long-lived and stateful. Um, unfortunately, uh, infrastructure itself though, those-- that's ephemeral. Crashing without durability can actually lead to a lot of state loss, and that state kind of includes things like message history, tool calls, as well as, you

[1:24](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=84s) know, where you are in the loop. Without these things, you can't resume the session. Uh, one option is, you know, maybe you wanna restart the session. Unfortunately, that's actually quite expensive as well.

[1:36](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=96s) Uh, you lose out on all the tokens that you'd originally used, uh, as well as, you know, latency. Uh, from a user experience standpoint, you've already triggered that session.

[1:47](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=107s) Now you have to wait for the whole thing to go again. And lastly, side effects. Your agent might have performed some side effects, and now there's a chance of those doubling up.

[1:58](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=118s) So next thing, sandbox infrastructure, right? So as we all know, we're running more and more agent-generated code as well as third-party code. This gets all run on your infrastructure, and due to that, there are some complexities.

[2:13](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=133s) Uh, because of that, we want to introduce isolated sandboxes, which help prevent, uh, unnecessary reads of environment secrets, unnecessary network access. You know, just in general, we don't wanna take down the shared host.

[2:30](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=150s) And then observability. How do we answer the question: where did this fail? Typically, this includes tracking logs and traces from across half a dozen systems.

[2:43](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=163s) Everything I've mentioned here, none of this actually improves an agent's capabilities. They're all taxes one has to pay in order to get an agent out there to play the game.

[2:56](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=176s) Thankfully, things have changed quite a bit. Uh, the whole ecosystem has matured quite a bit, and cloud infrastructure players such as Cloudflare, uh, Vercel, AWS, they've gone and taken some of that complexity away and built primitives that these frameworks, Flu, Vercel Eve, Mastra,

[3:18](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=198s) with these together, you know, they've taken a lot of the complexity away, and you can focus more on building the actual agent itself, the core logic that actually helps you and your team and your customers.

[3:33](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=213s) So here's an example of one. Uh, I've played around with Flu and Cloudflare, and as you can see on the left-hand side,

[3:42](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=222s) you know, we basically handle everything as mentioned before. So the primitives plus a framework lead to a situation where it's actually not that much code to define an agent, uh, one of the things I was shocked at when I first took a look at the documentation.

[3:57](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=237s) To get in the details, all you really have to do when defining an agent is, A, deciding which model you wanna use, B, the instructions or, you know, the system prompt, C, the tools that you want the ax-- the agent to have access to, skills, the things that it can do, as well as the sandbox location, where

[4:17](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=257s) things are being run. So, uh, to give you an example of this,

[4:25](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=265s) I've actually gone and built out a issue enrichment system specifically for Linear. So what this does is, given a Linear ticket and access to your code repository, it'll go out, you know, fetch a Linear ticket, determine whether or not it's a feature or a bug.

[4:43](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=283s) From there, it'll do some code searching, provide all that context to the agent, and then come up with a plan of next steps.

[4:51](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=291s) On the left-hand side here, this is a issue that one of my colleagues, a support engineer, had posted, I think, a month ago. Uh, to summarize it, what had happened was we had some pretty serious degradation in our agentic QA pipeline, time to first character was taking three to four seconds when it should realistically be in the

[5:11](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=311s) hundreds of milliseconds. So let's see what happens when, you know, we put this through the system.

[5:20](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=320s) So as you'll see here, I've set up the agent to go fetch a Linear ticket. I've given it the skills and tools to actually go and fetch a code, search a code, and query against that.

[5:31](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=331s) That's being passed back to the agent, which is doing some reasoning against that right now.

[5:36](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=336s) And then just wait a little bit. At this point, we've updated the Linear issue ticket. The recommendation here is to re-enable our async dispatch, which makes sense. It allows us to run a lot more of our QA pipeline in parallel on a single machine.

[5:52](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=352s) Sounds great, right? Unfortunately, um, this is wrong. This had actually caused an outage a few days ago, and one of our, uh, support engineers had explicitly disabled this, uh, before this ticket was, uh, shown.

[6:07](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=367s) So-

[6:10](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=370s) Where did things go wrong? Why was the con-- uh, you know, why did I get it wrong? The agent I had written, it didn't have a full picture. It was missing the context from the Slack discussion that happened after the issue where the engineers came together, uh, went through the actual outage, what went wrong, what was the

[6:28](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=388s) fix, and the next steps. It also was missing the postmortem, uh, Linear ticket, which came as a result of that. In general, it had a narrow understanding of the problem.

[6:41](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=401s) This concept of missing knowledge and intent that's stored across an organization and different systems is something that comes back again and again. And since this was deployed as a background agent, this is gonna make that mistake silently in the background, misinforming both my teammates and potentially other agents.

[7:00](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=420s) So I guess the next question is, why don't we run into this locally? You know, we all use agents locally. We don't necessarily run into these issues. Well, you, the human, the engineers, we currently act as that context layer.

[7:14](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=434s) When working with an agent, you know, you're there to ask questions, catch any errors, and supply the missing facts on every single turn.

[7:23](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=443s) A person knew why the code is the way it is, what broke last time, and what we've decided to do about it. The agent though, it only has what's on the right-hand side, right?

[7:33](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=453s) It has instructions, the tools and skills we specifically gave it, the code, as well as the ticket in front of it. When a agent is in the loop-- oh, sorry, when a human is in the loop with the agent, we're there to catch, to steer.

[7:47](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=467s) Ultimately, we're there to babysit the agent. But as agents have gotten trivially easy to deploy, as I've shown earlier with Flu and Cloudflare,

[7:57](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=477s) the-- without the human in the loop, this issue becomes more and more prevalent. This missing context becomes a silent failure. You know,

[8:06](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=486s) all that intuition and knowledge that we've had as humans needs to be replaced. Something needs to carry the load.

[8:14](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=494s) So that thing, that's a context engine. A context engine is a system that provides task-relevant information based on who you are and what matters. It also resolves all the conflicts across multiple data sets.

[8:29](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=509s) It understands your access roles or the agent's access roles, and only, uh, respects that, and only provides information that's relevant. And most importantly, it delivers a synthesized understanding that an agent can act on, not just a list of documents that it has to reason upon itself.

[8:47](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=527s) So how does this context engine work? Well, let's take a step back. What does an agent actually need? An agent needs-- Clearly, it needs context outside of just your source code.

[9:00](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=540s) Think about everything that you need to work day to day. It's not just the code. It's, you know, the Slack discussions where decisions are made, the documentation where we show all the best practices.

[9:13](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=553s) All that is important to your day-to-day process, and that's true for your agent as well. So what we do here is we connect everything, your docs, code, tickets, conversations.

[9:24](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=564s) We then build a model of your organization, of your system, and we piece how all of these things work together and make it generally available to your agents. From that model, the agents are only provided a slice of that data which has been reconciled, ranked, and scoped to your permissions.

[9:40](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=580s) Scattered context comes in, grounded context comes out.

[9:46](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=586s) The obvious next question is, why can't we just do this with MCP, right? You could connect a Slack MCP, a Linear MCP, a GitHub MCP, and with that, all that data is accessible.

[9:57](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=597s) MCP is great at access, but access isn't understanding. A MCP hands the agent the raw results, and you know, you're now dependent on the agent to actually decide what to believe in.

[10:10](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=610s) You end up flooding the agent with irrelevant data, filling up the context window and, you know, overall context costs just go up. It also leaves a local agent to handle conflicts in data.

[10:21](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=621s) You know, your Linear MCP and your Slack MCP may come back with different results. You're just leaving the agent to make that decision somewhat ad hoc at this moment.

[10:32](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=632s) So back to the original problem I had earlier. This is the same file, same agent, but now we've connected the context engine. Uh, what we do here is, is we're currently prompting Unblocked to do some research on the ticket and provide that context to the agent.

[10:49](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=649s) So let's see that in action. Sorry about that.

[11:02](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=662s) So here we go. Uh, we're doing a very similar thing. We're fetching the Linear ticket, but you'll notice here that we're actually calling the Unblocked context engine. And what it's done here is actually it's found the relevant Linear postmortem, as well as a Slack conversation where we've had the entire discussion between the engineering teams.

[11:19](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=679s) And as part of that, we've returned a understanding, and that's now been provided to the agent as a summary. So the agent no longer has to actually reason from those documents.

[11:31](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=691s) And at this point, you'll notice here, the agent now has been updated.

[11:41](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=701s) Uh, the recommendation has gone from breaking and causing another issue to actually preventing a- another outage.

[11:53](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=713s) So the example I've shown here is issue ticket enrichment, but this context layer can actually go a lot further. Uh, for example, coding. Everyone here does, uh, coding with, uh, Claude Code or Codex.

[12:05](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=725s) Using an Unblocked context engine to actually hydrate the agent plan goes a long way in terms of saving context and tokens. Uh, code review. It makes the PRs look as if they've been reviewed by an expert on your team.

[12:19](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=739s) Who doesn't like that? As well as surfacing the correct answers to your customer success team as well as sales.

[12:27](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=747s) In general, there are many instances where you might want an agent to have institutional and tribal knowledge of your organization.

[12:37](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=757s) Just wanted to leave you on this. I think this quote encapsulates what we're trying to solve at Unblocked. "The gap isn't intelligence, it's context."

[12:46](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=766s) So thank you. Uh, I'll be at Booth P16 along with the rest of my team if you guys have any questions.

[12:53](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=773s) There will be additional breakout sessions later tomorrow, I believe, that goes a lot more in depth about actually how the context engine works and, you know, how you can benefit from that.

[13:03](https://www.youtube.com/watch?v=HvMyYLTfvhg&t=783s) Cheers. [applause] [outro jingle]
