# How to Generate Mergeable Code with a Context Engine — Peter Werry, Unblocked

Peter Werry, Unblocked

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/qdAkxLoYNI8-generate-mergeable-code-context-engine) · [Video](https://www.youtube.com/watch?v=qdAkxLoYNI8)

## How to Generate Mergeable Code with a Context Engine

Peter Werry explains why coding agents need selected organizational knowledge—not merely repository access—and demonstrates how Unblocked connects code, decisions, review history, and expertise to improve planning and debugging.

### The context layer agents keep losing

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

A context engine delivers organizational knowledge to both people and agents. Before coding agents, engineers assembled that knowledge themselves: they searched discussions and documents, read the codebase, documented architecture, and learned from incidents and outages. Those experiences produced the “battle scars” that explain why a system works as it does—not just what the current code says.

![Shows the AI maturity curve as Werry locates many teams around the stages where context becomes the bottleneck.](https://ai.engineer/api/talk-essay-media/2cfa59a937b99383dedad69a926c3a2ede9291732e898dc3fa38f3be63a3e443)

Shows the AI maturity curve as Werry locates many teams around the stages where context becomes the bottleneck.

An agent starts from a harder position. Werry compares it to an expert software engineer joining the company for the first time on every task. General programming ability does not supply knowledge of this repository, its testing conventions, or its deployment process. Once the task ends, the newly discovered context effectively disappears, so the next task begins with another onboarding exercise.

He places this problem on an AI maturity curve that moves from autocomplete and editor assistance through organizational wikis, MCP-connected tools, skills, and eventually software factories. He puts many teams around stages four to five, where they recognize context as a bottleneck and are trying to make internal knowledge available to agents. More autonomous systems raise the stakes: an agent working without close supervision must find relevant facts that it does not already know to request.

### Why search access and a huge prompt are insufficient

[4:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=251s)

Attaching a wiki gives an agent somewhere to search, but it does not tell the agent what matters or when the search is complete. Werry borrows “satisfaction of search” from radiology: after finding one plausible indicator, a reader may stop and miss another finding that would change the diagnosis. A coding agent can make the same mistake by finding one apparently relevant page or code path and proceeding before it discovers a conflicting decision elsewhere.

![Displays the key distinction that access to information does not equal understanding.](https://ai.engineer/api/talk-essay-media/f583a72a4338475590ab670fae514155abd6d59fae723fb92b07985c16d2127a)

Displays the key distinction that access to information does not equal understanding.

Retrieving individual facts also leaves a synthesis problem. The agent must connect dependencies, architecture, and future plans to determine the scope of a change. A plausible document is not enough if it does not explain how those pieces constrain one another.

Putting everything into the context window fails differently. Werry argues that an organization can hold more relevant material than even a million-token window can contain, while irrelevant material distracts the agent and consumes time and tokens. The target is task-specific context: enough evidence to direct the work without filling the prompt with unrelated code and documents.

His iceberg model separates visible code from the knowledge underneath it. Agents can inspect and edit the code, but intent, team conventions, past decisions, Slack discussions, and architecture rationale may live elsewhere. Those submerged constraints are often the difference between code that merely compiles and a change that fits the organization.

The organizational-context iceberg
The repository exposes implementation, while many constraints that determine the right change live in organizational history.
- Visible code — The implementation the agent can inspect and modify directly.
- Intent and conventions — The desired outcome and the team's established way of working.
- Past decisions and discussions — Earlier choices and Slack conversations that explain constraints.
- Architecture rationale and plans — Why dependencies fit together and how future direction scopes the work.

### A generated architecture explanation that shows its work

[7:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=431s)

The first live demonstration returns to the human reader. People remain accountable for what they merge, so they still need to understand a pull request and the architecture it changes. The demo asks **Unblocked** about an internal component called the Source Mark Engine.

![Shows the answer’s attached sources while Werry emphasizes that synthesized explanations should show their work.](https://ai.engineer/api/talk-essay-media/27a684400647c13127a1db775b7e76a159052c9657a1641977325c61737c281c)

Shows the answer’s attached sources while Werry emphasizes that synthesized explanations should show their work.

The answer includes an architecture diagram synthesized from the current code and proposals for future architecture. It was not retrieving a diagram that already existed. It inferred a representation for this question, which makes provenance especially important: a generated explanation can be useful and still be partly wrong.

The attached sources let a person inspect the knowledge behind the answer and correct it. They also give an agent concrete places to continue investigating. “Show your work” is therefore more than a trust gesture; it creates a path from synthesis back to the underlying evidence.

Werry then moves the same question-answering behavior into Slack, where many engineering decisions happen. Unblocked can respond when it judges that it has a sufficiently useful answer, or a user can address it directly. The demonstration does not explain how that confidence decision is calculated, so selective participation remains a stated behavior rather than a fully specified mechanism.

### The same optimization plan, with and without organizational context

[9:55](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=595s)

The Source Mark Engine answer identifies optimization opportunities, which become the next experiment. Werry asks **Claude Code** to plan an optimization of the Source Mark calculator without Unblocked. The agent searches the repository, studies the algorithm, and produces a plan that he describes as reasonably good.

![Shows the usage comparison while Werry reports roughly one minute and sub-dollar cost with Unblocked versus a slower, costlier baseline.](https://ai.engineer/api/talk-essay-media/141f7604137e7bc703f6a38167ff402777dbd88c97e7f74b41637892985f8810)

Shows the usage comparison while Werry reports roughly one minute and sub-dollar cost with Unblocked versus a slower, costlier baseline.

The second run adds Unblocked. This time, the plan incorporates pull requests discussing future improvements, Slack conversations, Notion material, and architecture documents. The response carries its sources into Claude Code, giving the coding agent specific references to inspect if it needs more detail rather than forcing it to rediscover the relevant trail.

For this planning demonstration, Werry reports a cost below one dollar and a task time of about one minute with Unblocked. Without it, the run took about two minutes and cost more. He explicitly says to ignore the displayed wall-clock duration for the run with Unblocked because its session had remained open for about an hour. These figures describe one planning demo; they do not establish a general benchmark or show that either plan was implemented and merged.

The larger claim is about downstream rework. Baseline discovery costs time, but incomplete discovery can also put the agent on the wrong plan or wrong assumptions. Each later step then inherits the mistake, eventually forcing the agent to revisit earlier work. The initial minute saved is small compared with avoiding repeated loops across a longer task.

Why missing context compounds
A discovery mistake can survive planning, contaminate execution, and force another search loop. Selected cross-source context aims to reduce that risk before execution starts.
- Optimization task — Plan an optimization for the Source Mark calculator.
- Repository discovery — The baseline agent searches code and reconstructs how the algorithm works.
- Cross-source context — Relevant PRs, Slack discussions, Notion material, and architecture documents are assembled with sources.
- Plan and assumptions — The agent chooses what should change and why.
- Later execution — Subsequent work proceeds using the selected plan.
- Corrective loop — Wrong assumptions force the agent to return and repeat discovery or planning.
- Optimization task → Repository discovery (baseline path)
- Optimization task → Cross-source context (context-engine path)
- Repository discovery → Plan and assumptions (infers from discovered code)
- Cross-source context → Plan and assumptions (adds decisions and future intent)
- Plan and assumptions → Later execution (guides later work)
- Later execution → Corrective loop (wrong assumptions emerge)
- Corrective loop → Repository discovery (repeat discovery)

### Turning review history and expertise into guidance

[12:55](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=775s)

The code-review example treats organizational context as more than a collection of documents. Unblocked examines pull-request data and other sources, derives best practices associated with the codebase, and makes them available to a review agent. The intended result is guidance shaped by how this team has reviewed real changes.

![Shows the generated pull request connecting the proposed fix to the earlier model-behavior regression and organizational history.](https://ai.engineer/api/talk-essay-media/419ff75fd1bf0f50545a80881e280d7808f3e1578705f4e4803c36ce482d1fef)

Shows the generated pull request connecting the proposed fix to the earlier model-behavior regression and organizational history.

In the demo, a senior engineer named Richie recognizes an automated comment as something he would say. Werry explains that the system had surfaced a comment Richie previously made. Seniority or expertise acts as a boosting signal, giving some historical guidance more prominence. The talk does not specify the scoring formula or explain how the system handles conflicting expert opinions.

A second example begins when Richie notices a sharp drop in the number of issues surfaced by the review agent. He investigates with Unblocked, reaches an approximate diagnosis, and asks it to fix the problem. Werry describes this cloud-agent behavior as an internal experiment rather than a generally established workflow.

The generated pull request ties its fix to earlier conversations. A change in model behavior had been associated with the drop, and Unblocked found the Slack thread where Richie had made that connection. The example demonstrates traceability from an observed regression through organizational history to a proposed fix. It does not establish the exact patch mechanics or provide a measured post-fix recovery.

### Query history, map expertise, and compare task outcomes

[15:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=908s)

Werry closes with two open-source components. The [document query engine](https://github.com/unblocked/document-query-engine) runs over a GitHub repository, ingests historical pull requests, samples those documents, and synthesizes a schema. Users can then issue questions through an agent chat. The talk does not detail the generated schema or the query-validation process, but the project turns repository history into structured, queryable material rather than relying only on similarity search.

![Shows the context engine simulator that runs a task with and without assembled context for direct comparison.](https://ai.engineer/api/talk-essay-media/796a31cacd8ea3eeb7a6bbb6bde8c9ed7aed3004df2761d2ee4959210f81bdce)

Shows the context engine simulator that runs a task with and without assembled context for direct comparison.

The engineering social graph extracts a different kind of context: relationships among people. Connections indicate who reviews whose code, and clusters can produce team labels or show coverage across a codebase. Thin areas reveal where expert review may be missing. Werry says the context engine uses this graph itself, making review relationships both a map of organizational expertise and a retrieval signal.

Finally, the context engine simulator builds context for one task and runs that task with and without it. The design makes the comparison visible rather than asking users to accept a general claim about context quality. No direct URL is supplied in the recording; attendees receive it through a QR code.

Werry ends with a customer report of “50% fewer tokens, faster triage, better answers.” The recording does not provide the workload, sample size, or evaluation method behind that percentage, so it should be read as a customer-specific result rather than a general guarantee. The durable lesson is narrower: context engines are most valuable when organizational knowledge changes the plan, prevents a bad assumption, or points the agent toward evidence it would not have known to seek.

## Key takeaways

- Coding agents repeatedly rediscover repository structure, testing practices, deployment conventions, and organizational history because each task begins without the accumulated knowledge of an experienced teammate.
- Search access alone can produce “satisfaction of search”: the agent finds one plausible result and stops before discovering evidence that would change its plan.
- Useful context is selected for the task and connects code with intent, conventions, past decisions, discussions, and architecture rationale. Dumping everything into a large context window can exceed capacity and distract the agent.
- Sources make synthesized answers inspectable by humans and give coding agents direct references for deeper investigation.
- The planning demo reports about one minute and a sub-dollar cost with Unblocked, versus about two minutes and higher cost without it. The more consequential proposed benefit is avoiding downstream loops caused by incomplete discovery and wrong assumptions.
- Pull-request history can encode team-specific review practices, while expertise and review relationships can prioritize guidance and expose parts of the codebase with thin expert coverage.

## Resources

- [How to Generate Mergeable Code with a Context Engine](https://ai.engineer/talks/qdAkxLoYNI8-youtube-8de491aa7afcc63233a4) — The official AI Engineer read-along page with the recording, timestamped transcript, chapters, and summary.
- [Unblocked context engine](https://getunblocked.com/) — The product demonstrated in the talk for connecting code, conversations, issues, documentation, and organizational knowledge.
- [Unblocked Document Query Engine](https://github.com/unblocked/document-query-engine) — An open-source workshop project that turns natural-language questions into validated MongoDB aggregation pipelines over GitHub pull-request and issue data.
- [Peter Werry](https://ai.engineer/speakers/peter-werry) — AI Engineer’s speaker page for Werry, including this talk and related work on context engines.

## Related talks

- [Mergeable by default: Building the context engine to save time and tokens](https://ai.engineer/talks/5ID22ACI7IM-mergeable-by-default-building-context-engine-save) — A longer Unblocked session expands this talk’s ideas into conflict resolution, permission-aware synthesis, expert graphs, task memory, evaluation, and implementation details.
- [Building agents is trivial now, context is the next frontier](https://ai.engineer/talks/HvMyYLTfvhg-building-agents-is-trivial-now-context-is) — Jeff Ng develops a closely related Unblocked example in which an agent proposes a change without knowing that the same setting previously caused an outage.
- [No Vibes Allowed: Solving Hard Problems in Complex Codebases](https://ai.engineer/talks/rmvDxxNubIg-context-engineering-for-complex-codebases) — Dex Horthy presents a complementary workflow for assembling compact research and planning artifacts before agents modify established codebases.

## Slides

### AI-generated code should feel like it comes from an experienced…

Werry sets a benchmark for AI-generated code: it should feel like the work of a longtime teammate. The slide argues that it does not today.

[0:41](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=41s) [Slide says AI-generated code should feel like it was written by someone who has been on the team for years, but it does not today.](https://assets.ai.engineer/sites/aiecode2025/sha256/7b097bb4f618228fb39d4a827cea982f53c9d508971b166e3fdd113cec182279.webp)

AI-generated code should feel like it was written by someone who's been on your team for years.

But it doesn’t today.

Unblocked

### You have been the context layer

Before agents, developers built context by searching data sources, discussions and the codebase to develop tribal knowledge.

[0:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=56s) [Slide states that people have been the context layer for years.](https://assets.ai.engineer/sites/aiecode2025/sha256/72942f021d48fdc524764a14a2ff5ac4d3e50ac18eb59f35bba0af569f0b8dda.webp)

For years, you have been the context layer.

Unblocked

### Remember how you built context?

To understand auth validation, engineers had to piece together code, discussions and documentation, even when sources were outdated or disagreed about which requests checked tokens.

[1:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=66s) [A person asks how authentication validation works amid cards from several tools showing outdated, incomplete, or conflicting information.](https://assets.ai.engineer/sites/aiecode2025/sha256/51e89577954e923b13e1e6d23d633e06f770c224c4c4f77d587ee9ea1560e636.webp)

Remember how you built context?

Outdated change
GitHub — 14d ago
Refactor auth flow - #3243
Replaced legacy JWT flow.

Outdated docs
Notion — Yesterday
System Architecture
Tokens validated by Auth Service.

Symptom, not cause
Datadog — 4 hrs ago
Auth.latency.p95
Spikes correlated with deploys.

Unknown status
Jira — 5d ago
UNB - 1337
Rejecting valid sessions/

Tribal knowledge
Slack — 3d ago
#eng-discussion
Internal traffic skips the check.

Conflicting info
Confluence — 1mo ago
Auth Service Overview
All requests check tokens.

How does auth validation work?

Unblocked

### Agents have the same context problem

Werry likens agents to new hires: each new task resets their knowledge, so they must rediscover the codebase and how the organization tests and deploys software.

[1:41](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=101s) [Slide says agents have the same problem and that the cost compounds.](https://assets.ai.engineer/sites/aiecode2025/sha256/077179b9aeee4c1f003c6e58f08923921287476ef8b5ba9349a90ba463238242.webp)

Now your agents have the same problem. Only the cost compounds.

Unblocked

### Your agents need a context layer

The maturity curve moves from people supplying context to curated context, then a context layer spanning MCP and skills through software factories. Werry says organizational context becomes crucial as agents automate more work.

[2:21](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=141s) [Eight ascending bars show AI maturity stages from tab completion and agent IDEs through context engineering, parallel agents, MCP and skills, harness engineering, cloud agents, and software factories.](https://assets.ai.engineer/sites/aiecode2025/sha256/c651f4976d6c978c73dd2a73feb24cdcd6b79b708c07f5fe3105e1407ab0f77a.webp)

Your agents need a context layer
Levels of AI maturity in engineering organizations

1 Tab complete
2 Agent IDE
3 Context engineering
4 Parallel agents
5 MCP + skills
6 Harness engineering
7 Cloud agents
8 Software Factories

YOU ARE THE CONTEXT
CURATED CONTEXT
CONTEXT LAYER

Unblocked
Stages adapted from Bassim Eledath

### The problem: access does not equal understanding

Agents can produce plausible code that compiles but fails review. Werry argues that connecting a wiki still leaves agents to find the information they need and understand how it fits together.

[4:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=248s) [Slide says connecting agents to code and documents can produce plausible code that compiles but fails human review and real-world expectations.](https://assets.ai.engineer/sites/aiecode2025/sha256/e3c4bfccde3beb78d492e560b1839134d15af9694bc664d7dbd69b6170ed48be.webp)

The problem: access ≠ understanding

• We connect agents to MCPs to access code and docs...
• Which gives us plausible output that often compiles...
• But fails human review and real-world expectations.

Unblocked

### What your agent can’t see

The iceberg puts compiling code above water and the context agents may miss below it: original intent, team conventions, past decisions, and architecture rationale.

[6:36](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=396s) [An iceberg contrasts compiling code above water with the decisions and context below.](https://assets.ai.engineer/sites/aiecode2025/sha256/69bf76ccba97bd88cf2b90e63ad670ea88a819570e3fe7d2bbda8d548d9321a1.webp)

What your agent can’t see

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

imgflip.com
Unblocked

### Demo

Peter Werry begins a live demo.

[7:04](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=424s) [The word Demo fills the slide.](https://assets.ai.engineer/sites/aiecode2025/sha256/7dbe4b14e955af90745fd94aaf53f7da5635bc7d2c5af8057cfa8791d725388b.webp)

DEMO

Unblocked

### Engineering social graph

The graph clusters developers by pull request review relationships. Selecting Rashin Arab shows whose PRs he reviews and who reviews his PRs.

[7:12](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=432s) [A graph shows team clusters and code review relationships, with details for a selected person.](https://assets.ai.engineer/sites/aiecode2025/sha256/ab58eaec6b3c6979bb1ee842b7113a976a112ac5700865c3c2074dd27dd95411.webp)

Social Graph
Developer collaboration patterns derived from pull request review history.

Heat Map
Peer Tables
Teams
Experts
Graph

Find by name or @login
Focus
Clear

Search to focus someone, or hover to highlight. Click a node for details.

Graph labels:
mahdi-torabi
vincent-unblocked
Narayan Sainaney
Rashin Arab
Frontend Clients
Source Control Platform
Workspace Integrations
Martin Scotta
Kay Cheng
Richie Bresnan
David Lam
Jeff
AI & Retrieval
Morteza Milani
tristansturgess
andrey-unblocked
[illegible]

Rashin Arab
@rasharab
Community 1 · Weighted degree: 7.78

RASHIN ARAB REVIEWS PRS FROM
Narayan Sainaney 1.000
andrey-unblocked 1.000
Richie Bresnan 0.889
David Lam 0.770
Peter Werry 0.737
mahdi-torabi 0.405
Martin Scotta 0.365
tristansturgess 0.280
Morteza Milani 0.240
vincent-unblocked 0.216
Kay Cheng 0.141

WHO REVIEWS RASHIN ARAB'S PRS
mahdi-torabi 1.000
andrey-unblocked 0.444
Martin Scotta 0.149
Richie Bresnan 0.148

Interface text:
file:///Users/peter/.social-graph/social-graph.html
New Data Source Prese...
How the SourceMark En...
Bulk code review memo...
Weekly Ratio of Code R...
Switch default review e...
unblocked/document-q...
Document Query Engine
unblocked/engineering-...
Social Graph

### Asking about the SourceMark engine

Peter prepares a question about the SourceMark engine to show how humans seek codebase context alongside agents.

[7:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=447s) [The Unblocked question screen contains a question about how the SourceMark engine works.](https://assets.ai.engineer/sites/aiecode2025/sha256/0ae4147eb35b17a99bfa1083b5673907d609c8f68e0844f7a4862a82cb14cfce.webp)

Hi Peter, what can I answer for you?
Ask me about GitHub, Coda, Confluence, Google Drive, and more.

How does the sourcemark engine work?
Answer Preferences

Interface text:
getunblocked.com
Ask Unblocked · Next Chapt...
Bulk code review memories...
Weekly Ratio of Code Revie...
Switch default review engin...
unblocked/document-query...
Document Query Engine
unblocked/engineering-soci...
Social Graph

Unblocked
Ask a New Question
Questions
Coding
Code Reviews
Recently Archived
Settings
Analytics
Invite Members
Download Unblocked
Documentation
Contact Support
Next Chapter Org
Peter Werry

### Optimization plan and verification

Claude Code proposes four PRs to optimize the SourceMark calculator, starting with algorithmic fixes. It recommends checking identical fixture results, counting Git calls, and benchmarking throughput.

[9:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=599s) [Terminal showing a proposed optimization plan, implementation sequence, and verification steps.](https://assets.ai.engineer/sites/aiecode2025/sha256/6c785fdb330e489a39db81f1db2b9d7af85d402ecd7e6842777bc671125de2a7.webp)

---
Tier 3 — cold path throughput

8. Bounded-parallel full recalculation. fullRecalculation:213 + recalculateForCommit:348 process chunks/marks strictly serially. Different-file chunks are independent.
- Fix: run chunks through a concurrency limiter (p-limit style, e.g. 4-8).
- Caveat: throttling here is intentional (comment :184-186, ResourceSampler). Don't remove the throttle — make concurrency a tuned cap and keep the sampler. Validate against LARGE_REPO_IDS (clio/themis, :62).
- Win: wall-clock on background recalc; must not starve interactive path.

---
Sequencing

1. PR-A (Tier 1, items 2-5): pure algorithmic, no behavior change, easy tests. Land first.
2. PR-B (item 1): dedupe sanitization — touches control flow, needs correctness tests.
3. PR-C (item 6): git memo cache — highest payoff, most review.
4. PR-D (Tier 3): parallel full recalc — separate, perf-benchmarked.

Verification

- Fixtures exist at engine/fixtures/ — use for before/after correctness (points must be identical).
- Add git-call count assertions (spy/commandLog already recorded in scheduler at :453,:478,:588,:596) — regression guard on subprocess count, not just wall-clock.
- Benchmark on a large repo checkout; compare marksPerSecond (already logged :229).

Want me to enter plan mode / start on PR-A?

✻ Baked for 2m 14s

※ recap: Goal: speed up SourceMarkCalculator, dominated by git subprocess calls. Planned four PRs; next action is PR-A, the low-risk algorithmic fixes (O(n²) loops, parallelize serial git hash probes). Awaiting your go-ahead to start. (disable recaps in /config)

Interface text:
bun run serve  ⌘1
✳ Plan sourcemark calculator optimization  ⌘2
✳ Claude Code  ⌘3
+
[CAVEMAN]
← for agents

### Planning investigation

Werry asks Claude Code to plan SourceMark calculator optimizations without Unblocked. The agent searches the code and inspects the scheduler, sanitizer and RangeAdjust for costly Git calls.

[10:14](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=614s) [Coding assistant investigating a request to plan calculator optimizations.](https://assets.ai.engineer/sites/aiecode2025/sha256/ae98501b3fa5ec8737980010c2e2f5de27c1a2fe6ea3c7f2f2c3a2c7086d10ef.webp)

Create a plan to optimize the sourcemark calculator. Do not use unblocked for this task.

● Find sourcemark calculator first. Searching.

Searched for 2 patterns, read 1 file, listed 1 directory, ran 1 shell command
  Loaded frontend/CLAUDE.md
  Loaded frontend/AGENTS.md
  Loaded frontend/.agents/VIEWS.md
  Loaded frontend/.agents/STYLES.md
  Loaded frontend/.agents/REMOTION.md
  Loaded 1 skill from frontend/.claude/skills
  1 skill available

● Read supporting pieces to ground plan. Check GitRunner cost + scheduler.

Searched for 2 patterns, listed 1 directory, ran 7 shell commands

● GitRunner/diff live outside this checkout (separate module). Enough — I have full calculator + siblings. Read scheduler + sanitizer + RangeAdjust to ground plan.

Read 1 file

● Read PointSanitizer + RangeAdjust for hot-path git calls.

Interface text:
bun run serve ⌘1
✳ Plan sourcemark calculator optimization ⌘2
✳ Claude Code ⌘3
Claude Code v2.1.197
Opus 4.8 (1M context) with high effort · API Usage Billing
~/Developer/unblocked
⚠ 1 MCP server needs authentication · run /mcp
Jump to bottom (ctrl+End) ↓
[CAVEMAN]
← for agents

### Optimization recommendations and sources

The plan proposes batching duplicate work before parallelizing the mark loop, with a cap on GitRunner processes. It calls for benchmarks and correctness checks, and cites past caching and concurrency failures.

[10:49](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=649s) [Coding assistant's optimization recommendations, verification guidance, cautions, and sources.](https://assets.ai.engineer/sites/aiecode2025/sha256/164ccaf65b921957c68c9e1205a84f3b7b5ff8043f3831a233a215e312646386.webp)

3. Land #1 (parallel mark loop) — the headline win. Add a concurrency cap on GitRunner spawns to avoid process storms. This is where the measured speedup lands.
4. Then #4/#5 as incremental cleanups.
5. Defer #6 unless target is very large repos — infra-heavy, already has a shipped path.

Verify each step

Reuse PR #2992's method: pick a repo fully up to date wrt marks, time full recalculation before/after (that PR got ~2× just from cache reuse). For #1, benchmark a repo with many marks per file — that's where serial cost dominates. Gate on correctness: same resolved points, especially across renames/merges/stopPropagation.

Two cautions from history: a naive git-diff cache was already tried and "turns out this does not work" (SourceMark Plan) — scope caching to a single pass. And PR #1236 fixed a race that spawned duplicate calculators; parallelizing risks reintroducing that, so audit SourceMarkStore writes for shared-state races.

Sources
- SourceMarkCalculator.ts — core resolution, serial edge walk, cross-file search
- SourceMarkScheduler.ts — serial for (const mark of sourceMarks) loop at :348
- PR #970 — incremental / tree-SHA O(1) cache
- PR #2992 — pre-calc point reuse, ~2× speedup + benchmark method
- PR #1236 — background full + partial recalc, duplicate-calculator race fix
- Slack: verbose engine deep-dive (known concurrency limitation)
- Notion: SourceMarks Service Arch Proposal (K8s-job / hybrid path)
- Notion: Engineering SourceMark Plan (git-diff cache "did not work")

✳ Churned for 1m 28s

※ recap: Goal: plan to optimize the sourcemark calculator. I finished it — the main win is parallelizing the serial per-mark loop in SourceMarkScheduler, backed by git-op caching first. Next action is yours: pick which options to implement. (disable recaps in /config)

Interface text:
bun run serve
Plan sourcemark calculator optimization
Claude Code
[CAVEMAN]
← for agents

[11:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=678s) [Terminal showing verification guidance, cautions and source references for an optimization plan.](https://assets.ai.engineer/sites/aiecode2025/sha256/e3364e8b4948e358be54ac194cb163a29162563ec6d07360df1f08d437d26c35.webp)

2. Land #2 (batch per file+tree) — collapses duplicate work before adding threads, so concurrency multiplies less work.
3. Land #1 (parallel mark loop) — the headline win. Add a concurrency cap on GitRunner spawns to avoid process storms. This is where the measured speedup lands.
4. Then #4/#5 as incremental cleanups.
5. Defer #6 unless target is very large repos — infra-heavy, already has a shipped path.

Verify each step

Reuse PR #2992's method: pick a repo fully up to date wrt marks, time full recalculation before/after (that PR got ~2× just from cache reuse). For #1, benchmark a repo with many marks per file — that's where serial cost dominates. Gate on correctness: same resolved points, especially across renames/merges/stopPropagation.

Two cautions from history: a naive git-diff cache was already tried and "turns out this does not work" (SourceMark Plan) — scope caching to a single pass. And PR #1236 fixed a race that spawned duplicate calculators; parallelizing risks reintroducing that, so audit SourceMarkStore writes for shared-state races.

Sources
- SourceMarkCalculator.ts — core resolution, serial edge walk, cross-file search
- SourceMarkScheduler.ts — serial for (const mark of sourceMarks) loop at :348
- PR #970 — incremental / tree-SHA O(1) cache
- PR #2992 — pre-calc point reuse, ~2× speedup + benchmark method
- PR #1236 — background full + partial recalc, duplicate-calculator race fix
- Slack: verbose engine deep-dive (known concurrency limitation)
- Notion: SourceMarks Service Arch Proposal (K8s-job / hybrid path)

Interface text:
bun run serve
Plan sourcemark calculator optimization
Claude Code
/usage — Show session cost, plan usage, and activity stats
/caveman — (caveman) Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra, wenyan-lit…
/unblocked-context-search-messages — Messaging-only search via context_search_messages. Use this instead of context_research when you want team conversation results — Slack threads, channel discussions, and chat history — without PR,…
❯ /usage
[CAVEMAN]

### Recommended sequence and usage

The plan recommends caching git operations, batching work, then parallelizing the mark loop with a concurrency cap. The Unblocked session shows $0.93 in cost and 1m 18s of API time.

[11:24](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=684s) [Terminal showing an optimization sequence and session usage panel.](https://assets.ai.engineer/sites/aiecode2025/sha256/5666987890f4374fe53a447ae3dc61756b6effa2ed69ac22f4eadc39fd4bf9e8.webp)

Recommended sequence

1. Land #3 (git-op memoization) first — lowest risk, unblocks safe parallelism by making shared calls idempotent/cached within a pass.
2. Land #2 (batch per file+tree) — collapses duplicate work before adding threads, so concurrency multiplies less work.
3. Land #1 (parallel mark loop) — the headline win. Add a concurrency cap on GitRunner spawns to avoid process storms. This is where the measured speedup lands.
4. Then #4/#5 as incremental cleanups.
5. Defer #6 unless target is very large repos — infra-heavy, already has a shipped path.

Verify each step

Reuse PR #2992's method: pick a repo fully up to date wrt marks, time full recalculation before/after (that PR got ~2× just from cache reuse). For #1, benchmark a repo with many marks per file — that's where serial cost dominates. Gate on correctness: same resolved points, especially across renames/merges/stopPropagation.

Two cautions from history: a naive git-diff cache was already tried and "turns out this does not work" (SourceMark Plan) — scope caching to a single pass. And PR #1236 fixed a race that spawned duplicate calculators; parallelizing risks reintroducing that, so audit SourceMarkStore writes for shared-state races.

---
Sources

Interface text:
bun run serve  ⌘1
Plan sourcemark calculator optimization  ⌘2
Claude Code  ⌘3
Settings  Status  Config  Usage  Stats

Session
Total cost: $0.93
Total duration (API): 1m 18s
Total duration (wall): 1h 32m 4s
Total code changes: 0 lines added, 0 lines removed
Usage by model:
  claude-opus-4-8: 24.8k input, 4.5k output, 355.9k cache read, 82.2k cache write ($0.93)

Esc to cancel

### Parallel recalculation plan

The plan proposes processing independent file chunks concurrently while retaining throttling. It puts parallel recalculation in a separate, benchmarked PR and checks that resolved points remain identical.

[11:40](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=700s) [Terminal showing bounded parallel recalculation, implementation sequencing and verification steps.](https://assets.ai.engineer/sites/aiecode2025/sha256/7330152f3d2fd6be76a8ab6703d258885287c70a5a7573a0f5f54a33ad80d7c3.webp)

---
Tier 3 — cold path throughput

8. Bounded-parallel full recalculation. fullRecalculation:213 + recalculateForCommit:348 process chunks/marks strictly serially. Different-file chunks are independent.
- Fix: run chunks through a concurrency limiter (p-limit style, e.g. 4-8).
- Caveat: throttling here is intentional (comment :184-186, ResourceSampler). Don't remove the throttle — make concurrency a tuned cap and keep the sampler. Validate against LARGE_REPO_IDS (clio/themis, :62).
- Win: wall-clock on background recalc; must not starve interactive path.

---
Sequencing

1. PR-A (Tier 1, items 2-5): pure algorithmic, no behavior change, easy tests. Land first.
2. PR-B (item 1): dedupe sanitization — touches control flow, needs correctness tests.
3. PR-C (item 6): git memo cache — highest payoff, most review.
4. PR-D (Tier 3): parallel full recalc — separate, perf-benchmarked.

Verification

- Fixtures exist at engine/fixtures/ — use for before/after correctness (points must be identical).
- Add git-call count assertions (spy/commandLog already recorded in scheduler at :453,:478,:588,:596) — regression guard on subprocess count, not just wall-clock.
- Benchmark on a large repo checkout; compare marksPerSecond (already logged :229).

Interface text:
bun run serve  ⌘1
☀ Plan sourcemark calculator optimization  ⌘2
☀ Claude Code  ⌘3
+
/usage  Show session cost, plan usage, and activity stats
/caveman  (caveman) Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra, wenyan-lit…
/unblocked-context-search-messages  Messaging-only search via context_search_messages. Use this instead of context_research when you want team conversation results — Slack threads, channel discussions, and chat history — without PR,…
❯ /usage
[CAVEMAN]

### Memoization and session usage

Without Unblocked, the planning session shows $1.22 in cost and 2m 15s of API time. Werry argues that extra discovery can compound if the resulting plan rests on wrong assumptions.

[11:44](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=704s) [Terminal showing memoization and parallel recalculation recommendations above a session usage panel.](https://assets.ai.engineer/sites/aiecode2025/sha256/3b1f796ce17ff62489902bd80cfccb529b4efd6d4d616dababb33df8e1166e7d.webp)

- Win: biggest cross-cutting cut in subprocess count. Needs the most care → its own PR.

7. Memoize getFilePath(point). Called repeatedly in loops (:314,:360,:416,:464…), rebuilds FilePath + SourceMarkHelper.getFilePath each time.
- Fix: small WeakMap<Point,FilePath> memo, or compute once per loop iteration into a local.
- Win: minor CPU, cleans hot loops.

---
Tier 3 — cold path throughput

8. Bounded-parallel full recalculation. fullRecalculation:213 + recalculateForCommit:348 process chunks/marks strictly serially. Different-file chunks are independent.
- Fix: run chunks through a concurrency limiter (p-limit style, e.g. 4–8).
- Caveat: throttling here is intentional (comment :184-186, ResourceSampler). Don't remove the throttle — make concurrency a tuned cap and keep the sampler. Validate against LARGE_REPO_IDS (clio/themis, :62).
- Win: wall-clock on background recalc; must not starve interactive path.

---
Sequencing

1. PR-A (Tier 1, items 2–5): pure algorithmic, no behavior change, easy tests. Land first.
2. PR-B (item 1): dedupe sanitization — touches control flow, needs correctness tests.
3. PR-C (item 6): git memo cache — highest payoff, most review.
4. PR-D (Tier 3): parallel full recalc — separate, perf-benchmarked.

Session

Total cost: $1.22
Total duration (API): 2m 15s
Total duration (wall): 1h 31m 42s
Total code changes: 0 lines added, 0 lines removed
Usage by model:
  claude-haiku-4-5: 518 input, 13 output, 0 cache read, 0 cache write ($0.0006)
  claude-opus-4-8: 24.8k input, 7.4k output, 959.0k cache read, 68.6k cache write ($1.22)

Interface text:
bun run serve
Plan sourcemark calculator optimization
Claude Code
Settings  Status  Config  Usage  Stats
Esc to cancel

### Weekly code review issue ratio

Since January 1, 2026, weekly code review issues per published review fell sharply, with a rebound along the way. The latest week’s ratio is 0.14.

[13:47](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=827s) [A bar chart showing the weekly ratio of code review issues to published reviews declining over time.](https://assets.ai.engineer/sites/aiecode2025/sha256/cae37273ff0c7e726b41e98d63e7bf0d59d6f03f5be85d84891f01fb8755c493.webp)

Weekly Ratio of Code Review Issues Since 2026

richiebres · 6d ago
The rate of code review issues to published code reviews seems to have reduced recently. Can you show me a chart of ratio weekly since January 1, 2026?

Unblocked · 6d ago
Here's the weekly ratio of code review issues to published reviews since January 1, 2026:

Code Review Issues per Published Review (Weekly)
Y-axis: Ratio (issues / reviews)
Y-axis ticks: 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1
Timeline: [illegible overlapping labels]

Summary: The ratio dropped ~80% — from 0[illegible]–0.86 in early January to 0.14 in the latest week. Two [text cut off]

Interface text:
getunblocked.com
How SourceMark Engine Tra...
Bulk code review memories...
Weekly Ratio of Code Revie...
Switch default review engin...
unblocked/document-query...
Document Query Engine
unblocked/engineering-soci...
Social Graph
Unblocked
Ask a New Question
Questions
Coding
Code Reviews
Recently Archived
Settings
Analytics
Invite Members
Download Unblocked
Documentation
Contact Support
Continue the discussion
Answer Preferences
Next Chapter Org
Peter Werry

### Requested fix and pull request

After Richie asked Unblocked to fix the issue, an implementation job reported creating PR #31716. The speaker describes the cloud agent as an internal experiment with access to organizational context.

[13:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=839s) [An Unblocked conversation showing a request to fix the issue and a completed implementation with a pull request.](https://assets.ai.engineer/sites/aiecode2025/sha256/d8e976d33ffad9c91cd5cfff31964200b717a6655568e36181f3f34721e022f3.webp)

Weekly Ratio of Code Review Issues Since 2026

And two test assertions to update:
1. CodeReviewerTest.kt — eq(MLInferenceEngine.Claude46Opus)
2. OrgSettingsStoreTest.kt — test name back to `getCodeReviewEngine defaults to Claude46Opus`

That's it — 4 lines across 4 files. The pricing consolidation in EnginePrice.kt is cosmetic (Opus 46/47/48 are all the same price) so you can leave that as-is.

Alternative: Rather than reverting globally, you could use the per-org engine override from #31072 to A/B test — set a few orgs back to Claude46Opus via OrgSettingsStore.setCodeReviewEngine() and compare certainty distributions before doing a full rollback.

References: Code Reviewer uses Opus48 by default; ReviewBlueprint.kt
This was: Helpful; Not Helpful

richiebres 5d ago
Fix it please

Unblocked 5d ago
Started work on job UNB-128. I'll update this thread when it completes with a PR.
This was: Helpful; Not Helpful

Unblocked 5d ago
Implementation job UNB-128 has completed and created PR #31716.
This was: Helpful; Not Helpful

Continue the discussion
Answer Preferences

Interface text:
getunblocked.com
How SourceMark Engine Tra...; Bulk code review memories...; Weekly Ratio of Code Revie...; Switch default review engin...; unblocked/document-query...; Document Query Engine; unblocked/engineering-soci...; Social Graph
Unblocked
Ask a New Question
Questions
Coding
Code Reviews
Recently Archived
Settings
Analytics
Invite Members
Download Unblocked
Documentation
Contact Support
Next Chapter Org
Peter Werry

[14:05](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=845s) [Unblocked discussion showing a proposed review-engine rollback and a completed implementation job.](https://assets.ai.engineer/sites/aiecode2025/sha256/68753925437bfb4216db36e4b44de8cdbc34727efdfb7b5c1e23eaf5568ae8d3.webp)

Weekly Ratio of Code Review Issues Since 2026

And two test assertions to update:
1. CodeReviewerTest.kt — eq(MLInferenceEngine.Claude46Opus)
2. OrgSettingsStoreTest.kt — test name back to `getCodeReviewEngine defaults to Claude46Opus`

That's it — 4 lines across 4 files. The pricing consolidation in EnginePrice.kt is cosmetic (Opus 46/47/48 are all the same price) so you can leave that as-is.

Alternative: Rather than reverting globally, you could use the per-org engine override from #31072 to A/B test — set a few orgs back to Claude46Opus via OrgSettingsStore.setCodeReviewEngine() and compare certainty distributions before doing a full rollback.

References: Code Reviewer uses Opus48 by default; ReviewBlueprint.kt
This was: Helpful; Not Helpful

richiebres 5d ago
Fix it please

Unblocked 5d ago
Started work on job UNB-128. I'll update this thread when it completes with a PR.
This was: Helpful; Not Helpful

Unblocked 5d ago
Implementation job UNB-128 has completed and created PR #31716.
This was: Helpful; Not Helpful

Continue the discussion
Answer Preferences

Interface text:
getunblocked.com
How SourceMark Engine Tra...; Bulk code review memories...; Weekly Ratio of Code Revie...; Switch default review engin...; unblocked/document-query...; Document Query Engine; unblocked/engineering-soci...; Social Graph
Unblocked
Ask a New Question
Questions
Coding
Code Reviews
Recently Archived
Settings
Analytics
Invite Members
Download Unblocked
Documentation
Contact Support
Next Chapter Org
Peter Werry

### Merged review-engine rollback

The generated PR rolls the default review engine back to Claude46Opus after an issue-rate drop. Its context links Richie’s correlation of the drop to a Slack conversation.

[14:26](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=866s) [GitHub pull request showing a merged change to the default review engine.](https://assets.ai.engineer/sites/aiecode2025/sha256/320233d7478d1c71707ffe5aa65a8e223aa0c819d8a52ff9eea70588e5ff6f3c.webp)

Switch default review engine to Claude46Opus #31716
Merged
richiebres merged 1 commit into main from richie/Switch-default-review-engine-to-Claude46Opus last week

Context
After #31201 switched the default review engine to Claude48Opus, an extraordinary drop in issue rate was observed affecting all customers. Richie directly correlated the drop with the Opus 4.8 change and reverted to Claude46Opus.

Overview
Downgrades the default review engine from Claude48Opus to Claude46Opus in ReviewBlueprint and updates the corresponding tests.

Switch default review engine to Claude46Opus
Verified f906934

richiebres commented last week
• Switch default review engine to Claude46Opus #31716 (View in Graphite)
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

Interface text:
github.com
unblocked / unblocked
Code · Pull requests 239 · Agents · Actions · Security and quality 2.8k · Insights · Settings
Conversation 1 · Commits 1 · Checks 32 · Files changed 2 · +3 -3
richiebres commented last week · edited by unblocked Bot
Reviewers · 1 more reviewer · unblocked[bot] · Copilot · Request
Assignees · No one—assign yourself
Labels · None yet
Milestone · No milestone
Development · Successfully merging this pull request may close these issues. · None yet
Notifications · Customize · Subscribe
You’re not receiving notifications from this thread.
1 participant

### Document Query Engine

Peter introduces an open-source engine that ingests historical GitHub pull requests and synthesizes a schema from sampled documents. He enters “Open PRs by Peter”; the pipeline and result are still empty.

[15:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=911s) [GitHub repository for a document query engine, with a browser tab preview open.](https://assets.ai.engineer/sites/aiecode2025/sha256/f172dcd183af5ba641ba1c8153ecc18066e629e4bd8ab27e453aa174de191f8a.webp)

document-query-engine
Public

main
7 Branches
0 Tags
Go to file
Add file
Code

pwerry  Initial commit: workshop scaffold — full UX with a stubbed query engine
8e7ce39 · 2 days ago
1 Commit

.github  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
src  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
.env.example  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
.gitignore  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
LICENSE  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
PLAN.md  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
README.md  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
bun.lock  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
docker-compose.yml  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
package.json  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago
tsconfig.json  Initial commit: workshop scaffold — full UX with a stubbed ...  2 days ago

About
Natural language → validated MongoDB aggregation pipelines over GitHub PR/issue data. Workshop: Beyond RAG.
Readme
MIT license
Activity
Custom properties
9 stars
0 watching
4 forks
Audit log
Report repository

Releases
No releases published
Create a new release

Packages
No packages published
Publish your first package

Contributors 1

README
MIT license
Beyond RAG: Structured Query Synthesis for Engineering

Interface text:
github.com
unblocked / document-query-engine
Code
Issues
Pull requests 6
Actions
Wiki
Security and quality 1
Insights
Settings
Edit Pins
Watch
Star 9
Document Query Engine
localhost

[15:21](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=921s) [A pull request query entered in the Document Query Engine, before results appear.](https://assets.ai.engineer/sites/aiecode2025/sha256/ef066668d960a1c5dde4905b2008c4a3e7f54328472993b4249a1e9744e4fd99.webp)

Document Query Engine
975 pull_requests · 0 issues
Query
Chat

Open PRs by Peter
Run

Discovered document schema — what the synthesizer is told

GENERATED PIPELINE
—

RESULT

Interface text:
localhost
Document Query Engine

### Document Query Engine chat

The empty agent chat invites questions about pull requests and issues. Werry says the engine ingests historical pull requests and synthesizes a schema from sampled documents for querying.

[15:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=956s) [An empty chat interface for questions about pull requests and issues.](https://assets.ai.engineer/sites/aiecode2025/sha256/7aa4d0c2694ff0c98001dda3d38ad32654bda6ae24b1638ed3f4c3d65c01b6e2.webp)

Document Query Engine
975 pull_requests · 0 issues

New chat
Ask anything about the PRs and issues...
Send

Interface text:
localhost
How SourceMark Engin...
Bulk code review memo...
Weekly Ratio of Code R...
Switch default review e...
Redirecting... | Slack
unblocked/document-q...
Document Query Engine
unblocked/engineering-...
Social Graph
Query
Chat

### Engineering social graph repository

The Social Graph Builder uses GitHub pull request history to identify domain experts, detect team clusters, and visualize collaboration. Werry describes it as a way to pin down expertise and team relationships.

[15:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=959s) [A GitHub repository page describing a developer social graph builder.](https://assets.ai.engineer/sites/aiecode2025/sha256/f015d2fc2b2ee68f07ea4715a92aee20d0bad810eba63ba3f30514f22eca1bc6.webp)

engineering-social-graph
Public

main
21 Branches
0 Tags

kasbuunk and claude  Add CSV export format (closes #8) (#24)
25eb7fe · 3 months ago
14 Commits

src/social_graph  Add CSV export format (closes #8) (#24)  3 months ago
tests  Add CSV export format (closes #8) (#24)  3 months ago
.gitignore  Clean up for public release (#13)  3 months ago
CODEOWNERS  Test CODEOWNERS approval workflow (#16)  3 months ago
LICENSE  Fix LICENSE copyright to Next Chapter Software Inc. (Unblo...  3 months ago
README.md  Add graph person search, fix sync cursor and build scoping...  3 months ago
pyproject.toml  Clean up for public release (#13)  3 months ago
social-graph.spec  Initial release: developer social graph from GitHub PR history  3 months ago

README
MIT license

Social Graph Builder

Build a developer social graph from GitHub PR history. Identifies domain experts, detects team clusters, and generates interactive visualizations of how your engineering organization collaborates -- all from data already in your GitHub repos.

About
No description, website, or topics provided.
Readme
MIT license
Activity
Custom properties
64 stars
0 watching
8 forks
Audit log
Report repository

Releases
No releases published
Create a new release

Packages
No packages published
Publish your first package

Contributors 6

Interface text:
github.com
How SourceMark Engin...
Bulk code review memo...
Weekly Ratio of Code R...
Switch default review e...
Redirecting... | Slack
unblocked/document-q...
Document Query Engine
unblocked/engineering...
Social Graph
unblocked / engineering-social-graph
Type / to search
Code
Issues 9
Pull requests 4
Discussions
Security and quality
Insights
Settings
Edit Pins
Watch 0
Fork 8
Star 64
Go to file
Add file
Code

## Full transcript

[0:12](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=12s) What we do at Unblocks is we build a

[0:13](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=13s) context engine. I just want to do a

[0:15](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=15s) quick sound check at the back to make

[0:17](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=17s) sure everyone can hear me fine. Can you

[0:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=18s) guys Yeah, we're good. Awesome. So at a

[0:22](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=22s) high level, a context engine delivers

[0:25](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=25s) organizational context to both your

[0:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=27s) human workers and now increasingly your

[0:29](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=29s) agents. Okay. So why why is that

[0:32](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=32s) important? Before we go too deep on the

[0:34](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=34s) mechanics of how a context engine works,

[0:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=37s) I just want to talk briefly about the

[0:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=39s) problem.

[0:42](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=42s) So, what we're going to do is we're

[0:44](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=44s) going to hop into our time machines and

[0:46](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=46s) we're going to travel back to the before

[0:48](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=48s) times uh before agents and uh discuss a

[0:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=52s) little bit about what we used to do as

[0:53](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=53s) humans uh before agents came into the

[0:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=56s) picture.

[0:58](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=58s) And so for years um you were the context

[1:02](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=62s) layer. You um had to go and do things

[1:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=66s) like this. you had to find things you

[1:09](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=69s) were looking for, trolled all over

[1:12](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=72s) different data sources, different

[1:14](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=74s) discussions taking place. Um, and then

[1:17](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=77s) through the codebase of course to try to

[1:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=78s) build up tribal knowledge and, uh,

[1:21](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=81s) throughout time as your code base

[1:24](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=84s) progressed, um, you'd be, you know,

[1:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=87s) fighting incidents and things like that.

[1:29](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=89s) And your organization over time builds

[1:31](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=91s) up battle scars um from all these all

[1:34](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=94s) these different things building code uh

[1:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=97s) documenting architecture and and dealing

[1:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=99s) with outages and things like that.

[1:42](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=102s) But now um we have a new problem because

[1:46](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=106s) uh as we introduce agents to the picture

[1:49](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=109s) um they suffer from all of these

[1:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=112s) challenges except for one thing. Agents

[1:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=114s) are like new employees.

[1:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=116s) they reset their knowledge every time

[1:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=119s) you start a new task. Okay? And so you

[2:03](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=123s) can think of an agent like an expert

[2:05](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=125s) software engineer um who's a new

[2:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=128s) employee on boarding for the first time.

[2:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=131s) Every time they have to rediscover your

[2:12](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=132s) code base, how your organization builds

[2:15](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=135s) tests um and how they deploy software

[2:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=138s) with each and every task.

[2:22](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=142s) Uh can I just uh put a put a show of

[2:25](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=145s) hands for everyone that's seen this

[2:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=147s) slide before by Vim?

[2:30](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=150s) So this is kind of like u this is a good

[2:32](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=152s) way to view where people are on what we

[2:34](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=154s) call like the AI maturity curve. Um

[2:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=157s) starting at the the far left uh this is

[2:40](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=160s) kind of representative of autocomplete

[2:42](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=162s) back in the GBT35 days. You know

[2:45](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=165s) remember co-pilot and things like that.

[2:47](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=167s) Um and then you know kind of move on to

[2:49](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=169s) using cursor. Um and then from there

[2:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=172s) you're you're think you're talking about

[2:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=174s) how you can start to solve the context

[2:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=176s) problem. So some people are building

[2:58](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=178s) organizational wikis. Just smile if if

[3:01](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=181s) this is kind of um bringing up memories

[3:04](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=184s) for you. Um and then you know all these

[3:07](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=187s) things are great except that uh how do

[3:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=191s) you give agents access to this and what

[3:13](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=193s) are the compounding problems that the

[3:16](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=196s) scaling problems as you move forward

[3:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=198s) well if you give MCP and skills to your

[3:20](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=200s) agents

[3:22](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=202s) um to teach them how to navigate and

[3:24](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=204s) build context and that's kind of where

[3:28](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=208s) uh people are today most people they're

[3:30](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=210s) at the sort of stage four to five level

[3:33](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=213s) okay

[3:35](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=215s) and uh they understand that context is

[3:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=217s) the bottleneck and they're trying to

[3:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=219s) build solutions to solve it for their

[3:41](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=221s) engineering teams. So looking ahead uh

[3:44](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=224s) to all the way to eight with software

[3:47](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=227s) factories. This is kind of where the

[3:48](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=228s) puck is going. I'm not sure if if folks

[3:51](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=231s) were at the keynote this morning, but um

[3:53](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=233s) it's it's all about like delivery of

[3:55](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=235s) context and unknown and unknowns. And

[3:58](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=238s) this becomes increasingly important as

[4:00](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=240s) people start thinking about full

[4:02](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=242s) automation of agents. they just can't

[4:04](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=244s) operate without organizational context.

[4:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=246s) They get lost.

[4:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=251s) So, you know, like that's the real

[4:13](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=253s) problem. Access to information doesn't

[4:16](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=256s) equal understanding. Um I I know that

[4:19](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=259s) folks are probably familiar with

[4:20](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=260s) claude.md

[4:23](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=263s) um and and uh and wiki layouts and all

[4:26](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=266s) these things. If you attach a wiki, it

[4:29](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=269s) still doesn't tell the agent where the

[4:32](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=272s) information is that it needs. It can

[4:35](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=275s) search for things in the wiki, but then

[4:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=277s) what happens is it'll suffer from

[4:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=279s) something that uh radiologists

[4:42](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=282s) uh call satisfaction of search. So, this

[4:44](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=284s) is a term in radiology

[4:47](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=287s) where you look at an X-ray and you're

[4:49](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=289s) trying to find a region um that might be

[4:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=292s) an indicator for cancer. Okay? And you

[4:55](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=295s) discover like one

[4:57](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=297s) indicator and if you stop there uh you

[5:01](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=301s) might miss other important indicators

[5:03](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=303s) that might you know lead to diagnosis of

[5:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=306s) even more uh issues. So this is what

[5:10](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=310s) happens with agents. They don't they

[5:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=311s) they find something that they they think

[5:13](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=313s) is correct and then they stop. Um the

[5:16](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=316s) the other thing about agents is that

[5:17](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=317s) they don't distill understanding.

[5:20](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=320s) They can look around, they can find

[5:22](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=322s) information, but they they don't

[5:24](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=324s) understand how all the pieces fit

[5:26](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=326s) together because without doing that leg

[5:29](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=329s) work ahead of time. Um, they don't

[5:31](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=331s) understand how, you know, your

[5:32](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=332s) dependencies interact with each other

[5:34](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=334s) and how your architecture and sort of

[5:36](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=336s) future planning is going to scope the

[5:38](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=338s) work that it does next. And so some some

[5:41](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=341s) people will then ask, well, what if we

[5:43](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=343s) just take the entire codebase and all of

[5:45](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=345s) our architecture documents and just slam

[5:47](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=347s) it into the context window. Um, and then

[5:50](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=350s) yes, maybe like your agents will reason

[5:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=352s) about everything all at once. And in

[5:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=354s) practice, that that of course doesn't

[5:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=356s) work. Um, not just because you've got

[5:58](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=358s) way more organizational context than can

[6:00](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=360s) fit into a context window, even one

[6:02](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=362s) that's a million tokens in size. Um, but

[6:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=366s) it it it causes the agent to get

[6:07](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=367s) distracted. When you're working on a

[6:10](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=370s) task, you want task specific flow. Um,

[6:13](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=373s) and so your agents will get distracted

[6:15](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=375s) easily if you give them things that

[6:17](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=377s) cause them to look this way in that way.

[6:19](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=379s) Um, and it'll just waste tokens and

[6:21](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=381s) time. So, in this morning's keynote, um,

[6:25](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=385s) Tariq from Claude Code mentioned unknown

[6:28](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=388s) unknowns. I just want to uh harp on that

[6:30](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=390s) phrase again. And it can be phrased a

[6:32](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=392s) different way, which is finding the

[6:34](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=394s) things that really matter.

[6:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=397s) And so this is what your agent can see

[6:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=399s) at the top of the iceberg. They can see

[6:41](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=401s) the code and they can operate on the

[6:44](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=404s) code. What they don't see are things

[6:46](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=406s) like the actual intent, the team

[6:50](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=410s) conventions, past decisions, things that

[6:53](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=413s) you've discussed in Slack, for example,

[6:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=416s) uh architecture rationale, and so on.

[6:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=419s) And that's why your agents need a

[7:02](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=422s) context engine to get real work done.

[7:05](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=425s) So, I'm going to now uh attempt a live

[7:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=428s) demo. And hopefully the demo gods are

[7:10](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=430s) kind. Um, so I want to pop back up

[7:14](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=434s) conceptually. Oops, I think I'm on the

[7:16](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=436s) wrong tab. We'll get to that one in a

[7:17](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=437s) sec.

[7:20](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=440s) So for now,

[7:24](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=444s) sorry about that. And here we are.

[7:29](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=449s) So I'm going to ask a question as if I'm

[7:32](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=452s) a, you know, I'm a human and I want to

[7:34](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=454s) get some information about my codebase.

[7:38](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=458s) And, you know, the human layer hasn't

[7:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=459s) gone away. We talk about agents and

[7:41](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=461s) their need for context, but um humans

[7:44](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=464s) are still asking questions about the

[7:46](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=466s) codebase and we need that level of

[7:47](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=467s) understanding because ultimately the

[7:49](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=469s) accountability stops with us. When you

[7:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=472s) hit merge on a PR, you need to

[7:53](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=473s) understand what it's doing um and you

[7:55](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=475s) need to understand how the architecture

[7:57](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=477s) works. So this question I asked here um

[7:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=479s) is about an internal component of our

[8:02](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=482s) system called the source mark engine and

[8:04](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=484s) you can see that it uh is able to

[8:07](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=487s) articulate it fairly well. um

[8:09](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=489s) understands the architecture. This this

[8:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=491s) diagram here is uh is generated. So it

[8:15](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=495s) this diagram doesn't exist. Um it just

[8:19](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=499s) figures it out based on the um the way

[8:22](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=502s) the code operates today and then some

[8:24](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=504s) proposals for future architecture.

[8:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=507s) And then uh what's really important is

[8:29](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=509s) that you show your work. This is a trust

[8:31](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=511s) building thing more than anything, but

[8:33](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=513s) it allows people to see if um if the

[8:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=517s) answer is maybe not entirely correct,

[8:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=519s) then you can in look into the uh the

[8:42](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=522s) knowledge base that you have and make

[8:44](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=524s) corrections.

[8:45](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=525s) Increasingly agents are doing this for

[8:47](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=527s) you.

[8:49](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=529s) So now um what I want to show you is

[8:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=532s) another place where humans spend their

[8:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=534s) time which is in Slack and this is where

[8:58](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=538s) a lot of the decisions get made of

[8:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=539s) course.

[9:00](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=540s) So I can do something like this.

[9:04](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=544s) And uh unblocked will sit and kind of

[9:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=546s) listen for things that are things that

[9:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=548s) can chime in on when it provides a high

[9:10](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=550s) degree of Oh, sorry. We went to the

[9:12](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=552s) wrong You guys can't see that. Thank

[9:15](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=555s) you, Claire.

[9:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=558s) Oh, come on down. Let's see if I can

[9:20](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=560s) bring it up. There we go.

[9:24](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=564s) Perfect. So I can ask questions like

[9:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=567s) this in unblocked and if it thinks it

[9:29](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=569s) can chime in on the answer then it will

[9:31](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=571s) chime in. Otherwise I can just

[9:34](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=574s) um address unblocked directly and ask

[9:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=577s) the same question

[9:41](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=581s) and when it thinks that it has an answer

[9:43](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=583s) to give then it will give an answer and

[9:46](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=586s) so we can get um

[9:49](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=589s) quite a bit of interesting content there

[9:51](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=591s) from unblocked. Thank you. Unblocked.

[9:55](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=595s) I'm going to switch up

[9:58](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=598s) and show you the the really interesting

[10:00](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=600s) thing which is the agents. Okay. So, um

[10:03](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=603s) in in that question, the source mark

[10:05](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=605s) engine, I'm not sure if people picked

[10:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=606s) up, but there was a little thing at the

[10:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=608s) bottom there that said, you know,

[10:09](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=609s) there's some optimization opportunities.

[10:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=611s) Um so what I did here is I went into

[10:13](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=613s) claw code and I asked it um without

[10:16](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=616s) using unblocked to um

[10:19](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=619s) uh generate uh a plan to optimize the

[10:23](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=623s) source mark calculator and it did that

[10:25](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=625s) and it happily went and you know

[10:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=627s) searched through the code and and tried

[10:28](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=628s) to figure out how the algorithm works

[10:30](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=630s) and so on. Um and it it reached a

[10:33](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=633s) conclusion that's great you know it does

[10:35](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=635s) a pretty good job um but you know it

[10:38](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=638s) maybe could do a little bit better. So,

[10:40](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=640s) I asked that question again uh using

[10:42](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=642s) unblock this time and it it really kind

[10:46](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=646s) of nails the the nuances because it

[10:48](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=648s) picks up on the the uh PRs that we um

[10:53](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=653s) where we discussed future possibilities

[10:55](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=655s) for improvement. um some Slack

[10:58](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=658s) conversations that we had and uh of

[11:01](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=661s) course you know notion and architecture

[11:03](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=663s) documents and it shows its work and this

[11:05](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=665s) is really important because um all of

[11:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=668s) these things here the sources come back

[11:10](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=670s) to Claude and then Claude knows exactly

[11:13](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=673s) where to jump to next if it needs to

[11:15](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=675s) elaborate on that context. And so I just

[11:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=678s) want to show you what the impact of that

[11:19](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=679s) is. So if I um Whoops.

[11:24](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=684s) Thank you. If I pull up usage here, you

[11:26](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=686s) can see that with unblocked, uh, the

[11:29](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=689s) total cost was, you know, subd dollar to

[11:31](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=691s) create the plan. Uh, took about a

[11:33](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=693s) minute. Ignore the wall clock time

[11:35](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=695s) because I've had this open for about an

[11:36](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=696s) hour. But, um, it's about a minute. And

[11:40](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=700s) then if I look at um the usage without

[11:43](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=703s) unblocked, you can see that it's about 2

[11:46](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=706s) minutes. And and and it costs more to

[11:49](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=709s) generate all that context. Now, the

[11:50](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=710s) reason that happens is because it has to

[11:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=712s) do more work. It has to look around. has

[11:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=714s) to discover things. Um, and this

[11:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=716s) compounds, not only does it have to do

[11:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=719s) more work to discover things, it doesn't

[12:01](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=721s) discover the right things. So, when you

[12:03](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=723s) get further down in your execution, it

[12:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=726s) may be operating on the wrong plan or

[12:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=728s) the wrong assumptions. And then you have

[12:09](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=729s) to go back and you have to loop over and

[12:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=731s) over again. So, the real value of a

[12:13](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=733s) context engine is not like the upfront

[12:15](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=735s) cost on these short tasks. It's the

[12:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=738s) compounding effect. Um the the other

[12:20](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=740s) Tariq from Sonar mentioned this in the

[12:23](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=743s) keynote this morning and it's true like

[12:25](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=745s) the loops compound and you have to be

[12:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=747s) like um uh efficient the entire way

[12:30](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=750s) through with your context. I'm just

[12:32](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=752s) going to jump back to

[12:35](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=755s) Safari and I'm going to point out um

[12:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=757s) some really interesting things. So we

[12:41](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=761s) also have a a code review agent.

[12:44](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=764s) And when we say um you know

[12:47](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=767s) organizational context, we're talking

[12:50](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=770s) about more than just the underlying

[12:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=772s) data. Uh we're talking about real

[12:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=774s) intelligence. So what unblock does is it

[12:58](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=778s) looks at um not like it looks at pull

[13:00](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=780s) request data and there are other data

[13:02](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=782s) sources for this and it generates a

[13:05](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=785s) series of best practices that help align

[13:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=788s) agents to your codebase. But we thought

[13:10](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=790s) that this would be really helpful to

[13:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=791s) surface for the review agent as well. So

[13:14](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=794s) what you can see here is um

[13:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=798s) it unblock chimed in and then Richie

[13:21](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=801s) here said, "Oh, that's cool. That's

[13:22](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=802s) something I would say." And that's

[13:23](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=803s) because that actually was something he

[13:25](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=805s) said. So it surfaced the uh the previous

[13:28](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=808s) comments. Richie's one of the senior

[13:30](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=810s) engineers and we use the sort of

[13:33](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=813s) seniority or expertise as a signal um to

[13:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=817s) boost uh comments that are important.

[13:40](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=820s) Okay.

[13:42](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=822s) So another uh interesting interaction by

[13:45](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=825s) Richie, he uh discovered that the number

[13:48](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=828s) of code review issues that were being

[13:50](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=830s) surfaced dropped uh precipitously

[13:53](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=833s) and he was debugging it with unblocked.

[13:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=836s) Um he got all the way to the bottom and

[13:58](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=838s) realized what roughly what the problem

[14:00](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=840s) was and then asked unblocked to fix it.

[14:02](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=842s) Now this this is something that we have

[14:04](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=844s) internally um you know that we're

[14:07](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=847s) experimenting with. Um, so unblocked uh

[14:10](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=850s) can run as an agent in the cloud. Um,

[14:13](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=853s) but what's really cool about this is

[14:16](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=856s) that it has all your organizational

[14:17](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=857s) context at its fingertips and the

[14:20](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=860s) results are are pretty magical. So it

[14:23](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=863s) can do things like generate this PR um,

[14:26](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=866s) and then what you'll see here is that

[14:28](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=868s) not only does it generate the fix, it

[14:31](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=871s) also is able to relate it to the all the

[14:33](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=873s) conversations that were happening. So

[14:35](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=875s) this PR was created because and you read

[14:37](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=877s) that context thing. It's mind-blowing.

[14:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=879s) After this PR, we switched to uh Claude

[14:43](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=883s) 48 and it dropped a ton in issues

[14:46](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=886s) because of the behavior is quite a bit

[14:48](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=888s) different. So then it said Richie

[14:50](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=890s) directly correlated the drop. Now what's

[14:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=892s) this thing here? Let's click on it. It

[14:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=894s) is a Slack conversation. So, it found

[14:56](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=896s) the Slack conversation, correlated all

[14:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=899s) of that, you know, past history back

[15:01](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=901s) again, and then we ended up with a with

[15:03](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=903s) a final PR.

[15:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=908s) So, um, I'm going to I've got only a few

[15:10](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=910s) minutes left. I'm just going to close

[15:12](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=912s) this out really quickly. We have a uh a

[15:14](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=914s) couple of open- source projects that are

[15:16](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=916s) kind of interesting if people want to

[15:17](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=917s) play with them. One is the document

[15:19](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=919s) query engine. That was, uh, something

[15:21](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=921s) that I talked about on Monday in my

[15:23](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=923s) workshop. Um, I may uh talk about it

[15:26](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=926s) again tomorrow, but I just want to give

[15:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=927s) folks a sense of what this thing does.

[15:30](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=930s) Um, whoops.

[15:32](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=932s) If you want to play with it, it's open

[15:35](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=935s) source, so you can just download it and

[15:36](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=936s) have it go. It basically runs over your

[15:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=939s) um uh GitHub repository, ingests uh your

[15:43](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=943s) your historical pull requests, and then

[15:46](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=946s) uh synthesizes a schema based on the

[15:48](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=948s) documents that it can sample. Um and

[15:51](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=951s) then from there you can issue any kind

[15:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=952s) of queries that you like and get all

[15:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=954s) kinds of insights out of it through the

[15:57](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=957s) agent chat. You can ask all kinds of

[15:59](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=959s) questions. Um and then lastly the

[16:02](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=962s) engineering social graph. So this is the

[16:04](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=964s) thing that I was talking about earlier

[16:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=966s) that helps us pin down expertise and

[16:09](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=969s) team relationships. Um so what you can

[16:12](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=972s) see here is this sort of like the rough

[16:14](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=974s) breakdown of our team structure at

[16:16](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=976s) Unblocked. As you can see we're a fairly

[16:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=978s) small team. Um and so we've got these um

[16:23](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=983s) uh these clusters of people and how they

[16:25](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=985s) relate to each other indicates the kind

[16:27](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=987s) of um review relationships that they

[16:30](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=990s) have. So these are you know these lines

[16:32](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=992s) show like we review each other's code.

[16:35](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=995s) Um

[16:36](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=996s) we can then cluster that and generate

[16:39](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=999s) team labels for that or show the

[16:42](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1002s) coverage across your codebase. This is

[16:44](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1004s) really cool. you can see kind of where

[16:45](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1005s) the holes are, where you might be

[16:47](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1007s) lacking expert coverage. Um, and that's

[16:50](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1010s) exactly what we use within the context

[16:52](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1012s) engine itself.

[16:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1014s) All right,

[17:00](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1020s) one last thing we have uh for those that

[17:03](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1023s) want a taste of what a context engine

[17:05](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1025s) can do but don't want to sign up for

[17:07](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1027s) unblocked right away. Um you can use uh

[17:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1031s) something that we call the context

[17:12](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1032s) engine simulator which will basically

[17:15](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1035s) build up a context behind the scenes on

[17:18](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1038s) a per task basis and then use that

[17:21](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1041s) context uh to to drive the task. It'll

[17:24](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1044s) do it with context and without context

[17:26](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1046s) so that you can see what the differences

[17:28](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1048s) might be.

[17:30](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1050s) This is a QR code for that if you want

[17:33](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1053s) to just take a quick snap.

[17:38](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1058s) Awesome. And I'll just land

[17:41](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1061s) on a quote from one of our customers.

[17:45](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1065s) 50% fewer tokens, faster triage, better

[17:49](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1069s) answers. And that's exactly what a

[17:51](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1071s) context engine can do.

[17:54](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1074s) One last shout out um before we end. My

[17:57](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1077s) colleague Brandon is giving a talk in

[18:01](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1081s) 10 minutes uh at room 2020. um he's

[18:04](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1084s) going to speak to in a lot more detail

[18:06](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1086s) about some of the higher level things

[18:08](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1088s) that context engines can do. I'm going

[18:10](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1090s) to run over there right after this and I

[18:11](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1091s) think all of you should follow me.

[18:14](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1094s) Awesome. Oh, and don't forget to get a

[18:16](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1096s) coconut.

[18:33](https://www.youtube.com/watch?v=qdAkxLoYNI8&t=1113s) >> [music]
