# Ship Production Software in Minutes, Not Months

Eno Reyes, Factory

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/iheWKg2Tkrk-ship-production-software-in-minutes-not-months) · [Video](https://www.youtube.com/watch?v=iheWKg2Tkrk)

## Ship Production Software in Minutes, Not Months

Delegating production work takes more than a coding agent: it requires shared context, collaborative planning, reliable validation, and clear responsibility for what agents do.

Familiarity with Git branches, pull requests, continuous integration, and basic incident response will help you follow the workflows.

### What changes when agents do the work?

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

What should a software development environment look like when humans no longer write every individual line of code? Eno Reyes began working with LLMs around the arrival of **GPT-3.5**, when agentic systems were becoming plausible. At Factory, that possibility became a product direction: move from human-driven development toward delegating work to agents across the software lifecycle.

Adding AI to an editor gives developers useful assistance, but it leaves the original interaction pattern largely intact: a human operates tools designed for humans to write code. Reyes invokes the faster-horses saying attributed to Henry Ford to ask whether improving that familiar interface is enough. **Delegating most development tasks requires an environment built around delegation**, rather than an accumulation of AI features.

That environment needs four capabilities working together:

- **Task management:** an intuitive interface for assigning work and managing agents.
- **Shared context:** centralized information from engineering tools and data sources.
- **Reliable outputs:** agents that consistently produce work worth reviewing and using.
- **Parallel infrastructure:** capacity for thousands of agents to work concurrently.

These are the platform requirements Reyes draws from Factory’s two years of work with large organizations, not a claim that a coding model alone supplies them.

### Production software still needs engineering judgment

[2:51](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=171s)

Karpathy’s framing of English as a programming language captures the excitement around natural-language development. But being able to ask for software does not remove the engineering demands of a consequential system. Reyes illustrates the gap with a hypothetical legacy Java 7 application handling 5% of global bank transactions: it is an example of the stakes, not an identified customer or verified transaction share.

His analogy is climbing equipment. Agents make a difficult ascent more accessible, while building production software remains like scaling Mount Everest. Better equipment extends what an experienced climber can do; the climber still needs judgment about how to use it. Existing engineering expertise is what makes the new tools useful on difficult terrain.

![Slide titled “The new way to build software,” with the quote “The hottest new programming language is English” attributed to Andrej Karpathy above line drawings of mountains.](https://ai.engineer/api/talk-essay-media/3f488cb47f4219370c355cb798cdafc25ab3a8ffafdfda4ccea0edf00b5baa18)

“The new way to build software” pairs Karpathy’s English programming quote with a mountain illustration.

### From a delegated task to a pull request

[3:43](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=223s)

The first demonstration makes delegation concrete. Factory calls its agents **Droids**. Once given a task, the Droid begins by establishing where it is and what it can do; it does not immediately start editing files. The workflow proceeds in this order:

1. **Inspect the environment.** Search the codebase, determine the Git branch, and check the machine’s available capabilities.
2. **Recover relevant history.** Review recent code changes and retrieve memories of interactions with the user and across the organization.
3. **Propose and clarify.** Return a plan, then ask the user to resolve uncertainties before implementation.
4. **Execute and validate.** After the user supplies that information, write code, run pre-commit hooks and linting, and generate a pull request that Reyes describes as passing CI.

The clarification step is part of the engineering work. A useful agent should question an incomplete request and help improve it, rather than treat the first instruction as a complete specification. The endpoint shown here is a CI-passing pull request, not a production deployment.

### Failure often begins with missing context

[4:51](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=291s)

A successful demonstration raises the harder question: how do you make the outcome repeatable? Start by treating an LLM as an intelligence with only a slice of the real world available to it. What looks like a prompting problem may actually be a mismatch between what the developer knows and what the agent has been told.

Factory’s investigation of thousands of Droid-assisted sessions led Reyes to a recurring heuristic: an agent often fails because crucial context is missing, rather than because the underlying model cannot solve the problem. This is an observation from those sessions, not a universal diagnosis of agent failure. More capable models may make failures less frequent, but they cannot recover organizational facts that nobody has supplied.

The missing information may never have reached a repository or issue tracker. An LLM does not know what changed in the morning standup, what someone explained in an ad hoc meeting, or what the team drew on a whiteboard. Transcribed notes and uploaded whiteboard photos can make that information available. Native connections to engineering systems address another part of the problem, but **access and use are separate requirements**: the agent must be able to find the context and apply it to the task. Thinking of the system as somewhere between a coworker and a platform helps expose what it still needs to know.

### Research what to build before asking for code

[6:30](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=390s)

Using agents throughout development means involving them before implementation. In the next example, a Droid researches a new model release and plans its integration into an existing chat application. The task requires several kinds of evidence to meet in one place:

| Context | Contribution to the plan |
|---|---|
| Internet search | Up-to-date information about the model release |
| Existing codebase | How the application currently works |
| Organizational memory | The product’s goals |
| Recent design document | The technical architecture |

The difficult question is what to build within the existing product, not simply how to generate the integration code.

Planning becomes collaborative when the agent does the groundwork and research, then the developer explores possibilities with it. Asking for a finished design document in one step skips that interaction. The useful handoff is an informed starting point that people and agents can refine together.

The resulting plan can be exported to Notion, Confluence, or Jira through integrations. Reyes describes a platform experience without per-developer setup, while pointing out the friction of asking every developer to install servers, configure connections, and handle API keys. [Model Context Protocol (MCP)](https://modelcontextprotocol.io/specification/2025-03-26) standardizes integration interfaces; the no-setup experience is a platform claim, not a property guaranteed by the protocol. Removing that friction gets information moving, but the next improvement is organizational: standardize how the team expresses its reasoning.

### Build the PRD from evidence and constraints

[8:19](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=499s)

Factory’s planning for a cloud development environment feature shows what that reasoning can look like. The team started with roughly three months of feedback transcripts from enterprise and individual users. Reyes says Factory transcribes every interaction and meeting. They combined those notes with a Droid’s access to the architecture and an engineer’s ad hoc meeting notes captured with [Granola](https://www.granola.ai/).

Instead of asking the Knowledge Droid to plan the feature immediately, they asked it to investigate two things:

- **Customer patterns:** Which patterns in the feedback correspond to the team’s assumptions?
- **Technical constraints:** What limitations in the current architecture could inform a better design?

Those questions produced four or five intermediate results. The team then used the resulting documents to iterate toward a final **product requirements document (PRD)**. The intermediate analysis matters: it gives the team evidence and constraints to examine before committing to the feature’s shape.

![“Planning with AI” slide with three columns covering business context, architecture and meeting notes; patterns, constraints and iterative refinement; and templates, language polishing and visual enhancements.](https://ai.engineer/api/talk-essay-media/b4464d601c2f01a63b53752d12569649f8e5d67cbc31966af83416b0e8e7ffa8)

Planning with AI: gathering context, collaborative discovery, and final deliverables.

### Turn the plan into coordinated work

[9:26](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=566s)

Once the PRD exists, a Droid with Linear or Jira tools can translate it into a roadmap by creating and modifying tickets and epics. Reyes sketches eight tickets assigned across eight code Droids, with dependencies determining which work can proceed in parallel. The important operation is not merely splitting a document into tasks: it is preserving the relationships that govern when those tasks can run. The developer moves from executing each item to orchestrating the systems doing the work.

This makes ordinary process artifacts more valuable. PRDs, engineering design documents, root-cause analysis templates, quarterly engineering and product roadmaps, and meeting transcripts form a knowledge base for agents. They describe how the team thinks and works. Recording **why a decision was made**, alongside the decision itself, gives future developers and agents the context needed to follow the team’s practices. Documentation becomes a continuing conversation with both audiences.

### Connect incident evidence before proposing a mitigation

[10:49](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=649s)

The same context problem appears in site reliability engineering. Reyes explicitly rejects the idea that all incident response and root-cause analysis can already be automated. The demonstration has a narrower scope: a Droid takes a Sentry incident and turns it into a **root-cause analysis (RCA)** and mitigation plan. Producing that plan is distinct from executing a fix or resolving the incident.

Traditional incident investigation is a puzzle with pieces spread across systems: logs in one place, metrics elsewhere, historical context in documents, and some knowledge only in people’s heads. With appropriate tools, a Droid can gather relevant system logs, past incidents, runbooks in Notion or Confluence, and Slack discussions. This retrieval work supplies the evidence needed to interpret the alert.

Reyes says that access to these tools and sources can reduce incident search effort from hours to minutes. He does not provide a benchmark methodology. His next step—an agent offering an explanation and proposed fix as soon as an incident occurs—is an aspiration for immediate assistance, not a measured guarantee of zero response time. User and organization memory could then help identify recurring issues and familiar response patterns, allowing the system to propose process improvements beyond the current mitigation.

### Make incident response a learning cycle

[12:32](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=752s)

The RCA is an input to subsequent work. An agent can generate runbooks for newly recognized patterns, update response workflows, and capture team knowledge for automatic sharing. Connecting these steps makes incident response part of a learning cycle rather than a sequence of isolated investigations.

Reyes reports seeing unnamed teams cut incident response time in half because context is immediately available. No sample size or measurement method accompanies that report. He also describes repeated incidents prompting suggestions for underlying fixes: by the third occurrence, a Droid might flag that the recurring problem deserves a more durable solution. For a new engineer, the same organizational memory provides a way to ask how the team handles a particular situation without first finding the person who remembers it.

As operational history accumulates, patterns across incidents can inform future action. Reyes frames this as a shift from reactive toward predictive operations: each incident becomes an opportunity to improve the system’s reliability. The agent’s role is to amplify the engineer’s ability to connect evidence, recognize repetition, and improve the response process.

### The work moves outward, and responsibility remains

[13:51](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=831s)

The developer’s role expands beyond the inner loop of writing individual lines in an IDE. Reyes describes developers managing agents that work concurrently, organizing the surrounding systems, and building reusable patterns for how development happens. Working effectively with agents remains an active discipline; expecting the AI to do everything is not the same as directing it well. In that broader role, he places clear thinking and effective communication with humans and AI at the center of engineering practice.

The closing invitation was specific to the recording: attendees could scan a QR code to create an account with twenty million free tokens, and Reyes recommended a laptop because the mobile experience was not yet optimized. These were talk-time access details, not a statement of today’s offer.

Enterprise adoption adds questions that a successful code demo cannot answer. Where are the audit logs? Who owns the work? Who is responsible if an agent performs a destructive action? Reyes raises recursive deletion as a hypothetical and says Factory’s Droids do not do that; the example introduces accountability questions rather than demonstrating a safeguard.

Security, ownership, auditability, and legal indemnification all need explicit consideration. Reyes warns against unrestricted “YOLO mode” inside an enterprise and closes by inviting people to inspect the platform’s controls and send questions by email. Delegation changes who performs an action, but organizations still have to establish who authorizes it, how it can be audited, and who bears responsibility for its consequences.

## Resources

- [Factory's context stack](https://factory.com/news/context-window-problem) — Explains how Factory combines repository navigation, enterprise information, and user and organization memory.
- [Empower's incident-response case study](https://factory.ai/case-studies/empower) — Factory's customer account reports up to 40% lower average incident response time and separate collaboration improvements.
- [Model Context Protocol specification](https://modelcontextprotocol.io/specification/2025-03-26) — The March 2025 protocol version explains how applications connect models to external context and tools.
- [Granola meeting notes](https://www.granola.ai/) — A meeting assistant that turns conversation context and personal notes into enhanced meeting notes.
- [Get started with Factory](https://docs.factory.ai/) — Current onboarding for delegating tasks through Factory's application, CLI, and browser interfaces.
- [Factory enterprise deployment and controls](https://docs.factory.ai/enterprise) — Current guidance on deployment, managed settings, agent safety, data flows, and telemetry.

## Slides

### Factory

Eno introduces Factory and describes how working on LLMs around GPT-3.5 made agentic systems seem possible.

[0:22](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=22s) [Factory title slide: Ship Production Software in Minutes, Not Months.](https://assets.ai.engineer/sites/aiecode2025/sha256/1001050b10d44a1868363f629a9d0a7c9545380ffb8f2c882db013dc2ca743db.webp)

FACTORY
Ship Production Software in Minutes, Not Months

Interface text:
AIE
AI Engineer World’s Fair
vellum
Microsoft
aws
smol ai

### Factory

Factory’s Eno describes a shift from human-driven to agent-driven software development and introduces lessons from helping enterprises make that transition.

[0:32](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=32s) [Factory title slide: Ship Production Software in Minutes, Not Months.](https://assets.ai.engineer/sites/aiecode2025/sha256/fbaa32388dcbeef0922ba479c176e60f220521cf236fbfeee0402852c0a246c9.webp)

FACTORY

Ship Production Software in Minutes, Not Months

Interface text:
AIE
AI Engineer World’s Fair
vellum
Microsoft
aws
smol ai

### The New Way to Build Software

A mountain illustration accompanies Karpathy’s quote. The speaker likens agents to climbing gear: building production software still requires engineering expertise.

[2:48](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=168s) [A slide quotes Andrej Karpathy on English as a programming language, above a mountain illustration.](https://assets.ai.engineer/sites/aiecode2025/sha256/2669e8755217f90b06d1e5ecfd0840593b53568c24eef880ae3d5de15d8a9975.webp)

THE NEW WAY TO BUILD SOFTWARE

“The hottest new programming language is English”

– Andrej Karpathy

Interface text:
AIE
AI Engineer World’s Fair
daily
Microsoft
aws
smol ai

### Factory demo: submitting a task

A Code Droid prompt asks for a retry in factory-mono when Firecrawl returns a no content error, with a waitfor of maybe 2000ms more.

[3:48](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=228s) [Factory home screen with a request to retry a failed content scrape.](https://assets.ai.engineer/sites/aiecode2025/sha256/c96b0956e60e65b8f9cf0a54f1dd8b2ef9238a0a4dc15d62be85607c7c675693.webp)

WELCOME TO YOUR FACTORY, ENO

In firecrawl, if we get a no content error - retry with a waitfor of maybe 2000ms more in factory-mono

Interface text:
FACTORY
Code Droid
factory-mono
Sonnet 3.7
Toolkits [2]
Enter to start session
Cmd + Enter to enter empty session
DROIDS
VIEW ALL
AIE
AI Engineer World’s Fair
daily
Microsoft
aws
smol ai

### Agent searches the codebase

The Droid searches factory-mono for Firecrawl error handling, then tries a broader search. The context panel shows user and organization memory alongside the project source.

[3:54](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=234s) [Factory agent searches the codebase beside a context panel containing memory and source entries.](https://assets.ai.engineer/sites/aiecode2025/sha256/165bea104d91c0f38d1621a7016ee2895df3b0a3739c35317cce4ee4f4cec78e.webp)

FACTORY

In firecrawl, if we get a no content error - retry with a waitfor of maybe 2000ms more in factory-mono

Thinking...

I'll help you implement the retry mechanism for "no content" errors in firecrawl with an increased waitfor time. Let me search the codebase and analyze the current implementation first.

Searching "firecrawl error handling no content error waitfor" in factory-mono

Let me try a more general search for firecrawl:

Searching "firecrawl implementation" in factory-mono

Context
ADVANCED CODEBASE SEARCH
CODEBASE EXPLORER

MEMORY · 2
Organization Memory
Memory · 394 tokens
User Memory
Memory · 434 tokens

SOURCES · 1
Factory-AI/factory-mono
Local Project Overview · 13666 tokens

Interface text:
New Session
Code Droid
Chat
Context
History
Private
Connect
Filter session context...
Type @ to search your codebase
Enter your message...
Sonnet 3.7
Toolkits [3]
Auto
14% of context size used
DEV
AIE
AI Engineer World's Fair
daily
Microsoft
aws
smol ai

### Agent finds relevant files

Given a Firecrawl retry request, the Droid searches the codebase and uses grep to find related files, while user and organization memories remain visible in the context panel.

[3:59](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=239s) [Factory agent displays codebase search results while the context panel remains open.](https://assets.ai.engineer/sites/aiecode2025/sha256/635dddfc78a33d3003c6c939a8b73c58ed1c4e4c97e198399653e225d88d7e99.webp)

In firecrawl, if we get a no content error - retry with a waitfor of maybe 2000ms more in factory-mono

Thinking...
I'll help you implement the retry mechanism for "no content" errors in firecrawl with an increased waitfor time. Let me search the codebase and analyze the current implementation first.

Searching "firecrawl error handling no content error waitfor" in factory-mono

Let me try a more general search for firecrawl:
Searching "firecrawl implementation" in factory-mono

Let me try a more direct approach with grep to find files related to firecrawl:
Grepping "firecrawl" in factory-mono
factory-mono: apps/factory-app/package.json
factory-mono: apps/factory-app/src/app/api/_utils/metrics/interfaces.ts
factory-mono: apps/factory-app/src/app/api/sessions/[sessionId]/context/create-integration-context/route.ts
factory-mono: apps/factory-app/src/data/models/session/context/handlers.ts
factory-mono: apps/factory-app/src/services/integrations/firecrawl/context.ts
factory-mono: apps/factory-app/src/services/integrations/firecrawl/index.ts

Context
ADVANCED CODEBASE SEARCH
CODEBASE EXPLORER
MEMORY · 2
Organization Memory
Memory · 394 tokens
User Memory
Memory · 434 tokens
SOURCES · 1
Factory-AI/factory-mono
Local Project Overview · 13666 tokens

Interface text:
FACTORY
New Session
Code Droid
Chat
Context
History
Private
Connect
Filter session context...
Type @ to search your codebase
Enter your message...
Sonnet 3.7
Toolkits [3]
Auto
15% of context size used
DEV
AIE
AI Engineer World's Fair
daily
Microsoft
aws
smol ai

### Agent edits retry logic

The Droid examines Firecrawl’s type definitions, identifies waitFor as an available option, and begins modifying context.ts to retry no-content errors with a longer wait.

[4:18](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=258s) [Factory agent describes implementing retry logic beside an open code file.](https://assets.ai.engineer/sites/aiecode2025/sha256/06c64c8968cad44f84014b655115aeff255e9b7ad5d17e1b6acbcc02f6d0d228.webp)

FACTORY

Implementing Firecrawl Retry Logic for No Content Errors

Let’s look at the type definitions to understand the available options for scrapeUrl:
cat node_modules/@mendable/firecrawl-js/dist/index.d.ts | g...

Let’s look at the ScrapeParams type definition:
cat node_modules/@mendable/firecrawl-js/dist/index.d.ts | g...

Let’s also check for CrawlScrapeOptions since ScrapeParams extends from it:
cat node_modules/@mendable/firecrawl-js/dist/index.d.ts | g...

Great! Now I have the information I need. I can see that waitFor is a parameter in the CrawlScrapeOptions interface, which is extended by ScrapeParams. Now I’ll implement the retry mechanism for "no content" errors with an increasing waitFor time.

Let’s modify the context.ts file:
context.ts
apps/factory-app/src/services/integrations/firecrawl

Thinking about what to do next... (reasoning models take longer to respond)

context.ts

import {
  logError,
  logException,
  logInfoBreadcrumb,
  logWarn,
} from '@factory/logging';
import {
  ErrorResponse,
  FirecrawlError,
  ScrapeResponse,
} from '@mendable/firecrawl-js';

import { callWithMetrics, ExternalDependency } from '@/app/api/_utils/metrics';
import {
  ContextCreationError,
  ContextSource,
  ContextType,
  CreateContextPayload,
} from '@/data/models/session/context/interfaces';
import { generateOptimisticContextId } from '@/data/models/session/context/optimisticUtils';
import { retry } from '@/utils/function/retry';
import { extractIdentifierFromUrl } from '@/utils/integrations';
import { generateTextMetadata } from '@/utils/text';

import getFirecrawlInstance from '.';

interface CreateWebPageContextPayloadParams {
  url: string;
  userId: string;
}

// Track waitFor value that increases by 2000ms on each retry
let currentWaitFor = 0;

const RETRY_OPTIONS = {
  isRetryableError: (error: unknown) => {
    // Retry on rate limit errors (429)
    if (error instanceof FirecrawlError && error.statusCode === 429) {
      return true;
    }

Interface text:
Code Droid · Chat · Context · History · context.ts · Private · Connect
COMPLETED IN 0.04 · RISK LEVEL: LOW · STATUS: SUCCESS
COMPLETED IN 0.01 · RISK LEVEL: LOW · STATUS: SUCCESS
COMPLETED IN 0.01 · RISK LEVEL: LOW · STATUS: SUCCESS
COMPLETED IN 0.01 · RISK LEVEL: LOW · STATUS: SUCCESS
Type @ to search your codebase
Enter your message...
Sonnet 3.7 · Toolkits [3] · Auto
Version 1 · Edit · Diff · factory-mono · apps/.../firecrawl/context.ts · DEV
AIE
AI Engineer World’s Fair
 daily
Microsoft
aws
smol ai

### The Context Principle

After investigating thousands of Droid-assisted sessions, the speaker presents a rule of thumb: missing context accounts for 90% of agent errors, while context overload and model limitations account for 5% each.

[4:50](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=290s) [A slide presents a rule of thumb attributing 90% of agent errors to missing context, 5% to context overload, and 5% to model limitations.](https://assets.ai.engineer/sites/aiecode2025/sha256/60fef8abb6ecda59bead89e8c935ba30860f1729fd44c2294d171c151d8f7d6a.webp)

FACTORY

THE CONTEXT PRINCIPLE

Agents are aliens. You have to learn how to communicate with them.

Rule of thumb for why an agent can’t solve your problem | Percentage Of Errors
Missing Context: The agent does not have the information you have. | 90%
Context Overload: The agent has too much irrelevant information | 5%
Model Limitations: True AI System Contsraints. | 5%

Interface text:
AIE
AI Engineer World’s Fair
Graphite
[illegible]ARE WITH AI
Microsoft
aws
smol ai

### Factory dashboard

Factory’s dashboard presents Droids for knowledge, code, reliability, and tutorials alongside a session prompt, as the speaker introduces using agents throughout development.

[6:27](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=387s) [The Factory dashboard shows a prompt box and four Droid options for knowledge, code, reliability, and tutorials.](https://assets.ai.engineer/sites/aiecode2025/sha256/05bf842320b0c8724ef9de41788f70f9cd060968a044a56a14e310b9714fd6ce.webp)

WELCOME TO YOUR FACTORY, ENO

Knowledge Droid
Enter your message...
Select repo
Sonnet 4
Toolkits [2]
Enter to start session
Cmd + Enter to enter empty session

DROIDS
VIEW ALL

Knowledge Droid
Engineering research, technical documentation, and onboarding guides.

Code Droid
Go from idea to merge-ready code changes.

Reliability Droid
Investigate incidents, write RCAs, and debug complex multi-service systems.

Tutorial Droid
Learn to use the Factory Platform.

RECENT SESSIONS
VIEW ALL

Interface text:
FACTORY
Dashboard
Sessions
Droids
Eno Reyes
DEV
AIE
AI Engineer World’s Fair
Graphite
Microsoft
aws
smol ai

### Research request for a chat app

A Knowledge Droid is asked to research Sonnet 4’s new parameters and settings for integration into an existing chat app.

[6:32](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=392s) [A Knowledge Droid prompt requests research on integrating a new model into a chat application.](https://assets.ai.engineer/sites/aiecode2025/sha256/3dcdd456bdd82bc9a110a0c9e5d1df3accc4f3ab8a7dc99aab39589b598eceb7.webp)

WELCOME TO YOUR FACTORY, ENO

Knowledge Droid

I'd like to research how to implement the new Sonnet 4 model's into my chat app test-chatbot-ui - I know they have a bunch of new parameters and settings. Help

Interface text:
FACTORY
 test-chatbot-ui
Sonnet 4
Toolkits [3]
Enter to start session
Cmd + Enter to enter empty session
DROIDS
VIEW ALL
AIE
AI Engineer World's Fair
Graphite
Microsoft
aws
smol ai

### Researching the Sonnet 4 integration

The Knowledge Droid searches for Sonnet 4 API information and reviews the chat app’s files, using memory and codebase context to prepare a research report.

[6:54](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=414s) [A research session displays internet searches beside organization memory, user memory, and a codebase source.](https://assets.ai.engineer/sites/aiecode2025/sha256/4fa6868645fb8b05543f163a64ce4f7745a2b5795f4bc5f5fbe8b250492e8b17.webp)

1. Let's do it direct - OpenAI won't support it.
2. I need you to find this information
3. Yes I'd like to add it as an extra model
4. Yes

Thinking...
Searching the internet for "Anthropic Claude Sonnet 4 API parameters features capabilities new model 2024 202[illegible]"
Searching the internet for "Anthropic Claude Sonnet 4 API documentation parameters endpoints streaming functi[illegible]"
Searching the internet for "Anthropic Claude 4 Sonnet 4 API hybrid reasoning thinking budget parameters"
Thinking...
Searching the internet for "Anthropic API messages endpoint claude sonnet 4 model ID parameters JSON reques[illegible]"

Interface text:
FACTORY
Integrating Sonnet 4 into a Chat App
Knowledge Droid
Chat · Context · History
Private · Connect
ADVANCED CODEBASE SEARCH · CODEBASE EXPLORER
MEMORY · 2
Organization Memory — Memory · 394 tokens
User Memory — Memory · 434 tokens
SOURCES · 1
Factory-AI/test-chatbot-ui — Remote Project Overview · 6074 tokens
Filter session context...
Type @ to search your codebase
Enter your message...
Sonnet 4 · Toolkits [3] · Auto
26% of context size used
AIE
AI Engineer World's Fair
Graphite · Microsoft · aws · smol ai

[7:04](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=424s) [Factory's assistant reviews files and searches while a context panel lists memory and codebase sources.](https://assets.ai.engineer/sites/aiecode2025/sha256/7e54d1caff3cb459890d63d6527475a58ec2978330237852f469139215604aae.webp)

Viewing file pages/api/chat.ts
Viewing file utils/server/index.ts
Viewing file pages/api/models.ts
Viewing file utils/app/const.ts
Viewing file types/chat.ts
Thinking...
Searching the internet for "Anthropic Claude API streaming implementation JavaScript TypeScript SDK eventsource[illegible]"
Thinking...
Searching the internet for "Next.js Anthropic Claude API streaming implementation eventsource-parser Readable[illegible]"

Now I have comprehensive information about Sonnet 4 and implementation patterns. Let me create the comprehensive research report.

Write to Memory

Interface text:
FACTORY
Integrating Sonnet 4 into a Chat App
Knowledge Droid
Chat · Context · History
Private · Connect
ADVANCED CODEBASE SEARCH · CODEBASE EXPLORER
MEMORY · 2
Organization Memory — Memory · 394 tokens
User Memory — Memory · 434 tokens
SOURCES · 1
Factory-AI/test-chatbot-ui — Remote Project Overview · 6074 tokens
DYNAMIC CONTEXT · 7
components/Chat/ModelSelect.tsx — Factory-AI/test-chatbot-ui · 562 tokens
pages/api/chat.ts — Factory-AI/test-chatbot-ui · 569 tokens
pages/api/models.ts
Filter session context...
Type @ to search your codebase
Enter your message...
Sonnet 4 · Toolkits [3] · Auto
54% of context size used
AIE
AI Engineer World's Fair
Graphite · Microsoft · aws · smol ai

### Integration plan executive summary

Factory’s Knowledge Droid reviews code and searches the web, then starts a Sonnet 4 integration plan for an existing chat app. The plan opens with a summary of the model’s capabilities.

[7:15](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=435s) [A generated Claude Sonnet 4 integration plan opens with an executive summary beside the assistant's activity.](https://assets.ai.engineer/sites/aiecode2025/sha256/deed7bc7f3de5f9f8f377b126aa3847d97fc9795b40fe9396e0540ca86715f2a.webp)

Claude Sonnet 4 Integration Plan

Repository: test-chatbot-ui
File: sonnet-4-integration-plan.md

1. Executive Summary

Claude Sonnet 4 (May 2025) is Anthropic’s high-performance mid-sized model that balances cost and capability.
Key attributes:
• 200 k token context, up to 64 k output.
• Vision input & analysis.
• Tool/function calling with JSON

Interface text:
FACTORY
Integrating Sonnet 4 into a Chat App
Knowledge Droid
Chat
Context
History
Claude Sonnet 4 Int...
Private
Connect
CODE
SPLIT
PREVIEW
sonnet-4-integration-plan.md
Viewing file pages/api/models.ts
Viewing file utils/app/const.ts
Viewing file types/chat.ts
Thinking...
Searching the internet for “Anthropic Claude API streaming implementati[illegible]”
Thinking...
Searching the internet for “Next.js Anthropic Claude API streaming imple[illegible]”
Now I have comprehensive information about Sonnet 4 and implementation patterns. Let me create the comprehensive research report.
Write to Memory
Generating file...
Type @ to search your codebase
Enter your message...
Version 1
Edit
Diff
DEV
AIE
AI Engineer World’s Fair
Graphite
Microsoft
aws
smol ai

### Integration plan implementation details

Factory’s assistant researches the codebase and the web, then drafts a Sonnet 4 integration plan covering streaming, provider routing, UI changes and API configuration.

[7:23](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=443s) [The plan displays streaming, routing, interface and API integration details.](https://assets.ai.engineer/sites/aiecode2025/sha256/16576a0d89adb0dfaf06a283ae0c2b968b638956a4d7d55d7ba3bf92598cbf54.webp)

SSE Parser
Create utils/server/anthropic.ts
Use eventsource-parser similar to OpenAI but map events:

if (json.type === 'content_block_delta' && json.delta.text) {
  const text = json.delta.text;
  controller.enqueue(encoder.encode(text));
}

4.4 Routing Decision
Modify existing /api/chat to dispatch by model.provider.

4.5 UI Changes
• ModelSelect already lists merged models.
• Add Extended Thinking controls in components/Chat/Temperature.tsx or new component.
• Show provider icon.

4.6 Env Vars
ANTHROPIC_API_KEY=
ANTHROPIC_API_VERSION=2023-06-01

5. API Integration Details
Endpoint: /v1/messages
Verb: POST
Payload additions: stream, thinking, tools (future)
Headers: x-api-key, anthropic-version = 2023-06-01
Error handling: Anthropic returns standard JSON error with error object.

Interface text:
FACTORY
Integrating Sonnet 4 into a Chat App
Knowledge Droid
Chat
Context
History
Claude Sonnet 4 Int...
Private
Connect
CODE
SPLIT
PREVIEW
sonnet-4-integration-plan.md
Viewing file pages/api/models.ts
Viewing file utils/app/const.ts
Viewing file types/chat.ts
Thinking...
Searching the internet for “Anthropic Claude API streaming implementati[illegible]”
Thinking...
Searching the internet for “Next.js Anthropic Claude API streaming imple[illegible]”
Now I have comprehensive information about Sonnet 4 and implementation patterns. Let me create the comprehensive research report.
Write to Memory
Generating file...
Type @ to search your codebase
Enter your message...
Version 1
Edit
Diff
DEV
AIE
AI Engineer World’s Fair
Graphite
Microsoft
aws
smol ai

## Full transcript

[0:00](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=0s) [on-hold electronic music] Hi, everybody.

[0:15](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=15s) My name's Eno. I really appreciate that introduction. Um, and maybe I can start with a bit of background. Uh, I started working on LLMs about two and a half years ago, uh, when, uh, GPT-3.5 was coming out, and it became increasingly clear that agentic systems were going to be possible with the help of LLMs.

[0:39](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=39s) At Factory, we believe that the way that we use agents, in particular to build software, is going to radically change the field of software development. We're transitioning from the era of human-driven software development to agent-driven development.

[0:55](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=55s) You can see glimpses of that today. You guys have already heard a bunch of great talks about different ways that agents can help with coding in particular. However, it seems like right now we're still trying to find what that interaction pattern, what that future looks like, and a lot of what's publicly available is more or less an

[1:14](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=74s) incremental improvement. The current zeitgeist is to take tools that were developed twenty years ago for humans to write every individual line of code, um, and ultimately tools that were designed first and foremost for human beings, uh, and you sprinkle AI on top, and then you keep adding layers of AI, and then at some point, maybe there's some

[1:33](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=93s) step function change that happens. But there's not a lot of clarity there in exactly what that means. You know, there's a quote that is attributed to Henry Ford. Uh, "If I had asked people what they wanted, they would have said faster horses."

[1:47](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=107s) Now, we believe that there are some fundamentally hard problems blocking organizations from accessing the true power of AI. This power can only be found when your team is delegating the majority of their tasks across the software life cycle to agents.

[2:04](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=124s) To do that, you need a platform that has an intuitive interface for managing and delegating tasks, centralized context from across all your engineering tools and data sources, agents that consistently produce reliable, high-quality outputs, and infrastructure that supports thousands of agents working in parallel.

[2:26](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=146s) These are all hard problems to solve, but our team has spent the last two years partnering with large organizations to build towards this future. This talk is gonna serve as sort of a deep dive into agent native development and some of the-- and sh-- a bit of a share of some of the lessons that we've learned helping

[2:44](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=164s) enterprise organizations make the transition to agent native development.

[2:51](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=171s) When Andrej Karpathy said, "English is the new programming language," he captured this very exciting moment, right? And if you're to judge AI progress based on Twitter, you'd think that, you know, you can basically vibe code your way to anything.

[3:04](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=184s) But vibe coding isn't the approach to solve hard problems. You can't vibe code a legacy Java seven app that runs h-- 5% of the world's global bank transactions, right?

[3:16](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=196s) You need a little bit more software engineering. So agents really should not be thought of as a replacement for human ingenuity, right? Agents are climbing gear, and building production software is like scaling Mount Everest.

[3:31](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=211s) And so while better tools have made this climb more accessible, we still need to think about how to leverage them i-- and use our e-existing expertise in order to drive this transformation.

[3:43](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=223s) I wanna start with a quick video of what's possible today, right? And so in this, you'll see a quick glimpse of what it's like to delegate a task to an agentic system.

[3:55](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=235s) You can watch the Droid, as we call them, ingest the task and start grounding itself in the environment. It uses tools to search through the code base, determine the Git branch, check out what the machine has available to it.

[4:09](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=249s) It looks through recent changes to the code base. It looks at memories of its recent interactions with users, as well as memories from its interactions across the entire organization.

[4:20](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=260s) And then the Droid comes back with a plan and says, "Here's exactly what I'm gonna do, but I'd like you to clarify a couple of things," right? We need to expect our agents to not just take what we say at face value, but instead question it and make us better software developers.

[4:35](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=275s) And so after the user comes back with that info, the Droid comes, it executes on that task, it leverages its tools to write code, runs pre-commit hooks, lints, and ultimately generates a pull request that passes CI.

[4:51](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=291s) But how can you achieve outcomes like this on a regular basis, right? It's nice when it works, but what about when it fails? At the heart of effective AI-assisted development lies a very fundamental truth: AI tools are only as good as the context that they receive.

[5:06](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=306s) So much of what people are calling prompt engineering is really mentally modeling this alien intelligence that has a slice of context of the real world. And if you start thinking about your AI tools this way, you're going to start to get a lot better at interacting with them.

[5:20](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=320s) We've investigated thousands of Droid-assisted development sessions, and you see this sort of heuristic emerge where AI is most likely failing to solve the problem, not because the LLMs aren't good enough, but because it's missing crucial context that's required to truly solve it.

[5:38](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=338s) And better models are gonna make this happen less often. But the real solution is not just making the AI smarter. It's going to be getting better at providing these systems with that missing context.

[5:50](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=350s) LLMs don't know about your morning standup. They don't know about the meeting that you had ad hoc and the whiteboard that you did, right? But you can give those things to the LLM if you transcribe your notes, if you take a photo and you upload it, right?

[6:04](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=364s) You have to start thinking about these things not as tools, but as something in between a coworker and, uh, and a, and a platform, right? And if you can get that context that lies in the cracks between systems, you use platforms that integrate natively with all of your data sources, and you have agents that can actually make

[6:24](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=384s) use of those things, you can start actually driving this transition to agent native development.

[6:30](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=390s) I want to talk a bit as well about planning and design. When your agent-- I mean, sorry, when your organization is doing agent-native development, then you are using agents at every stage.

[6:42](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=402s) Droids don't just write code. They can help with that part, but the hardest thing about software development is not the code. It's about figuring out exactly what to build.

[6:52](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=412s) Here you can watch a Droid as it's tasked with trying to find the most up-to-date information about a new model release and integrate that into an existing chat application.

[7:02](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=422s) It's gonna leverage internet search, its knowledge of your code base, its understanding of your product goals from its organ, uh, memory, and its understanding of your technical architecture from the design doc you wrote last week.

[7:15](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=435s) Planning with AI is fundamentally different from planning alone. It's not necessarily just asking, "Please build this thing for me," or, "Give me the design doc." But instead, it's about delegating the groundwork and the research to AI agents, then using a collaborative platform to interact and explore possibilities together.

[7:36](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=456s) That is how you get better at planning with agents.

[7:40](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=460s) Now, you can see here we have a nice document, a nice plan. You could export that to Notion, Confluence, Jira, any of your integrations with no setup because MCP is great, but having every developer have to install a bunch of servers, click a bunch of things, pass around the API key is not necessarily ideal.

[7:58](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=478s) And so platforms are gonna evolve and solve a lot of these problems. But in the meantime, you do have Droids. And now a little bit more on this. The real unlock for AI transforming your organization in res- with respect to planning is going to be when you start standardizing the way that your organization thinks, right?

[8:19](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=499s) And so there's a bit of a, of an example that we just had a couple of weeks ago while we were planning out, uh, a feature related to our cloud development environments.

[8:29](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=509s) We got a lot of feedback from users, and so we had about three months of user transcripts, people from enterprises, uh, individuals that we knew. Uh, we transcribe every single interaction and meeting at Factory.

[8:40](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=520s) We take those notes, and we combine them with a Droid that has access to our architecture. We take a ad hoc meeting that one of our engineers took a Granola of.

[8:52](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=532s) If you guys use Granola, I love that tool. Um, and we throw that all to the Knowledge Droid, and we say-- We don't say, "Let's plan the feature out."

[9:00](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=540s) We say, "Could you find any patterns in the customer feedback that map up to our assumptions? Can you highlight any technical constraints with what we have today that might help us make this better?"

[9:13](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=553s) And then we take all of that output, those documents. There's maybe four or five intermediate results here, and that's what we use to start iterating on a final PRD that helps us outline the full feature.

[9:26](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=566s) You can take that PRD, and if you have a Droid that has access to Linear and Jira with tools to create tickets, create epics, modify those things, then that PRD can be turned into a roadmap.

[9:40](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=580s) Eight tickets. This ticket's dependent on that ticket. But ultimately, work that can be parallelized amongst a group of eight code Droids, right? And so this is how software is going to evolve.

[9:52](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=592s) We're going to move from executing to orchestrating systems that work on our behalf.

[9:59](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=599s) I talked, I talked about a couple of these. I think PRDs, eng design docs, RCA templates, quarterly eng and product roadmaps, right? Transcriptions of your meetings. Normally, you might see this stuff as a burden, but when your company is doing agent-native software development, your process and your documentation is a knowledge base and a map for your Droids

[10:21](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=621s) to learn and imitate the way that your team thinks. This documentation and process is a conversation with both future developers as well as future AI systems. And so if you can communicate that why behind the decision, that context for those future developers and agents, then you'll start to see that there's a huge lift in their ability to

[10:44](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=644s) natively work the way that your team actually works.

[10:49](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=649s) I wanna talk about si-- uh, agent-driven development with respect to site reliability engineering.

[10:56](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=656s) There is a lot that goes into a real incident response. It would be crazy for me to go up here and say you could actually just automate all of SRE and R-RCA work today.

[11:07](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=667s) But there is a difference in the AI agent-driven approach, right? Here we're watching a Droid take a Sentry incident and convert it into a full RCA and mitigation plan.

[11:18](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=678s) Traditional incident response is effectively solving a puzzle. The pieces are scattered across dozens of systems, logs in one place, metrics in another, historical context somewhere else. There's knowledge in your team's head.

[11:32](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=692s) Droids in your organization fundamentally change this, right? When an alert triggers, you can pull in context from relevant system logs, past incident, runbooks in Notion or Confluence, team discussions from Slack.

[11:45](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=705s) And you can see that a Droid that has the tools and the ability to access this can condense that search effort from hours to minutes. And so really, the acceptable time to act for a standard enterprise organization should really-- it's really gonna be zero, right?

[12:03](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=723s) The moment that an incident happens, you should have a Droid that's telling you exactly what happened, exactly how to fix it. And the thing that gets interesting is when you have user and organization-level memory, you really start to build a model of what your team's response patterns and common issues are.

[12:19](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=739s) And so it's not just generating runbooks or generating a mitigation for one incident, right, but creating new processes that help solve some of these issues.

[12:29](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=749s) And once you've written that RCA, right-

[12:32](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=752s) You, you can move on to generate runbooks for those new learned patterns, update existing response workflows, capture team knowledge that gets shared automatically without e- without the need for manual curation.

[12:47](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=767s) And this is why all these things are connected. Agent native incident response is a part of a larger learning cycle that happens when you start to integrate agents into the workflow.

[12:58](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=778s) We're seeing teams that are able to cut incident response time in half because context is immediate. They're able to reduce repeat incidents because the third time something happens, the Droid starts to say, "Maybe we should fix this."

[13:12](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=792s) And they're able to improve team collaboration because when a new engineer joins the team and says, "How do we do this?" It's already in memory. They can just ask the Droid how we do this.

[13:23](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=803s) And so most importantly, what we're seeing in general is a shift from reactive to predictive operations because you can now start to really see the patterns across the entire operational history.

[13:35](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=815s) And agentic systems turn each of these incidents into an opportunity to make the entire system far more reliable. AI agents are not replacing software engineers. They're significantly amplifying their individual capabilities.

[13:51](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=831s) The best developers I know are spending far less time in the IDE writing lines of code. It's just not high leverage. They're managing agents that can do multiple things at once, that are capable of organizing the systems, and they're building out patterns that supersede the inner loop of software development, and they're moving to the outer loop of

[14:11](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=851s) software development. They aren't worried about agents taking their jobs. They're too busy using the agents to become even better at what they do. The future belongs to developers who understand how to work with agents, not those who hope that AI will just do the work for them.

[14:28](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=868s) And in that future, the skill that matters most is not technical knowledge or your ability to optimize a specific system, but your ability to think clearly and communicate effectively with both humans and AI.

[14:45](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=885s) Now, if you find any of this interesting and you wanna try the Droids, I'm happy to share that everyone here, uh, at this talk can use this QR code, uh, to sign up for an account.

[14:55](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=895s) Our mobile experience is not optimized yet, but the Droids are on that. And so I'd recommend trying this on a laptop, but you will get twenty million free tokens, uh, credited to your account.

[15:06](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=906s) Um, and I also wanna add that, uh, you know, first and foremost, Factory is an enterprise platform, right? And so if you're, if you're thinking about security, if you're thinking about where are the audit logs, whose responsibility is it when an agent goes and runs rm -rf recursive on your code base, right?

[15:23](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=923s) Our Droids don't do that. But if it were to, right, whose responsibility is that? Then these are the types of questions that we're interested in and that we're helping large organizations solve today.

[15:33](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=933s) And so if you're a security professional, if you're thinking about ownership, auditability, indemnification if you're a lawyer, right? These are the types of questions that you should start asking today because YOLO mode is probably not the best thing to be running inside your enterprise, right?

[15:50](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=950s) And so give it a scan, give it a try, check out some of the controls we have, um, and if you have any questions, feel free to reach out via email.

[15:58](https://www.youtube.com/watch?v=iheWKg2Tkrk&t=958s) Thanks. [clapping] [upbeat music]
