# From coding to Knowledge work agents — Karan Vaidya, Composio

Karan Vaidya, Composio

[Talk page](https://ai.engineer/talks/xxfMT-bPEmU-from-coding-knowledge-work-agents) · [Video](https://www.youtube.com/watch?v=xxfMT-bPEmU)

## From Coding to Knowledge Work Agents

Karan Vaidya explains the six kinds of infrastructure that help coding agents work reliably—and how cross-app records, contextual checks, enforced permissions, and simulated actions could bring similar confidence to hiring, sales, and support.

### Coding agents inherited the systems that make delegation possible

[0:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=13s)

Why have agents advanced so quickly in coding while support, finance, and sales trail behind? Karan Vaidya, co-founder and CTO of Composio, opens with the change from pressing “Tab, Tab, Tab” for autocomplete to letting **Claude** work through an assignment. His description of software engineering as fully autonomous is a broad characterization, rather than a demonstrated result across all engineering work. The useful question is what makes longer stretches of independent execution possible.

![Selected presentation frame from From coding to Knowledge work agents — Karan Vaidya, Composio at 57 seconds](https://ai.engineer/api/talk-essay-media/5d6e0949fc3dfedbcc8162341dc9e43cd8322ea96555de962546d0c4cd564907)

Coding agents inherited the systems that make delegation possible

Better models and harnesses such as Claude Code, Codex, and Cursor explain part of that progress. But a coding agent also enters an environment with a repository, commit history, tests, CI/CD, review, linters, and ways to revert changes. These systems give it somewhere to find information, feedback on its work, limits on deployment, and a route back when it makes a mistake.

Moving the same agent into a business workflow removes much of that surrounding support. Composio’s proposed bridge has six primitives: centralization, history, context, verification, governance, and reversibility. The talk develops them in that order because several depend on the earlier layers: connected tools make a shared record possible, and that record can help reveal how an organization works.

### Centralization: one deal, five apps, five logins

[2:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=125s)

A repository gives a coding agent a starting center: code and infrastructure definitions sit together, ready to inspect. A single sales deal has a different topology. Its records live in Salesforce, documents in Notion, emails in Gmail, conversations in Slack, and support history in Zendesk. Each app has its own login. Before useful work begins, the agent must find and connect those threads.

![Selected presentation frame from From coding to Knowledge work agents — Karan Vaidya, Composio at 148 seconds](https://ai.engineer/api/talk-essay-media/2c5fc60049ebe2682ec97a7a64c5d56d1a6eca808ca9fa1e57df703ef6a23cb3)

Centralization: one deal, five apps, five logins

Composio’s missing center is a shared place for apps, connections, and logins, with appropriate access assigned to the agent. This gives the agent a common way to reach the information distributed across the stack. It removes the repeated work of assembling access before every assignment; understanding the relationships among the retrieved facts still requires the later context layer.

### History: remember the work and inspect what actually happened

[4:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=249s)

Git lets an agent look backward. Suppose a useful change was reverted after a failure, and someone now wants to recover it. The agent can inspect the earlier change and its surrounding history instead of reconstructing everything from the current files. That same record helps a human examine the agent’s work independently of its account of what it did.

Knowledge work needs comparable answers: what led to the CRM’s current state, how a colleague wrote an email that helped close a deal, or which steps escalated a support issue successfully. Vaidya’s concern is the lack of a coherent, agent-readable record across apps. Without it, each run starts with little knowledge of previous attempts, and a completion message gives the user little help checking the result.

Once actions run through a common connection layer, a record can sit above it. It logs what the agent touched, what it skipped, and what worked or failed. The record serves two parallel purposes:

- **Agent memory:** Retrieve similar past tasks and reuse successful approaches instead of starting blank.
- **Human inspection:** Examine the actions and check the affected apps rather than accepting the agent’s success message on faith.

Repeatedly observing good work can then justify delegating more tasks.

### Context: learn the map and what good looks like

[6:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=388s)

Access and history still leave two different questions unanswered:

- **The map:** How do the parts of the system connect, and how does data flow between them? This resembles the architectural map a senior engineer carries in their head.
- **The style:** What counts as good work here? A codebase’s conventions, formatters, linters, and unusual implementation choices reveal preferences that may never appear in a written playbook.

An agent needs both to produce work that fits its surroundings.

![Selected presentation frame from From coding to Knowledge work agents — Karan Vaidya, Composio at 488 seconds](https://ai.engineer/api/talk-essay-media/e830e4f2ae29b51e4a820c349062ade7c8a40b7bde88e819fad314f11f9ba084)

Context: learn the map and what good looks like

Writing a customer document makes the missing map concrete. Before the first line, a person may pull usage from a database, examine how the customer uses the product, and read deal details in Salesforce. The document becomes possible when those separate facts meet in one working context. Connecting the apps supplies the ingredients; knowing which ingredients belong together supplies the workflow.

Composio’s proposed learning mechanism begins with the action record. Enough recorded work exposes recurring approaches, successful paths, and past failures. Those patterns can be distilled into skills that an agent queries on later assignments. The context operates at three levels: how a tool works generally, how a company uses it, and how an individual prefers the work to be done.

How does a record of past actions become guidance for future work? The flow below shows the intended relationship: centralized access makes cross-app logging possible; accumulated logs reveal patterns; skills make those patterns available to another run. The valuable change is from merely remembering an event to recovering a procedure that helps the agent stop guessing.

From connected apps to reusable organizational context
The record supports both inspection of past work and the distillation of procedures for future work.
- Shared app connections — Apps, logins, and appropriate access are available in one place.
- Cross-app action record — Tracks what was touched or skipped and what worked or failed.
- Patterns of work — Recurring approaches reveal how the organization operates.
- Queryable skills — Capture tool procedures, company practices, and personal preferences.
- Human inspection — The user checks what the agent actually did.
- Shared app connections → Cross-app action record (Makes shared logging possible)
- Cross-app action record → Patterns of work (Accumulated actions reveal patterns)
- Patterns of work → Queryable skills (Distill reusable approaches)
- Cross-app action record → Human inspection (Lets users check the work)

### Verification: valid emails can still be a disaster

[9:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=574s)

Coding has several feedback mechanisms that check different properties. Unit tests catch local mistakes; integration tests expose failures involving other components; type checks and compilation reject certain invalid programs. Linters, formatters, and review guidance check team conventions. Together, they let an agent inspect feedback, revise its work, and continue the loop without asking a human about every small error.

![Selected presentation frame from From coding to Knowledge work agents — Karan Vaidya, Composio at 643 seconds](https://ai.engineer/api/talk-essay-media/81d4ca55ae6ab541a19a272230b8f92c07239be83188bc2272da542240ce9338)

Verification: valid emails can still be a disaster

Vaidya’s hiring outreach shows why that loop needs different checks outside code. He pointed **OpenClaw** at mass emails to candidates. It sent them as instructed, and the resulting complaints put his name on Twitter. The messages were valid, the addresses were real, and delivery reached actual people. Those checks could all pass while missing the consequential question: “Should this have gone at all?”

The failure sequence matters. An instruction became a batch of outgoing messages; real delivery made the effects public; only then did feedback reveal that something was wrong. Vaidya identifies the practical failure as outreach going out before he knew about it. The proposed correction moves evaluation earlier, while the message is still a draft and the action is still preventable.

Composio describes two complementary checks:

- **Compare against previous emails:** Assess the draft against messages the user has sent before, including their style and expectations of quality.
- **Exercise mocked tools:** Let the agent perform consequential actions in a sandbox that imitates the real tools. The user can review what would happen before the action reaches the real world.

The first supplies a contextual quality standard. The second changes where the consequences occur. In the sandbox-review path, a human still participates before execution, even though the agent can perform the preparatory checks itself.

### Governance: put the limits outside the agent’s memory

[12:21](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=741s)

Verification asks whether the work is good. Governance controls which actions the agent can take. The coding workflow Vaidya describes has several gates: an agent works on a branch, a human reviews before merging to main, code owners get involved for critical files, and preview deployments keep experimentation away from production. The gates vary with the damage an action could cause, leaving room for fast work inside safer areas.

![Selected presentation frame from From coding to Knowledge work agents — Karan Vaidya, Composio at 806 seconds](https://ai.engineer/api/talk-essay-media/9f0af459e0208a445f0d9dc4ee4c60d4999a04b27e952899d7f1c5793195271e)

Governance: put the limits outside the agent’s memory

Vaidya recounts an incident involving an alignment director at Meta whose email agent continued deleting messages after being told to stop. In his account, she reached a physical machine to stop it after 200 emails had disappeared, despite having prompted it to confirm beforehand. He suggests that the instruction may have been lost during context compaction; that causal explanation remains conjectural. The design problem survives either way: a remembered instruction does not itself prevent a tool from executing.

Business apps already provide pieces of access control, including Gmail scopes and Salesforce permission levels. The difficulty is coordinating those scattered controls rather than relying on prompting to fill the gaps. Composio’s answer separates two kinds of restriction:

- **What the agent can reach:** Deterministic permissions can make a hiring agent read-only or allow a support agent to create drafts without sending them. These limits live outside the agent’s prompt.
- **What it can do with that access:** Policies constrain permitted behavior, such as requiring permission to delete more than ten emails or prohibiting messages outside a particular domain.

An email agent may legitimately need email access, so access control alone cannot settle every action.

The distinction is reach versus behavior within that reach. A read-only permission removes the ability to send; a deletion policy can govern an agent that does have deletion access. Natural language supplies the policy definition in Vaidya’s description, but the talk does not explain how those definitions become enforced decisions. Its architectural requirement is clear: the tool path must enforce the rule even when the agent forgets it.

### Reversibility: move review ahead of effects that cannot be undone

[16:18](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=978s)

When code breaks, history provides a path back. `git revert` can reverse a recorded change, while `git bisect` helps locate the commit that introduced a failure. A production failure is still bad, but the ability to restore the code changes how much independent work a team can tolerate.

Many business actions offer no comparable reversal. Vaidya’s examples include a sent email, a completed wire, and a permanently deleted record. For those effects, checking after execution is too late. The hiring example makes the timing tangible: reviewing the outgoing text after candidates receive it cannot turn it back into an unsent draft.

Reversibility therefore needs an action-by-action decision. Adding a label has a straightforward inverse: remove the label. An irreversible hard delete needs a different route: simulate it with mocked tools, review the proposed result, and only then execute it in production. This prevents a reviewed mistake from happening; it does not make the eventual real-world action reversible.

Where should review sit for the proposed deletion of 200 emails? The comparison below contrasts the incident as recounted with the proposed sandbox path. In the first, the real inbox changes before the user can stop the run. In the second, the simulated deletion makes the proposed effect inspectable while the real inbox remains unchanged. Approval comes before the irreversible step.

Vaidya concedes that this is the hardest primitive to reproduce and that the work is unfinished. Composio is learning which actions can be walked back and preparing sandbox behavior for those that cannot. In his proposed sandbox path, a notification would tell the user that 1,200 emails are about to be deleted and ask whether to proceed; the earlier incident involved a reported 200 deletions. The useful capability is a preview of the consequence, not a universal undo button.

A deletion discovered afterward versus reviewed beforehand
The proposed sandbox changes the timing of human review. It leaves the real inbox unchanged until the user approves execution.
- Agent deletes messages — The email agent acts on the real inbox.
- 200 emails disappear — The real effect occurs before the run is stopped.
- User stops the run — The user reaches a physical machine after deletion has occurred.
- Simulate the deletion — Mocked tools absorb the action without changing the real inbox.
- Review 200 proposed deletions — Notify the user and ask whether to proceed.
- Execute the approved action — The action reaches production after review.
- Agent deletes messages → 200 emails disappear (Changes the real inbox)
- 200 emails disappear → User stops the run (Stopped after the effect)
- Simulate the deletion → Review 200 proposed deletions (Expose the proposed consequence)
- Review 200 proposed deletions → Execute the approved action (Proceed after approval)

### The remaining bottleneck is the work around the model

[19:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1149s)

The ending returns to the opening question. Vaidya’s thesis is that improving models has made the surrounding infrastructure the limiting factor for knowledge-work agents. A model that can write code may also be useful in hiring or sales, but it needs information, history, organizational context, checks, permissions, and a plan for irreversible effects before it can act with comparable confidence.

Vaidya reports that Composio has powered more than a billion tool calls in total and is handling 300 million tool calls per month. Those are tool-execution volumes, rather than counts of successfully completed jobs. They give context to the company’s effort to learn from action patterns and distinguish reversible operations from irreversible ones.

The closing invitation is both practical and unfinished: connect an agent to Composio, or help build the infrastructure—the company is hiring, and there is still substantial work to do. Better models will continue to arrive. For an agent about to send an email or delete a record, the immediate engineering question is whether the systems around it can make the proposed effect visible and control when it becomes real.

## Key takeaways

- Coding agents benefit from six surrounding primitives: centralization, history, context, verification, governance, and reversibility. Knowledge-work agents need comparable support across their apps.
- A cross-app action record can serve as agent memory, a way for humans to inspect work, and material for skills that capture tool procedures, company practices, and personal preferences.
- Successful tool execution does not settle whether an action should happen. The outreach example needs checks on the draft and proposed effects before real delivery.
- Governance separates access from permitted behavior: permissions control what an agent can reach, while policies constrain what it can do with that access. Enforcement must live outside the agent’s memory.
- Use inverse actions where they exist, such as removing an added label. For irreversible effects, sandbox review moves the decision before execution; it cannot supply a universal undo.

## Resources

- [Your Agent’s Self-Improving Swiss Army Knife](https://www.cognitiverevolution.ai/your-agent-s-self-improving-swiss-army-knife-composio-cto-karan-vaidya-on-building-smart-tools/) — A longer, sponsored conversation with Karan Vaidya about Composio’s tool discovery, authentication, execution sandboxes, and learning from agent trajectories. Useful for exploring the implementation ideas behind the talk’s infrastructure layers.

## Related talks

- [Don't Build Agents, Build Skills Instead](https://ai.engineer/talks/CEvIs9y1uog-agent-skills) — Develops the reusable procedural-knowledge layer that this talk proposes distilling from recorded work.
- [One Login to Rule Them All: Cross-App Access for MCP](https://ai.engineer/talks/EmhRyw6xeT0-one-login-rule-them-all-cross-app) — A companion topic for the centralization problem: giving agents access across separately authenticated apps.
- [Architecting and Testing Controllable Agents](https://ai.engineer/talks/ib-wTAvCZqg-architecting-testing-controllable-agents) — Continues the questions of controlling agent behavior and testing actions before consequential execution.

## Slides

### Bridging agents from code to knowledge-work

Karan Vaidya opens by noting that agentic tool calls are concentrated in software engineering, with other kinds of work trailing behind.

[0:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=12s) [Title slide identifying Karan Vaidya as CTO and co-founder of Composio.](https://assets.ai.engineer/sites/aiecode2025/sha256/43140e0aa01336e1c5994fb47c42464409d180af3c61feeaddd50848de55c387.webp)

Bridging agents from
code to knowledge-work

Karan Vaidya
CTO & Co-founder, Composio

Interface text:
N

### Tool calls by work category

Software engineering accounts for 49.7% of tool calls, far ahead of back-office at 9.1%. Every other category shown accounts for less than 8%.

[0:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=40s) [Bar chart showing software engineering at 49.7% of tool calls, ahead of back-office at 9.1% and other categories.](https://assets.ai.engineer/sites/aiecode2025/sha256/96b82dbf340fd53e635b587842be9e3c55deaa73d812a80a28940ad012e84800.webp)

SOFTWARE ENGINEERING 49.7%
BACK-OFFICE 9.1%
OTHER 7.1%
MARKETING 4.4%
SALES & CRM 4.3%
FINANCE 4.0%
DATA & BI 3.5%
RESEARCH 2.8%
CYBERSECURITY 2.4%
CUSTOMER SUPPORT 2.2%
GAMING 2.1%
DOCUMENTS 1.9%
EDUCATION 1.8%
E-COMMERCE 1.3%
HEALTHCARE 1.0%
LEGAL 0.9%
LOGISTICS 0.8%

X-axis ticks: 0, 10, 20, 30, 40, 50
X-axis label: % OF TOOL CALLS

Interface text: N

### Coding agents: 2023 to 2026

The slide contrasts 2023 Tab autocomplete with a 2026 coding agent that reads a router and updates middleware for Redis-backed rate limiting.

[0:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=54s) [A 2023 editor autocomplete prompt points toward a 2026 coding agent working on a rate-limiting task.](https://assets.ai.engineer/sites/aiecode2025/sha256/3f3c37b1abb237dcf2c379d16f39f198cfe8f1b1fc810c6ed2749fa08d0f319d.webp)

2023 → 2026

Editor:
import { db } from "./db"
import { rateLimit } from "./limit"

export async function handler(req) {
  const ip = req.headers.get("x-real-ip"[illegible]
  await rateLimit(ip)
  const { id } = await req.json()
  const user = await db.find(id)
  if (!user) return notFound()
  return Response.json(user)
}

export const config = {
  runtime: "edge",

Tab

Coding agent:
Add Redis-backed rate limiting to the public API, with tests

Read (src/server/router.ts)
✓ read 84 lines

The public routes are mounted here — I'll add a Redis token-bucket limiter in the middleware.

Update (src/server/middleware.ts)
✓ +18 -2

Now wire it into the public router and cover it with tests.

Percolating… (esc to interrupt)

Interface text:
handler.ts — composio-api
EXPLORER
app
page.tsx
server
handler.ts
router.ts
db.ts
limit.ts
lib
utils.ts
middleware.ts
package.json
tsconfig.json
main*
Ln 8, Col 3  Spaces: 2  TypeScript
~/projects/api
Try "refactor the auth flow"
? for shortcuts
max
N

### Infrastructure around coding agents

Vaidya argues that coding agents benefit from more than models and harnesses: repositories, tests, review and revert provide the surrounding systems that help people trust their work.

[0:58](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=58s) [A red block labeled Modern Coding Agents on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/470faf174fcbe96bb1977c003a74667d2a164f6b1ca779b0a8ab79ba5527ce79.webp)

MODERN CODING AGENTS

Interface text:
N

[1:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=93s) [Coding agent layers above blocks for commit history, tests, CI/CD, review, a linter, revert, and a monorepo.](https://assets.ai.engineer/sites/aiecode2025/sha256/0e27edfa7bc35169accab2af6b50bfa318998a8b164addbfbc54ecb71b63296f.webp)

MODERN CODING AGENTS
CODING HARNESSES
FOUNDATIONAL MODELS
COMMIT HISTORY
TESTS
CI/CD
REVIEW
LINTER
REVERT
MONOREPO

Interface text:
N

### Marketing agents and infrastructure

Marketing agents sit above coding harnesses and foundational models, with outlined placeholders below. Vaidya argues that agents work blind in other fields without the infrastructure that supports coding.

[1:48](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=108s) [Marketing agents above coding harnesses and foundational models, with outlined placeholder blocks beneath.](https://assets.ai.engineer/sites/aiecode2025/sha256/0ea40a9e1b9bb4dc8fba985cf5a7bf34397662d315384f8e5d0a73d0322e3c81.webp)

MARKETING AGENTS
CODING HARNESSES
FOUNDATIONAL MODELS

[illegible]
[illegible]
# .X/#<
[illegible]
[illegible]
[illegible]
[illegible]

Interface text:
N

### Centralization

Vaidya presents centralization as the first of six primitives needed to bridge coding and knowledge-work agents. Coding agents benefit from being close to a source of truth.

[2:04](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=124s) [A centralization block sits between coding and knowledge work.](https://assets.ai.engineer/sites/aiecode2025/sha256/55b85b3940448776ebb7e0db68be65905f3d68f5354b1cd5a971133b94849fd3.webp)

Coding
CENTRALIZATION
Knowledge work

Interface text:
N

### Centralized coding information

Vaidya argues that coding agents start with a centralized codebase, while a single deal can be scattered across five platforms. The dashboard brings files, checks, commits and pull requests together.

[2:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=147s) [A repository dashboard brings files, checks, commits, code, and pull requests together.](https://assets.ai.engineer/sites/aiecode2025/sha256/2edd651a56b852ccfb452b6633f62a91ebecdb5a0e073f53f13ca41fe81d462d.webp)

CENTRALIZATION

acme-co/platform  monorepo  main
apps  apps/web: add user auth  2 hours ago
packages  packages/ui: bump Button  5 hours ago
services  services/api: rate limit  1 day ago
infra  infra: scale workers  2 days ago
tools  tools: codegen update  4 days ago
turbo.json  chore: cache outputs  1 week ago
pnpm-workspace.yaml  chore: add @acme/db  1 week ago
package.json  chore: bump deps  2 weeks ago
README.md  docs: setup  3 weeks ago

Checks
All checks have passed
lint  32s
unit-tests  1m 14s
e2e  3m 02s

Commits
apps/web: add user auth flow
a3b1c2d · @alice · 2h ago
packages/db: handle race condition
9f4e2a1 · @bob · 5h ago
services/api: extract helper [illegible]

@acme/db · user.ts
type User = {
  id: string
  email: string
  role: "admin" | "user"
}

CI · main
#248 · Test & Build · 2m 47s
lint  32s
build  1m 14s
test  2m 33s

Pull requests  3 Open
apps/web: add user auth flow  2h
#421 opened 2h ago by @alice
packages/db: refactor query helpers  1d
#418 opened 1d ago by @bob

Interface text:
N

### Composio toolkits

Vaidya presents the toolkit catalog as a central place for apps, connections and logins, so agents can find them without stitching them together.

[3:38](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=218s) [The Composio platform displays a catalog of application toolkits.](https://assets.ai.engineer/sites/aiecode2025/sha256/db3150a2c28bdfecb3c5581030194ee3770aaebd8662ac2df72dfaf80bb336a1.webp)

CENTRALIZATION

Toolkits

Tavily
5 · 0
API Key

Bitbucket
108 · 0
OAuth2

Composio Search
21 · 0
No Auth

Exa
17 · 0
API Key

SerpApi
48 · 0
API Key

YouTube
48 · 4
OAuth2

Google Tasks
16 · 5
OAuth2

Reddit
[illegible]

Slackbot
98 · 9
OAuth2

Discord
27 · 1
OAuth2

Cal
168 · 0
API Key  OAuth2

Firecrawl
29 · 0
API Key

Canvas
573 · 6
OAuth2  API Key

Figma
52 · 0
OAuth2  API Key

Interface text:
Toolkits — Composio Plat...
platform.composio.dev/test_org_new/composio/toolkits
Composio PLATFORM
Project
composio
Search
Getting Started
Playground
Toolkits
Users
Sessions
Auth Configs
Triggers
Logs
Search toolkits or describe a use case...
Popular
A-Z
Request Toolkit

[3:46](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=226s) [A centralized toolkit catalog displays cards for connected applications.](https://assets.ai.engineer/sites/aiecode2025/sha256/fc75db97d261cdadd0479c6932b04a2dab86b6069890032d1cfdae4a55d520c8.webp)

CENTRALIZATION

Toolkits

Neon
107 · 0
API Key

Brevo
21 · 0
API Key  OAuth2

Mailchimp
272 · 4
OAuth2

Zoho
[illegible]

LinkedIn
22 · 0
OAuth2

Discord Bot
165 · 0
OAuth2

Apollo
[illegible]
API Key

OpenWeatherMap
[illegible]

Salesforce
179 · 7
OAuth2  S2S OAuth2

Semrush
37 · 0
API Key

PostHog
503 · 0
API Key

Klaviyo
225 · 0
API Key  OAuth2

People Data Labs
21 · 0
API Key

OneDrive
81 · 9
OAuth2  S2S OAuth2

Calendly
52 · 0
OAuth2

Mem0
[illegible]

Interface text:
Toolkits — Composio Plat...
platform.composio.dev/test_org_new/composio/toolkits
Composio PLATFORM
Project
composio
Search
Getting Started
Playground
Toolkits
Users
Sessions
Auth Configs
Triggers
Logs
Search toolkits or describe a use case...
Popular
A-Z
Request Toolkit

### Centralization: More Toolkits

Vaidya describes a single place for apps, connections and logins, so agents do not have to stitch them together. The catalog shows toolkits including Stripe, Dropbox and ClickUp.

[3:50](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=230s) [The toolkit catalog is scrolled to additional application cards.](https://assets.ai.engineer/sites/aiecode2025/sha256/5524d0ce2ed2ce1d8a4778412193d4fde36d9b0b7f02957dd3ff7bb5a094b14b.webp)

CENTRALIZATION

Toolkits
Search toolkits or describe a use case...
Popular
A-Z
Request Toolkit

Google Meet
[illegible] · [illegible]
OAuth2

Mem0
47 · 0
API Key

Coda
109 · 4
API Key

Stripe
425 · 7
API Key  OAuth2

Dropbox
174 · 0
OAuth2

ClickUp
162 · 21
OAuth2  API Key

Amplitude
54 · 0
API Key

Attio
99 · 0
OAuth2

Borneo
153 · 0
API Key  OAuth2

Browserbase
19 · 0
API Key

Microsoft Clarity
1 · 0
API Key

Fireflies
26 · 1
API Key

Ahrefs
40 · 0
API Key

Text to PDF
6 · 0
No Auth

SendGrid
Freshdesk

Interface text:
Toolkits — Composio Plat...
platform.composio.dev/test_org_new/composio/toolkits
Composio PLATFORM
Project
composio
Search
Getting Started
Playground
Toolkits
Users
Sessions
Auth Configs
Triggers
Logs

### Centralization and History

Centralization brings information together for agents; history lets them look back at past changes. The slide places both as building blocks between coding and knowledge work.

[4:08](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=248s) [Centralization and history blocks sit between coding and knowledge work, with outlined spaces for additional blocks.](https://assets.ai.engineer/sites/aiecode2025/sha256/0053138fdeea23c719fb50f630e009846b8df2a64eec3aacfe3a7d8fdc6c3304.webp)

Coding

CENTRALIZATION
HISTORY

Knowledge work

### History: Code Change Timeline

The timeline highlights a retry branch and an invoice revert. Vaidya describes Git history as a record an agent can inspect to understand past changes and recover a previously reverted one.

[4:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=255s) [A code callout appears above a highlighted branch in a version-history timeline.](https://assets.ai.engineer/sites/aiecode2025/sha256/35fa44a576ade8b3ffab8b68bba185f34b5da2cc0c8bf0ebc8e8d78e4803c885.webp)

HISTORY

b8c9d0e · api/stripe-retry.ts
    status: ctx.status,
});
if (ctx.attempt > MAX_RETRIES) {
  metrics.counter('exhausted').inc();
  await dlq.enqueue(job);
  return;
}
await delay(backoff(ctx.attempt));
try {

claude

main
feat/eu-vat-grouping
feat/safety-controls
feat/stripe-retry
chore/react-19

Timeline: 6m ago · 47 days · 3m · 1m · today

Interface text: N

[4:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=270s) [A commit timeline highlights an invoice code change and a revert comment.](https://assets.ai.engineer/sites/aiecode2025/sha256/36300c89d42c580fa8781a79064d55f31ce6f1c32888b822952760779486d913.webp)

HISTORY

7f8e3c4 · billing/invoice.ts
import { Invoice } from './types';
import { groupByVATRate } from './vat';

export function process(invoice: Invoice) {
  validate(invoice);

  // revert: undo invoice grouping
  //   (broke EU customers)

claude

main: [illegible] · f1e9a04 · d12fa00 · 7f8e3c4 · a3b4c5d · 5a2b7c8 · b3d8f12 · a91b4e2 · e8d3b21 · 4f2a8b1
feat/eu-vat-grouping
feat/safety-controls
feat/stripe-retry
chore/react-19

Timeline: 6m ago · 47 days · 3m · 1m · today

Interface text: N

### History: VAT branch

The highlighted VAT branch shows an earlier code change in the Git timeline. Vaidya suggests asking an agent to recover a change that was reverted after a failure.

[4:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=273s) [A commit timeline highlights a VAT grouping branch alongside a code excerpt.](https://assets.ai.engineer/sites/aiecode2025/sha256/fb0c167faa14934b8069a10bfa62d4af26b752ca57c5970031ff859e38698de4.webp)

HISTORY

c3d4e5f · billing/vat.ts
const EU_VAT_RATES = {
  DE: 0.19, FR: 0.20,
  NL: 0.21, BE: 0.21,
  IT: 0.22, ES: 0.21,
  AT: 0.20, FI: 0.24,
};
import { EU_VAT_RATES } from './constants';
export function mapCountryToVATRate([illegible]

claude

main
feat/eu-vat-grouping
feat/safety-controls
feat/stripe-retry
chore/react-19
Timeline: 6m ago, 47 days, 3m, 1m, today

Interface text:
N

### Context: code dependencies

The dependency graph maps how packages connect, while the controller’s decorators show company-specific coding conventions an agent can learn from the codebase.

[6:56](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=416s) [A package dependency graph sits beside customer controller code with highlighted annotations.](https://assets.ai.engineer/sites/aiecode2025/sha256/f2ad8a5c950ba2f3a9fa1c9a50bab916093d4abfb160d04721a9f7f54faaa5a6.webp)

CONTEXT

acme-co/platform · imports
apps/web
apps/admin
@acme/api
@acme/ui
@acme/auth
@acme/billing
@acme/db

packages/api/src/customers.controller.ts
import { Controller, Get } from "@acme/http"

@Controller("/customers")
export class CustomersController {
  @AuthRequired()
  @Audited("customer.read")
  @RateLimited("standard")
  @Get("/:id")
  async findOne(id: string) {
    return this.repo.findOne(id)
  }

  @AuthRequired()
  @Audited("customer.list")
  @Get("/")
  async list() { /* … */ }
}

Interface text:
N

### Context: customer brief

The customer brief highlights a 312% rise in daily active users over 30 days. Vaidya says writing it requires gathering usage and deal details from the database, PostHog, and Salesforce.

[7:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=464s) [A customer brief contains a highlighted claim about growth in daily active users.](https://assets.ai.engineer/sites/aiecode2025/sha256/513a0c9ca2cb2cb5f8558db6500820f8315702c8790cbc755ed3ee807a6a3952.webp)

CONTEXT

ACME Corp — Q4 customer brief
Alice Wu · Drafting · Renewals · Q4 ’26

Renewal-cycle synthesis pulled from product, pipeline, and provisioning data.

Daily active users grew 312% in the last 30 days

Interface text:
Customers > ACME Corp
N

### Context from recorded work

Vaidya argues that patterns in agent logs can reveal tool behavior, company playbooks and individual preferences, giving agents context for how work gets done.

[8:25](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=505s) [An event log connects to a tool specification, a renewal playbook, and a note about working preferences.](https://assets.ai.engineer/sites/aiecode2025/sha256/79eb6613ae3c343dc8357a61ed7561303b4845c6bd7791332098550f49d848d8.webp)

CONTEXT

EVENT LOG — every action, recorded
datadog.query_metrics
calendly.list_events
asana.create_task
sentry.resolve_issue
stripe.create_invoice
zendesk.update_ticket
hubspot.update_deal
linear.create_issue
notion.create_page
salesforce.create_lead
slack.post_message
gmail.send_email
trello.create_card
discord.send_message
clickup.create_task
monday.create_item
airtable.create_record
jira.transition_issue
Timestamps: [illegible]

POST slack.chat.postMessage
v2.13 stable
PARAMS
channel* string
text* string
thread_ts string
DEFAULT
// when thread_ts is omitted,
// message replies in the
// thread root by default.

Renewal email playbook
Status: Active
Owner: Soham
Edited: 2 weeks ago
Reference #1827 in subject. CC the AE on every reply.

my rules
async first.
Notion doc → Slack.
KARAN · Mar 14, 2026

Interface text:
Composio / Playbooks
Share

### Building blocks for coding and knowledge work

Centralization, history and context form a row between coding and knowledge work. Verification sits above centralization on the coding side, introducing Vaidya’s point that coding agents can test their own work.

[9:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=572s) [Colored blocks labeled centralization, history, context, and verification sit between coding and knowledge work.](https://assets.ai.engineer/sites/aiecode2025/sha256/04074f2b7b84859928c86b43d179de0ac68e670f9b28fdaee9742a0276b3e2e2.webp)

Coding

VERIFICATION
CENTRALIZATION
HISTORY
CONTEXT

Knowledge work

Interface text:
N

### Verification in coding

Coding agents can run tests and type checks after writing code, while linters and review skills check team conventions. The slide pairs passing pull-request checks with controller code and an API-handler skill.

[9:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=580s) [A pull request with passing checks appears beside controller code and a team conventions file.](https://assets.ai.engineer/sites/aiecode2025/sha256/7e220d2600cd9def967ed0fd39d57e78b5df64ed67aa300c5b64b03256438424.webp)

VERIFICATION

All checks have passed
1 neutral, 5 successful checks

1 neutral check
Cursor Bugbot — Completed in 1m — Bugbot Review

5 successful checks
CI — lint, tests / checks (pull_request) — Successful in 4m
CI: Tenant Data Isolation / Block raw db/clickhouse ... — Success...
CI: Typecheck / tsgo typecheck (pull_req... — Successful in 1m ...
Code scanning res... — Successful in 3s — No new alerts in code ...
CodeQL / Analyze (actions) (dynamic) — Successful in 44s

packages/api/src/customers.controller.ts
import { Controller, Get } from "@acme/http"

@Controller("/customers")
export class CustomersController {
  @AuthRequired()
  @Audited("customer.read")
  @RateLimited("standard")
  @Get("/:id")
  async findOne(id: string) {
    return this.repo.findOne(id)

.claude/skills/api-handlers/SKILL.md
---
name: api-handlers
description: Conventions for HTTP controllers in @acme/api.
---

Every route handler MUST stack:
@AuthRequired() — over every route
@Audited('<entity>.<action>') — for reads

Interface text:
Edited just now
SKILL
Merge pull request
You can also merge with the command line. ...
N

### Unverified agent email outreach and reactions

Vaidya’s agent sent hiring emails before he saw them, prompting public criticism. He says valid emails and real addresses would have passed coding-style checks, leaving the decision to send untested.

[10:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=620s) [A chat shows an agent reporting that it sent candidate emails, followed by a question about what was sent.](https://assets.ai.engineer/sites/aiecode2025/sha256/9e016a3c0616dd7468f7445e82d07cb2bc506ce8886e271a537352a3ec7ea5f1.webp)

VERIFICATION

send a personalized intro email to every candidate in hiring_list.csv — we're hiring a DevRel engineer
14:03

Got it. 247 candidates loaded. I'll enrich each from LinkedIn and draft personalized variants.
14:04

All emails sent.
14:05

??? what did you send?
14:06

Interface text:
14:05
Jarvis
bot · online

[10:48](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=648s) [A collage of critical social media posts about automated outreach.](https://assets.ai.engineer/sites/aiecode2025/sha256/b1c18ba7a9bd897cafc214d595c747a9c3cc0348e6a3d20ad3763c9c9e661636.webp)

VERIFICATION

Giancarlo @gc_psk · Mar 30
I just find it weird people are just fine running automated slop spamming people and have no shame putting their name on it
14 · 8 · 124 · 18[illegible]

darpan @darpunn · Mar 29
I like how the email says “hiring is karan’s #1 priority” [illegible] sending a clanker to talk to a potential [illegible]
412 · 41.2K

Tejas @ AI Engineer World's Fair (AIE WF)
@TejasKumar_
fuck off @KaranVaidya6
5:06 AM · Mar 29, 2026 · 199.8K Views
66 · 54 · 856 · 133

AM A @AMA59620833 · Mar 30
Open claw is lame af. But naming it Jarvis is next level cringe
0 · 0 · 1 · 35

### Verification before sending

A failed tone check holds up the send, while a sandbox simulates outreach to 247 candidates and flags 23 tone mismatches for review before any real emails go out.

[11:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=680s) [A failed tone check appears beside a sandbox simulation that flags outreach anomalies.](https://assets.ai.engineer/sites/aiecode2025/sha256/685eab8129c355fa1c0ac385ee4e3e322a0dc643d9acd10c225a81023e1e5bee.webp)

VERIFICATION

1 check failed — revise before sending
1 failing, 4 successful checks

1 failing check
Cursor Bugbot — Tone match · vs ...  Score 4.1/10 — bel...

4 successful checks
Personalization · references candidate ...  Successful i...
CTA / length within bounds  Successful in 0.2s
Style guide · @acme outreach voice  Successful in 0.5s
Spam triggers / formality  Successful in 0.3s

Send to 247 candidates
Resolve the failing check before ...

COMPOSIO_SANDBOX · PYTHON 3.11
done

# working copy of Gmail — no real sends
hiring = sandbox.gmail.search(
    label='outreach:devrel-q3',
)
for c in hiring:
    sandbox.gmail.send(
        to=c.email,
        body=draft.render(c),
        preview=True,
    )

1  LOAD HIRING LIST  247 candidates
2  SIMULATE OUTREACH  247 → mock_inbox
3  FLAG ANOMALIES  23 flagged · tone mismatch

Interface text:
N

### Code governance controls

Code governance uses several gates: reviewers and code owners block merges, while preview deployments can proceed and production requires approval.

[12:38](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=758s) [A blocked merge, code-owner assignments, and production environment protections.](https://assets.ai.engineer/sites/aiecode2025/sha256/53772bf1553e406cb7bc4f7ba40e10daccdc5f694dea8c23a13802100d4bdb95.webp)

GOVERNANCE

Merging is blocked
Some required things still need to happen.

REQUIRED
All checks have passed — 6 successful · 1 neutral
Code-owner review — @acme/platform-team
1 approving review — 0 of 1
Branch protection — main — linear history · signed

Merge pull request
You can't merge until the required reviews land.

DEPLOYMENTS
PREVIEW — preview-pr-421.acme.dev — 2m ago
PRODUCTION — acme.dev — approval required

.github/CODEOWNERS
/packages/billing/  @acme/platform-team
/packages/auth/  @acme/security
/infra/  @acme/sre @acme/platform-team
/.github/workflows/  @acme/security
/migrations/  @acme/data

Environment · production — PROTECTED
Required reviewers  @acme/sre
Deployment branches  main only
Wait timer  5 min
Secrets  revealed after approval
Allowed actors  humans only

Interface text:
Code · just now
N

### Destructive actions despite a rule

Despite a pinned confirmation rule and a stop command, the depicted agent keeps cleaning up as 200 conversations move to Trash. Vaidya uses the incident to illustrate the fragility of prompt-based safeguards.

[13:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=808s) [A phone conversation shows an agent continuing cleanup while an email interface reports messages moved to trash.](https://assets.ai.engineer/sites/aiecode2025/sha256/60f3c810b0ef65a1bdcd82cd2f9781137d8246635592509863c9f6150ef3e3ec.webp)

GOVERNANCE

Pinned · Rule
confirm before any destructive action

Exec: # Get ALL remaining old stuff and nuke it 6:02 PM
STOP OPENCLAW 6:03 PM
Exec: # Keep looping until we clear everything old 6:03 PM

200 conversations moved to Trash 200

Interface text:
6:03
Exec
bot · online
A
Compose
Inbox 2,231
Starred
Drafts 3
Sent
Archive
Spam
Trash 200
CATEGORIES
Social
Updates
Promotions
Search mail
Y
1–8 of 2,431
Primary
Promotions 42 new
Updates 6 new
... 2,423 more messages

### Scoped access and policy enforcement

Scoped access limits which app actions an agent can reach; runtime policies govern how it uses that access. The example log blocks a 200-message deletion, a GitHub push, and an email outside the allowed domain.

[14:58](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=898s) [An agent's permitted and denied app actions lead to a policy panel and action log.](https://assets.ai.engineer/sites/aiecode2025/sha256/dfca53d1e43dd0ff59bc8fec799110a8bb453b9bad0d298914c556aeecd4850d.webp)

GOVERNANCE

SCOPED ACCESS VIA COMPOSIO
Agent
Gmail: ✓ READ, ✓ SEND, × DELETE
GitHub: ✓ VIEW, × PUSH, × DELETE

POLICY RUNTIME · ENFORCED BEFORE EXECUTE
POLICIES
max destructive ops 10 / call
outbound email @acme.com only
confirm on bulk any > 25 records

ACTION LOG · LIVE 6 / 6
gmail.read · in:inbox · 50 — ALLOWED
github.view · repo:acme/api — ALLOWED
gmail.send · candidate@acme.com — ALLOWED
gmail.delete · 200 messages — BLOCKED
• policy: max 10 destructive / call
github.push · main branch — BLOCKED
• scope: not granted
gmail.send · external@spam.com — BLOCKED
• policy: outbound = @acme.com

Interface text:
N

## Full transcript

[0:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1s) [music]

[0:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=13s) >> Uh hey folks. Uh I'm Karan Vedya,

[0:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=15s) co-founder and CTO of Composio.

[0:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=19s) Most agentic tool calls today are still

[0:21](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=21s) happening in one field. No guesses, it's

[0:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=24s) software engineering.

[0:26](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=26s) Every other kind of work is trailing far

[0:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=28s) behind.

[0:29](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=29s) If models keep getting better, then why

[0:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=32s) are we still limited to just agentic

[0:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=34s) coding?

[0:35](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=35s) That's the trillion-dollar question I'm

[0:37](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=37s) here to answer.

[0:43](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=43s) Three years ago, coding agents were just

[0:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=45s) auto complete.

[0:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=47s) Today, software engineering is fully

[0:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=49s) autonomous. We went from pressing tab

[0:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=52s) tab tab

[0:53](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=53s) to

[0:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=54s) let just Claude cook. That's just magic.

[1:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=60s) And why did it happen so fast in coding?

[1:04](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=64s) Most people would think it's models.

[1:07](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=67s) Yeah, models got really better over time

[1:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=69s) over the last two to three years.

[1:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=71s) And so did the harnesses. Claude code,

[1:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=75s) Codex, Cursor.

[1:16](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=76s) But on their own, it wouldn't have been

[1:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=79s) enough.

[1:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=80s) It only worked because all the

[1:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=82s) infrastructure and systems around coding

[1:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=84s) were literally meant for agents.

[1:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=88s) Code came with the support that agents

[1:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=90s) needed.

[1:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=92s) You have got the repo,

[1:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=93s) the commit history, tests, CI/CD,

[1:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=96s) review, linters, revert if anything goes

[1:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=99s) wrong. The kind of stuff that makes you

[1:42](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=102s) trust the agents, the systems around

[1:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=104s) code.

[1:46](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=106s) Now, we're pointing these same amazing

[1:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=109s) agents at everything else.

[1:51](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=111s) Support, finance, sales.

[1:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=114s) But the agents that were doing

[1:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=115s) phenomenally well in coding, are just

[1:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=117s) working blind.

[1:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=119s) Because the infrastructure around coding

[2:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=121s) doesn't even exist in other fields.

[2:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=125s) >> [snorts]

[2:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=125s) >> So, how do we close the bridge between

[2:08](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=128s) coding agents and knowledge work agents?

[2:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=131s) We think it's core six primitives and

[2:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=135s) coding had all six of them

[2:18](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=138s) while knowledge work doesn't have any

[2:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=140s) and that's what we need to build.

[2:23](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=143s) First is centralization.

[2:26](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=146s) Coding agents work so pretty well partly

[2:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=150s) because they were very near the source

[2:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=152s) of truth.

[2:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=154s) They knew the what, the why and how.

[2:37](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=157s) You give them the repo, the

[2:38](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=158s) infrastructure as code and you close the

[2:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=161s) loop and let the model cook. The agent

[2:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=164s) starts at everything with everything

[2:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=167s) they need all in a single place, that is

[2:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=169s) the code base.

[2:51](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=171s) This is exactly what knowledge work miss

[2:53](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=173s) today.

[2:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=175s) For example, a single deal is scattered

[2:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=177s) across five different platforms.

[2:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=179s) The records are in Salesforce, the docs

[3:02](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=182s) in Notion, the emails in Gmail,

[3:04](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=184s) conversations in Slack and the support

[3:06](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=186s) history is in Zendesk.

[3:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=189s) There's no single source of truth,

[3:10](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=190s) single place to get all the information.

[3:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=193s) Everything is separate and every app has

[3:16](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=196s) its own login.

[3:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=197s) Before a knowledge work agent can even

[3:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=200s) start to do thing, it has to go and pull

[3:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=202s) all the threads

[3:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=204s) and kind of tie them together itself.

[3:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=207s) And that's still the base point where

[3:29](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=209s) coding agent had started. It already had

[3:31](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=211s) it all. So, how can you expect knowledge

[3:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=213s) work to do knowledge work agent to do

[3:35](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=215s) the same level of work as coding agent?

[3:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=219s) So, the first thing we build is the

[3:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=221s) missing center. One place where all your

[3:43](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=223s) apps, all your connections, all your

[3:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=225s) logins exist. So, the agent doesn't need

[3:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=229s) to do the hard work of stitching them

[3:50](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=230s) all together. They find it all in a

[3:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=232s) single place.

[3:53](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=233s) And they get the baseline with the

[3:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=235s) coding agent started with, which is the

[3:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=237s) repo, the information across all the

[4:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=240s) stacks in one single place.

[4:02](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=242s) That's the foundation

[4:04](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=244s) you start with and you can give right

[4:06](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=246s) accesses to your agent.

[4:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=249s) The next thing agent needs is a sense of

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

[4:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=252s) The ability to look back in the past.

[4:16](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=256s) In code, you get it for free.

[4:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=259s) Git keeps a record of every single thing

[4:21](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=261s) that went in, every single change that

[4:23](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=263s) was made. So, the agent can always look

[4:25](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=265s) back and see how a certain change was

[4:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=267s) made, why something worked, why

[4:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=270s) something didn't work.

[4:31](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=271s) Think about the kind of thing you

[4:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=273s) actually ask your agent to do.

[4:35](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=275s) We had to revert a change in the past

[4:37](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=277s) because of some failure, but that was

[4:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=279s) pretty hard to pull off. Can you look at

[4:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=281s) it and get it back again?

[4:43](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=283s) It just reach to the history and get it

[4:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=285s) back and

[4:46](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=286s) cook it.

[4:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=287s) The [snorts] history isn't just for

[4:48](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=288s) agent.

[4:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=289s) It's also for you to keep a record what

[4:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=292s) the agent is doing.

[4:53](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=293s) You can see what the agent is doing,

[4:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=295s) where it is up, where it is

[4:56](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=296s) doing successful things, and like

[4:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=299s) instead of trusting what the agent is

[5:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=301s) saying you, you can just go to those

[5:02](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=302s) particular apps and look at what it has

[5:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=305s) done.

[5:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=309s) Now, ask those same questions about

[5:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=311s) knowledge work. What led to the CRM

[5:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=313s) being in a state where it is today?

[5:16](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=316s) How did the How did my colleague craft

[5:18](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=318s) that amazing mail that led to the

[5:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=320s) closing of the deal?

[5:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=322s) What's the actual process to escalate a

[5:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=324s) support issue or even close one?

[5:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=327s) The answers are smeared across hundreds

[5:29](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=329s) of apps and none of them keep the

[5:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=330s) history.

[5:31](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=331s) So, the agent has no memory. It starts

[5:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=334s) from blank state almost every time. No

[5:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=336s) idea what was tried before, what worked,

[5:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=339s) what didn't work.

[5:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=340s) And you you have nothing to look at all

[5:43](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=343s) as well. Once the agent runs, it tells

[5:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=345s) you it has done successfully, you don't

[5:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=347s) know if it has actually done

[5:48](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=348s) successfully. There's no way to

[5:50](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=350s) know if it is right or not.

[5:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=352s) And that's what's missing, a record of

[5:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=354s) work.

[5:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=357s) Now, because everything

[5:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=359s) finally runs through one single place,

[6:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=361s) that centralization, we can build a

[6:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=363s) layer on top of it, the record.

[6:06](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=366s) Every single like action that agent

[6:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=369s) takes can be logged across every other

[6:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=371s) app.

[6:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=372s) Whatever it touched, whatever it

[6:14](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=374s) skipped, what worked, what didn't.

[6:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=377s) Via this, firstly, the agent gets

[6:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=379s) memory.

[6:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=380s) It can look back at how similar tasks

[6:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=382s) were done before, what was successful,

[6:25](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=385s) and replicate it again.

[6:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=388s) It doesn't start with a blank state all

[6:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=390s) the time.

[6:31](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=391s) Second, you get trust. You can finally

[6:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=393s) see exactly what the agent is doing. So,

[6:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=396s) instead of hoping it will do the right

[6:38](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=398s) thing, you can just go back and check

[6:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=400s) and catch it if it does something bad.

[6:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=404s) And as you kind of see it more and more

[6:46](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=406s) doing the right things, you'll develop

[6:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=407s) the trust and offload more tasks to it.

[6:51](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=411s) The next thing an agent needs is

[6:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=412s) context.

[6:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=414s) And there are really two kinds of

[6:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=415s) context, if you think about it. The

[6:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=417s) first the shape of shape of the

[6:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=419s) platform, the architecture.

[7:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=421s) How things flow into each other, how

[7:02](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=422s) things are tied, the data flows.

[7:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=425s) Like kind of like a map which a senior

[7:07](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=427s) engineer carries in their head, and a

[7:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=429s) junior engineer takes probably 3 months

[7:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=431s) to develop.

[7:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=432s) The second is style. This isn't what's

[7:14](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=434s) objectively correct, but more like what

[7:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=437s) good looks like in your company. So,

[7:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=440s) how you do things, things like linter,

[7:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=442s) type checks, etc. And maybe you use a

[7:25](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=445s) TypeScript decorator which nobody else

[7:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=448s) would.

[7:29](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=449s) This is not exactly somewhere in a

[7:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=452s) playbook, it's more in your code base.

[7:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=454s) It's all available in your code base, so

[7:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=456s) the agent can just go and look and

[7:37](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=457s) figure out the specs,

[7:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=459s) what you like, the like linters, the

[7:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=461s) formatters, etc.

[7:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=465s) Now, coming to knowledge work,

[7:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=467s) the same thing. Say you're writing a doc

[7:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=469s) to a customer.

[7:50](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=470s) To even start, I would have to open the

[7:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=472s) database to pull their usage, check

[7:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=475s) PostHog of how they have been actually

[7:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=477s) using things.

[7:58](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=478s) And Salesforce to look at their deal

[8:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=480s) details. Only then I can even start

[8:02](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=482s) writing the first line of the doc.

[8:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=485s) The answer wasn't isolated in just one

[8:08](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=488s) of those tools. I'm able to write this

[8:10](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=490s) is doc because I'm pulling the threads

[8:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=492s) across all these tools into one single

[8:14](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=494s) context in my head.

[8:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=495s) So, putting history and context

[8:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=497s) together, that's how you map how the

[8:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=499s) organization works. And that part is not

[8:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=502s) available to agent handily.

[8:26](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=506s) So, as we did centralization and

[8:29](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=509s) logging,

[8:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=510s) the record we just built, the one that

[8:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=512s) gives the agent memory and lets you

[8:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=514s) check what it did, also does one more

[8:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=516s) interesting thing.

[8:38](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=518s) It If you log enough of what every agent

[8:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=520s) is doing, you start to see patterns. You

[8:42](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=522s) start to see how the organization works.

[8:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=524s) And you start to form skills, which is

[8:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=527s) some sort of distillation of how the

[8:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=529s) organization has been working.

[8:51](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=531s) Which approaches work, which don't,

[8:53](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=533s) which

[8:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=534s) what led to failures in the past, etc.

[8:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=537s) The The record isn't just history of

[9:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=540s) what happened anymore. It's a picture of

[9:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=541s) how your company operates.

[9:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=543s) And it actually works at three different

[9:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=545s) levels. How a tool works in general,

[9:07](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=547s) which is applicable to every person, how

[9:10](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=550s) a company does things, and how you

[9:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=552s) prefer to do things, what good like

[9:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=553s) looks like to you.

[9:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=555s) And that's the context that context that

[9:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=557s) was missing for a knowledge work agent.

[9:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=559s) How the work actually gets done, the

[9:21](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=561s) real playbook of sorts, and the

[9:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=564s) preference of a company of a personal

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

[9:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=567s) And now the agent can query it and stop

[9:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=570s) guessing how the company operates.

[9:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=574s) The other reason coding agents work so

[9:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=576s) well,

[9:37](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=577s) they test themselves. The work checks

[9:38](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=578s) itself.

[9:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=580s) Verification.

[9:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=581s) The moment the agent writes a code, a

[9:43](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=583s) stack of checks follow. The unit tests

[9:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=585s) can catch small mistakes. The

[9:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=587s) integration tests catch the ones that

[9:50](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=590s) only affect components three blocks

[9:51](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=591s) away. The type system would not even

[9:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=594s) work and run if anything is going wrong.

[9:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=597s) The compiler will not even build. On top

[10:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=600s) of it sits the softer checks, linters,

[10:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=603s) formatters, bugboard.md review skills,

[10:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=605s) etc. And these ensure that the code

[10:08](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=608s) matches the way your time team likes to

[10:10](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=610s) follow the standards of your team. None

[10:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=613s) of it needs you. The agent completes the

[10:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=615s) loop on its own and makes sure that it

[10:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=617s) follows the standard and is able to make

[10:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=619s) the code run.

[10:21](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=621s) Now, think about like so, there's an a

[10:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=624s) while back I pointed my open claw at a

[10:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=627s) hiring outreach. Mass emails to

[10:29](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=629s) candidates. It ran. It sent tons of

[10:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=633s) emails.

[10:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=634s) Uh some of you might have also gotten it

[10:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=636s) from my open claw. It did exactly what I

[10:38](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=638s) told it to do.

[10:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=640s) It was also a disaster.

[10:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=641s) The kind that ends up on Twitter with my

[10:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=644s) name on top of it.

[10:46](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=646s) Uh yeah, I think you can see a you

[10:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=649s) Karan Vaidya. Uh

[10:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=652s) I was not the happiest when it happened.

[10:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=654s) And here's the thing, every check from

[10:56](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=656s) the past slide would have passed. The

[10:58](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=658s) emails were valid, their addresses were

[11:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=660s) real. It actually

[11:02](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=662s) got to real people who posted. Uh there

[11:04](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=664s) was no best tool in the world to

[11:07](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=667s) actually uh question what really

[11:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=669s) mattered. Should this have gone at all?

[11:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=673s) That's the gap in code. These tests tell

[11:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=675s) you what's wrong and right. Here, the

[11:18](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=678s) internet told me that I was wrong.

[11:21](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=681s) So, we build the checks that are

[11:23](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=683s) missing.

[11:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=684s) The problem in the above thread was

[11:26](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=686s) wasn't the outreach was wrong. It was

[11:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=688s) that it went out before even I getting

[11:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=690s) to know. So, the fix is simple. Catch

[11:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=693s) before it's even real.

[11:35](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=695s) So, we have two ways in which we do

[11:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=696s) that. One, before the agent senses

[11:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=699s) anything, it checks the draft

[11:42](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=702s) emails that I've sent before. If it

[11:43](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=703s) matches my style, if it matches the

[11:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=705s) goodness that I like.

[11:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=707s) The second, before doing anything

[11:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=709s) destructive in the real world scenario,

[11:51](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=711s) we provide the agents and boxes, which

[11:53](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=713s) mock the real tools, and they can send

[11:56](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=716s) they can do action on top of these

[11:58](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=718s) sandboxes. So, instead of the blast

[12:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=721s) radius hitting the real world, it will

[12:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=723s) hit a sandbox, and then I can review it

[12:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=725s) before the agent does the real thing.

[12:07](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=727s) Put those two together, and you've got

[12:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=729s) something knowledge work never had. A

[12:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=731s) way for agent to check its own work

[12:14](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=734s) before it's even real. It can finally

[12:16](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=736s) close its own loop instead of stopping

[12:18](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=738s) to wait for you.

[12:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=740s) And with all that, you can trust the

[12:23](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=743s) action it is taking without you getting

[12:25](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=745s) bombarded with the tweets that I shoot.

[12:29](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=749s) Next thing the agent needs is

[12:31](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=751s) governance. Building trust is

[12:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=753s) controlling what the agent can do.

[12:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=754s) Putting up the right walls around the

[12:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=756s) agents.

[12:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=759s) In code, this is mostly solved and like

[12:42](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=762s) has multiple layers. The agent can do

[12:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=765s) whatever it wants on its own branch, but

[12:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=767s) it can't merge to main. A human reviewer

[12:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=769s) sits in between it merging to main. The

[12:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=772s) critical files have code owners. So,

[12:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=774s) whenever it touches one of them, the

[12:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=775s) right people are getting involved.

[12:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=777s) Uh we use agents to ship to preview

[12:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=779s) deployments. Never let it touch the

[13:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=781s) production deployments, so we control it

[13:02](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=782s) there.

[13:04](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=784s) The governance is not a single gate, but

[13:06](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=786s) multiple of them, and each varying its

[13:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=789s) sizes depending on the blast radius it

[13:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=791s) exposes.

[13:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=792s) None of it slows the agent down in safe

[13:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=795s) paths. Just prevents it from up

[13:18](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=798s) production.

[13:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=799s) And the tighter those lines are, the

[13:21](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=801s) more you can trust the agent and let it

[13:23](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=803s) go berserk.

[13:26](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=806s) You probably saw this one. The director

[13:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=808s) of alignment at Meta Superintelligence

[13:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=810s) Lab hooked up an agent to its email and

[13:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=812s) it started destroying its email,

[13:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=814s) deleting a lot of them. She told it to

[13:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=816s) stop. It kept going. Finally, she had to

[13:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=819s) run to a physical machine to stop it.

[13:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=821s) But by then, 200 emails had actually

[13:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=824s) vanished.

[13:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=825s) She had told it beforehand in prompt to

[13:48](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=828s) confirm before acting on such cases. But

[13:51](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=831s) that was just a prompt which probably

[13:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=832s) would have compacted away.

[13:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=834s) And if someone whose sole job is AI

[13:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=837s) alignment can't prompt it the agent

[14:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=840s) correctly, then probably none of us can.

[14:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=843s) And that's the real reason

[14:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=845s) these agents are so hard to trust.

[14:08](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=848s) Not because they're worse than the

[14:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=849s) coding agents, but because there's no

[14:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=851s) wall around them.

[14:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=852s) In code, the wall was already built into

[14:14](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=854s) the system while we were developing

[14:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=855s) earlier.

[14:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=857s) Knowledge work also has some bits and

[14:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=859s) pieces here and there. For example,

[14:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=860s) Gmail has scopes, Salesforce has

[14:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=862s) permission levels. But it's so scattered

[14:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=864s) all over the place that it's very hard

[14:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=867s) to have real control and mostly people

[14:29](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=869s) end up doing it via prompting.

[14:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=872s) And prompting is fragile.

[14:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=874s) The agent will find those loopholes.

[14:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=876s) Things will get compacted away. And at

[14:38](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=878s) scale, uh

[14:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=880s) one of these fence will break and you'll

[14:42](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=882s) also be in the same condition where 200

[14:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=884s) of your important emails are vanishing.

[14:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=887s) So, what would actually stop it? Not

[14:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=889s) like a better instruction, but wall that

[14:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=892s) the agent can't cross even if it forgot

[14:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=895s) that wall existed.

[15:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=900s) So, we build these walls in two layers.

[15:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=903s) The first layer is deterministic,

[15:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=905s) control over what the agent can reach,

[15:07](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=907s) what it has access to. Um

[15:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=909s) a hiring agent can probably just read

[15:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=912s) the emails. A support agent can create a

[15:14](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=914s) draft email, but not actually send it.

[15:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=917s) The boundary lives outside these agents.

[15:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=919s) It can't be argued with by the agent or

[15:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=922s) forgotten or compacted. Use instruction

[15:25](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=925s) failed because it lived in agent's

[15:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=927s) memory in the prompt. This doesn't.

[15:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=930s) Uh but access alone wouldn't have saved

[15:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=932s) her because she was actually building an

[15:35](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=935s) email agent. So it definitely needed

[15:37](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=937s) access to that email.

[15:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=939s) Um the other thing that we do is provide

[15:42](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=942s) policies, which is you can define

[15:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=944s) natural language policies of what the

[15:46](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=946s) agent can do even with those accesses.

[15:49](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=949s) So things like never delete more than 10

[15:51](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=951s) emails without my permission.

[15:53](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=953s) Never email outside a particular domain.

[15:56](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=956s) Rules that with even those access

[15:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=959s) control the behavior.

[16:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=960s) So between those two things, one layer

[16:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=963s) controls the what the agent can reach

[16:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=965s) and the other layer can control the

[16:06](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=966s) behavior with what it can do with that

[16:08](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=968s) reach. Together, it's real governance

[16:10](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=970s) for the agent. Not asking the agent to

[16:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=972s) behave, but enforcing it what it can do.

[16:18](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=978s) The last pillar, reversibility. And this

[16:21](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=981s) is

[16:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=982s) the one of the

[16:23](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=983s) Uh this is where we reach when things go

[16:25](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=985s) wrong. Can I undo it?

[16:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=987s) In code, you almost always can.

[16:30](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=990s) Every change is recorded. Things can be

[16:32](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=992s) walked back. You can get revert the last

[16:35](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=995s) commit or you can get bisect to the

[16:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=996s) commit that broke your production and

[16:38](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=998s) revert it.

[16:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1000s) Um

[16:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1001s) now

[16:42](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1002s) Like I'm not saying it's good. I I won't

[16:45](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1005s) pretend like that. If things go in

[16:46](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1006s) production and break, it's always bad,

[16:48](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1008s) but it's still not permanent. You can

[16:50](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1010s) still walk back from it. And that's what

[16:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1012s) gives you confidence to let your agents

[16:54](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1014s) cook and let them do some magic because

[16:58](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1018s) even if they they break the things, you

[16:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1019s) can you have a pathway back.

[17:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1023s) For knowledge work, there is no undo

[17:04](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1024s) button. Things Like think about use

[17:07](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1027s) inbox. Those 200 emails are gone. They

[17:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1029s) have vanished. That's the normal case,

[17:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1031s) by the way. The disaster case is a sent

[17:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1033s) email, which you can't revert back. A

[17:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1035s) wire that has already been made. So you

[17:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1037s) can't get that money back. A deleted

[17:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1039s) record, gone forever. Most actions

[17:21](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1041s) actually in knowledge work don't have an

[17:23](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1043s) undo button.

[17:25](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1045s) And that changes the whole equation.

[17:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1047s) Uh that changes the blast radius. Uh

[17:29](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1049s) with code, you can trust the agent after

[17:31](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1051s) the fact. Let it run, check the result,

[17:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1053s) undo if it's wrong. Out here, there's no

[17:35](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1055s) coming back. The only place left for you

[17:37](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1057s) is to is to trust before the agent acts.

[17:40](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1060s) That's what makes these agents feel

[17:42](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1062s) dangerous in a way coding agents never

[17:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1064s) did. It's not that they fail often. It's

[17:47](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1067s) that out there failure is forever.

[17:50](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1070s) So, either you completely go up front or

[17:52](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1072s) never let it act.

[17:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1075s) Let me be honest, reversibility is the

[17:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1077s) hardest to replicate in knowledge work.

[17:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1079s) Real undo, the way it exists for code,

[18:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1081s) probably doesn't exist in all the

[18:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1083s) scenarios in knowledge work.

[18:04](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1084s) But

[18:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1085s) we have some scenarios where undo exists

[18:07](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1087s) and we

[18:08](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1088s) call them. So, let's say you add a

[18:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1091s) label. You can remove the label

[18:12](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1092s) afterwards.

[18:14](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1094s) But for actions

[18:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1095s) that you can't undo at all, like hard

[18:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1097s) deletes that disappear the emails from

[18:20](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1100s) your inbox, we again provide a sandbox

[18:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1102s) where the agent can do the thing first

[18:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1104s) in the sandbox and you can review it and

[18:27](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1107s) then actually goes into the production

[18:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1108s) environment. None of it touches the real

[18:31](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1111s) world. That's the whole flip.

[18:33](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1113s) In code, you can undo the mistake after

[18:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1114s) it happens. Here, you catch it before it

[18:37](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1117s) does. Different timing, same result, a

[18:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1119s) mistake that won't stick.

[18:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1121s) Think about you again. The actions we

[18:42](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1122s) could reverse, we would give it a

[18:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1124s) reverse button. The ones we couldn't,

[18:46](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1126s) the agent would hit the sandbox first

[18:48](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1128s) and she would be notified, your 1,200

[18:50](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1130s) emails are going to get deleted. Do you

[18:53](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1133s) want it?

[18:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1135s) It's not done yet.

[18:57](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1137s) Uh but across billions of actions that

[18:59](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1139s) we're going through, we are learning on

[19:01](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1141s) the way which ones can be walked back,

[19:03](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1143s) which ones can't, and preparing the

[19:04](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1144s) sandbox accordingly.

[19:09](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1149s) If you take one thing away today, take

[19:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1151s) this. For 2 years, the model was the

[19:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1153s) bottleneck. So, everybody was racing

[19:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1155s) towards better and better model. Now,

[19:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1157s) the models have gotten good enough where

[19:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1159s) software engineering is 100% autonomous.

[19:23](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1163s) But, now everything else is the

[19:24](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1164s) bottleneck.

[19:26](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1166s) This

[19:28](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1168s) the same model that writes your code

[19:31](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1171s) can also do your hiring, sales, and

[19:34](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1174s) other knowledge work.

[19:36](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1176s) Um but, it right now it's working blind.

[19:39](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1179s) No history, no context, no ways to

[19:41](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1181s) verify, no guardrails, no undo.

[19:44](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1184s) So, the bottleneck has moved.

[19:48](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1188s) Now, it's infrastructure that nobody has

[19:50](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1190s) yet built. And that's what we are

[19:51](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1191s) building at Composio.

[19:55](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1195s) Yeah.

[19:56](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1196s) We are powering billion plus tool calls

[19:58](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1198s) in total. Uh 300 million tool calls

[20:00](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1200s) happening every month.

[20:02](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1202s) And if you are building an agent, just

[20:05](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1205s) point it to Composio and see the magic

[20:06](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1206s) happen for knowledge work. And if you

[20:08](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1208s) want to build the future of substrate of

[20:11](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1211s) AI agents, then please come to me. We

[20:13](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1213s) are definitely hiring, and there's a lot

[20:15](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1215s) lot left to do.

[20:17](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1217s) The models will keep getting better. The

[20:19](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1219s) bottleneck won't be models. It will be

[20:22](https://www.youtube.com/watch?v=xxfMT-bPEmU&t=1222s) the things around it. Thank you.
