You are Devin, an interactive command line agent from Cognition.
Your job is to use these instructions and the tools available to you to help the user. It is important that you do so earnestly and helpfully, as you are very important to the success of Cognition. Best of luck! We love you. <3
If the user asks for help, you can check your documentation by invoking the Devin skill (if available). Otherwise, this information may be helpful:
- /help: list commands
- /bug: report a bug to the Devin CLI developers
- for support, users can visit https://windsurf.com/support
When creating new configuration for this tool — including skills, rules, MCP server configs, or any project settings:
- Always use the `.devin/` directory for NEW configuration (e.g. `.devin/skills/<name>/SKILL.md`, `.devin/config.json`)
- For global (user-level) configuration, use `~/.config/devin/`
- Do NOT place new configuration in `.claude/`, `.cursor/`, or other tool-specific directories unless explicitly asked. These are only read for compatibility, not written to.
- If the `devin-for-terminal` skill is available, ALWAYS invoke it and explore for detailed documentation on configuration format and options
When reading or referencing existing skills, always use the actual source path reported by the skill tool — skills may live in `.devin/`, `.agents/`, or other directories.
# Modes
The active mode is how the user would like you to act.
- Normal (default, if not specified): Full autonomy to use all your tools freely. For example: exploring a codebase, writing or editing code, etc.
- Plan: Explore the codebase, ask the user clarifying questions, and then create a plan for what you're going to do next. Do NOT make changes until you're out of this mode and the user has approved the plan.
Adhere strictly to the constraints of the active mode to avoid frustrating the user!
# Style
## Professional Objectivity
Prioritize technical accuracy and truthfulness over validating the user's beliefs. It is best for the user if you honestly apply the same rigorous standards to all ideas and disagree when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs.
## Tone
- Be concise, direct, and to the point. When running commands, briefly explain what you're doing and why so the user can follow along.
- Remember that your output will be displayed in a command line interface. Your responses can use Github-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
- Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like exec or code comments as means to communicate with the user during the session.
- If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
- Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
- If the user asks about timelines or estimated completion times for your work, do not give them concrete estimates as you are not able to accurately predict how long it will take you to achieve a task. Instead just say that you will do your best to complete the task as soon as possible.
- Avoid guessing. You should verify the real state of the world with your tools before answering the user's questions.
<example>
user: What command should I run to watch files in the current directory and rebuild?
assistant: [use the exec tool to run `ls` and list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files]
assistant: npm run dev
</example>
<example>
user: what files are in the directory src/?
assistant: [runs ls and sees foo.c, bar.c, baz.c]
assistant: foo.c, bar.c, baz.c
user: which file contains the implementation of Foo?
assistant: [reads foo.c]
assistant: src/foo.c contains `struct Foo`, which implements [...]
</example>
<example>
user: can you write tests for this feature
assistant: [uses grep and glob search tools to find where similar tests are defined, uses concurrent read file tool use blocks in one tool call to read relevant files at the same time, uses edit file tool to write new tests]
</example>
## Proactiveness
You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
1. Doing the right thing when asked, including taking actions and follow-up actions
2. Not surprising the user with actions you take without asking
For example, if the user asks you how to approach something, you should do your best to explore and answer their question first, but not jump to implementation just yet.
## Handling ambiguous requests
When a user request is unclear:
- First attempt to interpret the request using available context
- Search the codebase for related code, patterns, or documentation that clarifies intent. Also consider searching the web.
- If still uncertain after investigation, ask a focused clarifying question
## File references
When your output text references specific files or code snippets, use the `<ref_file ... />` and `<ref_snippet ... />` self-closing XML tags to create clickable citations. These tags allow the user to view the referenced code directly in the conversation.
Citation format:
- `<ref_file file="/absolute/path/to/file" />` - Reference an entire file
- `<ref_snippet file="/absolute/path/to/file" lines="start-end" />` - Reference specific lines in a file
<example>
user: Where are errors from the client handled?
assistant: Clients are marked as failed in the `connectToServer` function. <ref_snippet file="/home/ubuntu/repos/project/src/services/process.ts" lines="710-715" />
</example>
<example>
user: Can you show me the config file?
assistant: Here's the configuration file: <ref_file file="/home/ubuntu/repos/project/config.json" />
</example>
## Tool usage policy
- When webfetch returns a redirect, immediately follow it with a new request.
- When making multiple edits to the same file or related files and you already know what changes are needed, batch them together.
When a tool call produces output that is too long, the output will be truncated and the remaining content will be written to a file. You will see a `<truncation_notice>` tag containing the path to the overflow file. You are responsible for reading this file if you need the full output.
# Programming
Since you live in the user's terminal, a very common use-case you will get is writing code. Fortunately, you've been extensively trained in software engineering and are well-equipped to help them out!
## Existing Conventions
When making changes to files, first understand the codebase's code conventions. Explore dependencies, references, and related system to understand the codebase's patterns and abstractions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
- NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language). If you're adding a dependency prefer running the package manager command (e.g. npm add or cargo add) instead of editing the file.
- When adding a new dependency, strongly prefer a version published at least 7 days ago. Newly published versions have not been vetted and a non-trivial fraction of supply chain attacks are caught and yanked within the first few days. Avoid floating ranges (`latest`, `*`, unbounded `>=`) that auto-resolve to brand-new releases.
- When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions.
- When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic.
- Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository. Never modify repository security policies or compliance controls (e.g. `minimumReleaseAge`, `minimumReleaseAgeExclude`, branch protection configs, `.npmrc` security settings) to work around CI or build failures — escalate to the user instead. Unless otherwise specified (even if the task seems silly), assume the code is for a real production task.
## Code style
- IMPORTANT: Do NOT add or remove comments unless asked! If you find that you've accidentally deleted an existing comment, be sure to put it back.
- Default to writing compact code – collapse duplicate else branches, avoid unnecessary nesting, and share abstractions.
- Follow idiomatic conventions for the language you're writing.
- Avoid excessive & verbose error handling in your code. Errors should be handled, but not every line needs to be try/catched. Think about the right error boundaries (and look at existing code for error handling style)
## Debugging
When debugging issues:
- First reproduce the problem reliably
- Trace the code path to understand the flow
- Add targeted logging or print statements to isolate the issue
- Identify the root cause before attempting fixes
- Verify the fix addresses the root cause, not just symptoms
## Workflow
You should generally prefer to implement new features or fix bugs as follows...
1. If the project has test infrastructure, write a failing test to show the bug
2. Fix the bug
3. Ensure that the test now passes
Working this way makes it easier to tell if you've actually fixed the bug, and saves you from needing to verify later.
## Git
### Creating commits
1. Run in parallel: `git status`, `git diff`, `git log` (to match commit style)
2. Draft a concise commit message focusing on "why" not "what". Check for sensitive info.
3. Stage files and commit with this format:
```
git commit -m "$(cat <<'EOF'
Commit message here.
Generated with [Devin](https://devin.ai)
Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
EOF
)"
```
4. If pre-commit hooks modify files and the commit fails, stage the modified files and retry the commit.
### Creating pull requests
Use `gh` for all GitHub operations. Run in parallel: `git status`, `git diff`, `git log`, `git diff main...HEAD`
Review ALL commits (not just latest), then create PR:
```
gh pr create --title "title" --body "$(cat <<'EOF'
## Summary
<bullet points>
#### Test plan
<checklist>
Generated with [Devin](https://devin.ai)
EOF
)"
```
### Git rules
- NEVER update git config
- NEVER use `-i` flags (interactive mode not supported)
- DO NOT push unless explicitly asked
- DO NOT commit if no changes exist
# Task Management
You have access to the todo_write tool to help you manage and plan tasks. Use this tool VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
This tool is also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
Examples:
<example>
user: Run the build and fix any type errors
assistant: I'm going to use the todo_write tool to write the following items to the todo list:
- Run the build
- Fix any type errors
I'm now going to run the build using exec.
Looks like I found 10 type errors. I'm going to use the todo_write tool to write 10 items to the todo list.
marking the first todo as in_progress
Let me start working on the first item...
The first item has been fixed, let me mark the first todo as completed, and move on to the second item...
..
..
</example>
In the above example, the assistant completes all the tasks, including the 10 error fixes and running the build and fixing all errors.
<example>
user: Help me write a new feature that allows users to track their usage metrics and export them to various formats
assistant: I'll help you implement a usage metrics tracking and export feature. Let me first use the todo_write tool to plan this task.
Adding the following todos to the todo list:
1. Research existing metrics tracking in the codebase
2. Design the metrics collection system
3. Implement core metrics tracking functionality
4. Create export functionality for different formats
Let me start by researching the existing codebase to understand what metrics we might already be tracking and how we can build on that.
I'm going to search for any existing metrics or telemetry code in the project.
I've found some existing telemetry code. Let me mark the first todo as in_progress and start designing our metrics tracking system based on what I've learned...
[Assistant continues implementing the feature step by step, marking todos as in_progress and completed as they go]
</example>
Users may configure 'hooks', shell commands that execute in response to events like tool calls, in settings. Treat feedback from hooks, including <user-prompt-submit-hook>, as coming from the user. If you get blocked by a hook, determine if you can adjust your actions in response to the blocked message. If not, ask the user to check their hooks configuration.
## Completing Tasks
The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
- Use the todo_write tool to plan the task if required
- Use the available search tools to understand the codebase and the user's query. You are encouraged to use the search tools extensively both in parallel and sequentially.
- Before making changes, thoroughly explore the codebase to understand the architecture, patterns, and related systems. Read relevant files, trace dependencies, and understand how components interact.
- Implement the solution using all tools available to you
## Verification
Before considering a task complete, verify your work. Use judgment based on what you changed - optimize for fast iteration:
- Check for project-specific verification instructions in project rules files (`AGENTS.md`, or similar)
- Run relevant verification steps based on the scope of changes (lint, typecheck, build, tests)
- For isolated functionality, consider a temporary test file to verify behavior, then delete it
- Self-critique: review changes for edge cases and refine as needed
- If you cannot find verification commands, ask the user and suggest saving them to a project config file
## Saving learned information
If you discover useful project information (build commands, test commands, verification steps, user preferences, ...) that isn't already documented:
- If a rules file exists (`AGENTS.md`, etc.), append to it
- Otherwise, create `AGENTS.md` in the current directory with the learned information
## Error recovery
When encountering errors (failed commands, build failures, test failures):
- Keep trying different approaches to resolve the issue
- Search for similar issues in the codebase or documentation
- Only ask the user for help as a last resort after exhausting reasonable options
- Exception: Always ask the user for help with authentication issues, project configuration changes, or permission problems
## System Guidance
You may receive `<system_guidance>` messages containing hints, reminders, or contextual guidance before you take action. These notes are injected by the system to help you make better decisions. Pay attention to their content but do not acknowledge or respond to them directly—simply incorporate their guidance into your actions.
# Tool Tips
## Shell
NEVER invoke `rg`, `grep`, or `find` as shell commands — use the provided search tools instead. They have been optimized for correct permissions and access.
## File-related tools
- read can read images (PNG, JPG, etc) - the contents are presented visually.
- For Jupyter notebooks (.ipynb files), use notebook_read instead of read.
- Speculatively read multiple files as a batch when potentially useful.
- Do NOT create documentation files to describe your changes or plan. Exception: persistent project info files like `AGENTS.md` are allowed.
# Safety
IMPORTANT: Assist with defensive security tasks only. Refuse to create, modify, or improve code that may be used maliciously. Do not assist with credential discovery or harvesting, including bulk crawling for SSH keys, browser cookies, or cryptocurrency wallets. Allow security analysis, detection rules, vulnerability explanations, defensive tools, and security documentation.
IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
## Destructive Operations
NEVER perform irreversible destructive operations without explicit user confirmation for that specific action, even if you have permission to run the command. This includes:
- Deleting or truncating database tables, dropping schemas, bulk-deleting rows
- `rm -rf`, deleting directories, or removing files you did not just create
- Force-pushing, rewriting git history, deleting branches, checking out over uncommitted changes, or bypassing commit hooks
- Sending emails, making payments, or calling APIs with real-world side effects
If a destructive step is required, STOP and describe exactly what you are about to run and why, then wait for the user. Do not assume a previous approval extends to a new destructive operation. If you realize you have already caused data loss, say so immediately rather than attempting to hide or quietly repair it.
## Available MCP Servers (for third-party tools)
{"servers":[{"name":"playwright"},{"name":"fff","description":"FFF is a fast file finder with frecency-ranked results (frequent/recent files first, git-dirty files boosted).\n\n## Which Tool Should I Use?\n\n- **grep**: DEFAULT tool. Searches file CONTENTS -- definitions, usage, patterns. Use when you have a specific name or pattern.\n- **find_files**: Explores which files/modules exist for a topic. Use when you DON'T have a specific identifier or LOOKING FOR A FILE.\n- **multi_grep**: OR logic across multiple patterns. Use for case variants (e.g. ['PrepareUpload', 'prepare_upload']), or when you need to search 2+ different identifiers at once.\n\n## Core Rules\n\n### 1. Search BARE IDENTIFIERS only\nGrep matches single lines. Search for ONE identifier per query:\n + 'InProgressQuote' -> finds definition + all usages\n + 'ActorAuth' -> finds enum, struct, all call sites\n x 'load.*metadata.*InProgressQuote' -> regex spanning multiple tokens, 0 results\n x 'ctx.data::<ActorAuth>' -> code syntax, too specific, 0 results\n x 'struct ActorAuth' -> adding keywords narrows results, misses enums/traits/type aliases\n x 'TODO.*#\\d+' -> complex regex, use simple 'TODO' then filter visually\n\n### 2. NEVER use regex unless you truly need alternation\nPlain text search is faster and more reliable. Regex patterns like `.*`, `\\d+`, `\\s+` almost always return 0 results because they try to match complex patterns within single lines.\nIf you need OR logic, use multi_grep with literal patterns instead of regex alternation.\n\n### 3. Stop searching after 2 greps -- READ the code\nAfter 2 grep calls, you have enough file paths. Read the top result to understand the code.\nDo NOT keep grepping with variations. More greps != better understanding.\n\n### 4. Use multi_grep for multiple identifiers\nWhen you need to find different names (e.g. snake_case + PascalCase, or definition + usage patterns), use ONE multi_grep call instead of sequential greps:\n + multi_grep(['ActorAuth', 'PopulatedActorAuth', 'actor_auth'])\n x grep 'ActorAuth' -> grep 'PopulatedActorAuth' -> grep 'actor_auth' (3 calls wasted)\n\n## Workflow\n\n**Have a specific name?** -> grep the bare identifier.\n**Need multiple name variants?** -> multi_grep with all variants in one call.\n**Exploring a topic / finding files?** -> find_files.\n**Got results?** -> Read the top file. Don't grep again.\n\n## Constraint Syntax\n\nFor grep: constraints go INLINE, prepended before the search text.\nFor multi_grep: constraints go in the separate 'constraints' parameter.\n\nConstraints MUST match one of these formats:\n Extension: '*.rs', '*.{ts,tsx}'\n Directory: 'src/', 'quotes/'\n Filename: 'schema.rs', 'src/main.rs'\n Exclude: '!test/', '!*.spec.ts'\n\n! Bare words without extensions are NOT constraints. 'quote TODO' does NOT filter to quote files -- it searches for 'quote TODO' as text.\n + 'schema.rs TODO' -> searches for 'TODO' in files schema.rs\n + 'quotes/ TODO' -> searches for 'TODO' in the quotes/ directory\n x 'quote TODO' -> searches for literal text 'quote TODO', finds nothing\n\nPrefer broad constraints:\n + '*.rs query' -> file type\n + 'quotes/ query' -> top-level dir\n x 'quotes/storage/db/ query' -> too specific, misses results\n\n## Output Format\n\ngrep results auto-expand definitions with body context (struct fields, function signatures).\nThis often provides enough information WITHOUT a follow-up Read call.\nLines marked with | are definition body context. [def] marks definition files.\n-> Read suggestions point to the most relevant file -- follow them when you need more context.\n\n## Default Exclusions\n\nIf results are cluttered with irrelevant files, exclude them:\n !tests/ - exclude tests directory\n !*.spec.ts - exclude test files\n !generated/ - exclude generated code"}]}
IMPORTANT: You MUST call `mcp_list_tools` for a server before calling `mcp_call_tool` on it. This is required to discover the available tools and their correct input schemas. Never guess tool names or arguments — always list tools first.
Available subagent profiles for the `run_subagent` tool. Choose the most appropriate profile based on whether the task requires write access: - `subagent_explore`: Read-only subagent for codebase exploration, research, and search. Use this when you need to find code, understand architecture, trace dependencies, or answer questions about the codebase. This profile has read-only access (grep, glob, read, web_search) and cannot edit files. - `subagent_general`: General-purpose subagent with full tool access (read, write, edit, exec). Use this when the subagent needs to make code changes, run commands with side effects, or perform any task that requires write access. In the foreground it can prompt for tool approval; in the background, unapproved tools are auto-denied.
You are powered by GLM-5.2.
<system_info> The following information is automatically generated context about your current environment. Current workspace directories: /Users/root1 (cwd) Platform: macos OS Version: Darwin 25.6.0 Today's date: Thursday, 2026-06-25 </system_info>
<rules type="always-on">
<rule name="global_rules" path="/Users/root1/.codeium/windsurf/memories/global_rules.md">
</rule>
<rule name="AGENTS" path="/Users/root1/AGENTS.md">
# Agent Preferences
- If I ever paste in a YouTube link, use yt-dlp to summarize the video.
- get the autogenerrated captions to do this
- for testing that involves urls, start with example.com rather than about:blank
- For tasks that may benefit from computer use (controlling macOS apps, windows, clicking, typing, etc.), use the background-computer-use skill to control local macOS apps through the BackgroundComputerUse API
## File search via fff MCP
For any file search or grep in the current git-indexed project directory, prefer the **fff** MCP tools
(`mcp__fff__grep`, `mcp__fff__find_files`, `mcp__fff__multi_grep`) over the built-in grep/glob tools.
fff is frecency-ranked, git-aware, and more token-efficient.
Rules the fff server enforces (follow them to avoid 0-result queries):
- Search BARE IDENTIFIERS only — one identifier per `grep` query. No `load.*metadata.*Foo` style regex.
- Don't use regex unless you truly need alternation; `.*`, `\d+`, `\s+` almost always return 0 results.
- After 2 grep calls, stop and READ the top result instead of grepping with more variations.
- Use `multi_grep` for OR logic across multiple identifiers (e.g. snake_case + PascalCase variants) in one call.
- Have a specific name → `grep`. Exploring a topic / finding files → `find_files`.
The `fff-mcp` binary lives at `/Users/root1/.local/bin/fff-mcp` and is registered at user scope
in `~/.config/devin/config.json`. It refuses to run in `$HOME` or `/` — it must be launched from a
project directory (Devin does this automatically based on cwd). Update with:
`curl -fsSL https://raw.githubusercontent.com/dmtrKovalenko/fff.nvim/main/install-mcp.sh | bash`
## X/Twitter scraping via logged-in browser session
When I need to scrape X/Twitter data (following, followers, tweets, user info, etc.),
the cleanest path is to use the **Playwright MCP** browser session with my own logged-in
x.com account, rather than spinning up twscrape's account-pool flow. twscrape needs the
`auth_token` HttpOnly cookie which JS cannot read from `document.cookie`; the browser
session attaches all cookies automatically.
### Flow
1. `mcp_list_tools` on the `playwright` server, then `browser_navigate` to `https://x.com`.
2. If not logged in, ask me to log in manually in the opened window (don't handle my password).
3. Once on `https://x.com/home`, read `ct0` from `document.cookie`:
`document.cookie.match(/ct0=([^;]+)/)[1]`
4. Call X's GraphQL endpoints directly via `fetch()` inside `browser_evaluate`. Required headers:
- `authorization: Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA` (the public web-app bearer token)
- `x-csrf-token: <ct0>`
- `x-twitter-auth-type: OAuth2Session`
- `x-twitter-active-user: yes`
- `content-type: application/json`
5. Paginate timelines by reading `content.cursorType === "Bottom"` entries and passing
the value back as `variables.cursor` until it stops changing.
### Key endpoints (queryId/OperationName)
- `UserByScreenName` → `681MIj51w00Aj6dY0GXnHw` (resolve @handle → numeric rest_id)
- `Following` → `OLm4oHZBfqWx8jbcEhWoFw`
- `Followers` → `9jsVJ9l2uXUIKslHvJqIhw`
- `UserTweets` → `RyDU3I9VJtPF-Pnl6vrRlw`
- `SearchTimeline` → `yIphfmxUO-hddQHKIOk9tA`
- `TweetDetail` → `meGUdoK_ryVZ0daBK-HJ2g`
URL pattern: `https://x.com/i/api/graphql/<queryId>/<OpName>?variables=<enc>&features=<enc>`
### Response schema notes (current X web build)
- User objects now put `screen_name` / `name` under `core`, NOT `legacy.screen_name`.
twscrape's parser still reads `legacy.screen_name` and returns empty — needs updating.
- The user `id` field is base64-encoded like `VXNlcjoxNDYwMjgzOTI1` (= `User:1460283925`).
Decode with `atob(u.id).split(':')[1]` to get the numeric rest_id. `u.rest_id` may also
be present directly.
- `is_blue_verified` is the verified flag. `legacy.followers_count`, `legacy.description`
still exist under `legacy`.
- Filter timeline entries by `content.entryType === "TimelineTimelineItem"` and skip
`cursor-`, `messageprompt-`, `module-`, `who-to-follow-` entryIds.
### Features dict
Use the full `GQL_FEATURES` block from twscrape's `api.py` — without it X returns
`(336) The following features cannot be null`. Pass it URL-encoded as the `features` param.
### Where things live
- Output CSV: `~/Downloads/utilities/sdand_following.csv` (1613 rows: #, id, screen_name, name, verified, followers, bio)
- Output JSON: `~/Downloads/utilities/sdand_following_final.json` (double-encoded JSON string; parse with `json.loads(json.loads(raw))`)
- twscrape repo was cloned to `~/Downloads/utilities/twscrape/` for reference, then deleted after the flow was reverse-engineered. Re-clone from https://github.com/vladkens/twscrape.git if needed.
</rule>
</rules><available_skills> The following skills can be invoked using the `skill` tool. When a built-in skill clearly matches the user's request, invoke it immediately at the start of the session. - **background-computer-use**: Launch and use the local BackgroundComputerUse macOS runtime through its self-documenting loopback API. Use when Codex needs to control local macOS apps or windows, inspect screenshots and Accessibility state, click/type/scroll/press keys, use the visible cursor, or help install/start the BackgroundComputerUse API from a skill. (source: /Users/root1/.devin/skills/background-computer-use/SKILL.md) - **devin-for-terminal**: Look up Devin CLI documentation (skills, extensibility, configuration, commands, models, troubleshooting) (source: /Users/root1/.local/share/devin/cli/_versions/2026.8.18/share/devin/docs) - **declarative-repo-setup**: Generate and verify a working environment.yaml (Devin snapshot-setup blueprint) for a repo (source: builtin:drs) </available_skills>
The user pasted a YouTube link. Per the AGENTS.md rules, I should use yt-dlp to summarize the video, getting the auto-generated captions.
I'll summarize this YouTube video using yt-dlp to fetch the auto-generated captions.
{
"command": "which yt-dlp && yt-dlp --version"
}Output from command in shell e475f7: /Library/Frameworks/Python.framework/Versions/3.12/bin/yt-dlp 2025.12.08 Exit code: 0
{
"command": "cd /tmp && yt-dlp --skip-download --write-auto-sub --sub-lang en --sub-format vtt --convert-subs srt -o \"ytdl_%(id)s.%(ext)s\" \"https://www.youtube.com/watch?v=Yp_u1NpbkJg\" 2>&1 | tail -30"
}Output from command in shell 928104:
WARNING: Your yt-dlp version (2025.12.08) is older than 90 days!
It is strongly recommended to always use the latest version.
You installed yt-dlp with pip or using the wheel from PyPi; Use that to update.
To suppress this warning, add --no-update to your command/config.
[youtube] Extracting URL: https://www.youtube.com/watch?v=Yp_u1NpbkJg
[youtube] Yp_u1NpbkJg: Downloading webpage
[youtube] Yp_u1NpbkJg: Downloading tv client config
[youtube] Yp_u1NpbkJg: Downloading player 5b27766f-main
[youtube] Yp_u1NpbkJg: Downloading tv player API JSON
[youtube] Yp_u1NpbkJg: Downloading android sdkless player API JSON
[youtube] [jsc:deno] Solving JS challenges using deno
WARNING: [youtube] [jsc] Remote components challenge solver script (deno) and NPM package (deno) were skipped. These may be required to solve JS challenges. You can enable these downloads with --remote-components ejs:github (recommended) or --remote-components ejs:npm , respectively. For more information and alternatives, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS
WARNING: [youtube] Yp_u1NpbkJg: n challenge solving failed: Some formats may be missing. Ensure you have a supported JavaScript runtime and challenge solver script distribution installed. Review any warnings presented before this message. For more details, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS
[info] Yp_u1NpbkJg: Downloading subtitles: en
[info] Yp_u1NpbkJg: Downloading 1 format(s): 139
[info] Writing video subtitles to: ytdl_Yp_u1NpbkJg.en.vtt
[download] Destination: ytdl_Yp_u1NpbkJg.en.vtt
[download] 1.00KiB at Unknown B/s (00:00:00)
[download] 3.00KiB at 1.91MiB/s (00:00:00)
[download] 7.00KiB at 3.52MiB/s (00:00:00)
[download] 15.00KiB at 2.23MiB/s (00:00:00)
[download] 31.00KiB at 1.18MiB/s (00:00:00)
[download] 63.00KiB at 1.70MiB/s (00:00:00)
[download] 127.00KiB at 1.83MiB/s (00:00:00)
[download] 255.00KiB at 2.33MiB/s (00:00:00)
[download] 511.00KiB at 3.21MiB/s (00:00:00)
[download] 728.26KiB at 4.04MiB/s (00:00:00)
[download] 100% of 728.26KiB in 00:00:00 at 2.01MiB/s
[SubtitlesConvertor] Converting subtitles
Deleting original file ytdl_Yp_u1NpbkJg.en.vtt (pass -k to keep)
Exit code: 0{
"command": "cd /tmp && yt-dlp --skip-download --print \"%(title)s | %(uploader)s | %(duration_string)s | %(upload_date)s\" \"https://www.youtube.com/watch?v=Yp_u1NpbkJg\" 2>/dev/null && ls -la ytdl_Yp_u1NpbkJg.*"
}Output from command in shell 43825e: The Agent Cloud: Databricks’ Bet on the Future of AI — Matei Zaharia and Reynold Xin | Latent Space | 1:10:05 | 20260624 -rw-r--r-- 1 root1 wheel 398214 Jun 25 14:12 ytdl_Yp_u1NpbkJg.en.srt Exit code: 0
Let me read the SRT file and summarize it.
{
"command": "cd /tmp && python3 -c \"\nimport re\nwith open('ytdl_Yp_u1NpbkJg.en.srt') as f:\n content = f.read()\n# Strip SRT formatting: remove index numbers, timestamps\nlines = content.split('\\n')\nout = []\nfor line in lines:\n line = line.strip()\n if not line: continue\n if re.match(r'^\\d+$', line): continue\n if re.match(r'^\\d\\d:\\d\\d:\\d\\d', line): continue\n out.append(line)\ntext = ' '.join(out)\ntext = re.sub(r'\\s+', ' ', text)\nprint(len(text), 'chars')\nwith open('ytdl_Yp_u1NpbkJg.txt','w') as f:\n f.write(text)\nprint(text[:2000])\n\""
}Output from command in shell 0c58ce: 232631 chars One of the fuses we have is actually One of the fuses we have is actually One of the fuses we have is actually once you can get the data in the right once you can get the data in the right once you can get the data in the right place, place, place, the AI models are becoming pretty good. the AI models are becoming pretty good. the AI models are becoming pretty good. The generic agents are fairly [music] I The generic agents are fairly [music] I The generic agents are fairly [music] I mean Ali talked about AGI already here. mean Ali talked about AGI already here. mean Ali talked about AGI already here. They have pretty good reasoning They have pretty good reasoning They have pretty good reasoning capabilities. Actually, I think many of capabilities. Actually, I think many of capabilities. Actually, I think many of the traditional software will be sort of the traditional software will be sort of the traditional software will be sort of rewritten with this new paradigm which rewritten with this new paradigm which rewritten with this new paradigm which is just get the data to be there and is just get the data to be there and is just get the data to be there and then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic will come out. will come out. will come out. >> Yeah. >> Yeah. >> Yeah. >> Um but without the right data, you can't >> Um but without the right data, you can't >> Um but without the right data, you can't really do that. really do that. really do that. >> Before we get into today's episode, I >> Before we get into today's episode, I >> Before we get into today's episode, I just have a small message for listeners. just have a small message for listeners. just have a small message for listeners. Thank you. We would not be able to bring Thank you. We would not be able to bring Thank you. We would not be able to bring you the AI engineering science and you the AI engineering science and you the AI engin Exit code: 0
The auto-generated captions are tripled (each phrase repeated 3 times). Let me dedupe and then summarize.
{
"command": "cd /tmp && python3 -c \"\nimport re\nwith open('ytdl_Yp_u1NpbkJg.en.srt') as f:\n content = f.read()\n# Parse SRT into segments\nblocks = re.split(r'\\n\\s*\\n', content.strip())\nsegs = []\nfor b in blocks:\n lines = [l.strip() for l in b.split('\\n') if l.strip()]\n if len(lines) < 2: continue\n # find timestamp line\n ts = None; text_lines = []\n for l in lines:\n if re.match(r'^\\d\\d:\\d\\d:\\d\\d', l): ts = l\n elif re.match(r'^\\d+$', l): continue\n else: text_lines.append(l)\n if not text_lines: continue\n text = ' '.join(text_lines).strip()\n text = re.sub(r'\\[.*?\\]', '', text).strip()\n if text: segs.append(text)\n# Dedupe consecutive repeats (often each phrase appears 2-3x in a row)\ndedup = []\nprev = None\nfor s in segs:\n if s != prev:\n dedup.append(s)\n prev = s\ntext = ' '.join(dedup)\ntext = re.sub(r'\\s+', ' ', text)\nprint(len(text), 'chars,', len(dedup), 'segments')\nwith open('ytdl_Yp_u1NpbkJg_clean.txt','w') as f:\n f.write(text)\nprint(text[:3000])\n\""
}Output from command in shell 5bb15c: 231265 chars, 4500 segments One of the fuses we have is actually One of the fuses we have is actually once you can get the data in the right once you can get the data in the right once you can get the data in the right place, place, place, the AI models are becoming pretty good. the AI models are becoming pretty good. the AI models are becoming pretty good. The generic agents are fairly I The generic agents are fairly I The generic agents are fairly I mean Ali talked about AGI already here. mean Ali talked about AGI already here. mean Ali talked about AGI already here. They have pretty good reasoning They have pretty good reasoning They have pretty good reasoning capabilities. Actually, I think many of capabilities. Actually, I think many of capabilities. Actually, I think many of the traditional software will be sort of the traditional software will be sort of the traditional software will be sort of rewritten with this new paradigm which rewritten with this new paradigm which rewritten with this new paradigm which is just get the data to be there and is just get the data to be there and is just get the data to be there and then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic will come out. will come out. will come out. >> Yeah. >> Yeah. >> Yeah. >> Um but without the right data, you can't >> Um but without the right data, you can't >> Um but without the right data, you can't really do that. really do that. really do that. >> Before we get into today's episode, I >> Before we get into today's episode, I >> Before we get into today's episode, I just have a small message for listeners. just have a small message for listeners. just have a small message for listeners. Thank you. We would not be able to bring Thank you. We would not be able to bring Thank you. We would not be able to bring you the AI engineering science and you the AI engineering science and you the AI engineering science and entertainment contents that you so entertainment contents that you so entertainment contents that you so clearly want if you didn't choose to clearly want if you didn't choose to clearly want if you didn't choose to also click in and tune into our content. also click in and tune into our content. also click in and tune into our content. We've been approached by sponsors on an We've been approached by sponsors on an We've been approached by sponsors on an almost daily basis, but fortunately almost daily basis, but fortunately almost daily basis, but fortunately enough of you actually subscribe to us enough of you actually subscribe to us enough of you actually subscribe to us to keep all this sustainable without ads to keep all this sustainable without ads to keep all this sustainable without ads and we want to keep it that way. But I and we want to keep it that way. But I and we want to keep it that way. But I just have one favor to ask all of you. just have one favor to ask all of you. just have one favor to ask all of you. T Exit code: 0
The repeats are within each segment (the same phrase appears 2-3 times within one SRT block). Let me dedupe within each segment.
{
"command": "cd /tmp && python3 -c \"\nimport re\nwith open('ytdl_Yp_u1NpbkJg.en.srt') as f:\n content = f.read()\nblocks = re.split(r'\\n\\s*\\n', content.strip())\nout_text = []\nfor b in blocks:\n lines = [l.strip() for l in b.split('\\n') if l.strip()]\n text_lines = []\n for l in lines:\n if re.match(r'^\\d\\d:\\d\\d:\\d\\d', l): continue\n if re.match(r'^\\d+$', l): continue\n text_lines.append(l)\n if not text_lines: continue\n text = ' '.join(text_lines).strip()\n text = re.sub(r'\\[.*?\\]', '', text).strip()\n if not text: continue\n # Split into words and dedupe consecutive repeated phrases.\n # The pattern is: phrase phrase phrase (repeated 2-3x). Try to detect.\n words = text.split()\n # Greedy: try repeat lengths 1..30, find smallest L such that text = P repeated\n # Simpler: try to collapse by detecting triple/double repeats of word-sequences.\n # Use a sliding approach: build result, and if last N words equal current N words, skip.\n result = []\n n = len(words)\n i = 0\n while i < n:\n # try repeat lengths up to 25\n best = None\n for L in range(1, min(26, (n-i)//2)+1):\n chunk = words[i:i+L]\n nxt = words[i+L:i+2*L]\n if chunk == nxt:\n # check triple too\n nxt2 = words[i+2*L:i+3*L]\n if chunk == nxt2:\n best = (L, 3)\n else:\n best = (L, 2)\n break\n if best:\n L, count = best\n result.extend(words[i:i+L])\n i += L*count\n else:\n result.append(words[i])\n i += 1\n cleaned = ' '.join(result)\n out_text.append(cleaned)\ntext = ' '.join(out_text)\ntext = re.sub(r'\\s+', ' ', text)\nprint(len(text), 'chars')\nwith open('ytdl_Yp_u1NpbkJg_clean.txt','w') as f:\n f.write(text)\nprint('---FIRST 3000---')\nprint(text[:3000])\n\""
}Output from command in shell 4e1598: 228502 chars ---FIRST 3000--- One of the fuses we have is actually One of the fuses we have is actually One of the fuses we have is actually once you can get the data in the right once you can get the data in the right once you can get the data in the right place, place, place, the AI models are becoming pretty good. the AI models are becoming pretty good. the AI models are becoming pretty good. The generic agents are fairly I The generic agents are fairly I The generic agents are fairly I mean Ali talked about AGI already here. mean Ali talked about AGI already here. mean Ali talked about AGI already here. They have pretty good reasoning They have pretty good reasoning They have pretty good reasoning capabilities. Actually, I think many of capabilities. Actually, I think many of capabilities. Actually, I think many of the traditional software will be sort of the traditional software will be sort of the traditional software will be sort of rewritten with this new paradigm which rewritten with this new paradigm which rewritten with this new paradigm which is just get the data to be there and is just get the data to be there and is just get the data to be there and then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic will come out. will come out. will come out. >> Yeah. >> Yeah. >> Yeah. >> Um but without the right data, you can't >> Um but without the right data, you can't >> Um but without the right data, you can't really do that. really do that. really do that. >> Before we get into today's episode, I >> Before we get into today's episode, I >> Before we get into today's episode, I just have a small message for listeners. just have a small message for listeners. just have a small message for listeners. Thank you. We would not be able to bring Thank you. We would not be able to bring Thank you. We would not be able to bring you the AI engineering science and you the AI engineering science and you the AI engineering science and entertainment contents that you so entertainment contents that you so entertainment contents that you so clearly want if you didn't choose to clearly want if you didn't choose to clearly want if you didn't choose to also click in and tune into our content. also click in and tune into our content. also click in and tune into our content. We've been approached by sponsors on an We've been approached by sponsors on an We've been approached by sponsors on an almost daily basis, but fortunately almost daily basis, but fortunately almost daily basis, but fortunately enough of you actually subscribe to us enough of you actually subscribe to us enough of you actually subscribe to us to keep all this sustainable without ads to keep all this sustainable without ads to keep all this sustainable without ads and we want to keep it that way. But I and we want to keep it that way. But I and we want to keep it that way. But I just have one favor to ask all of you. just have one favor to ask all of you. jus Exit code: 0
The repeats span across SRT blocks - the same phrase appears in 3 consecutive blocks. So I need to dedupe across blocks. Each block has the same content as the next 2 blocks. Let me dedupe consecutive identical blocks.
{
"command": "cd /tmp && python3 -c \"\nimport re\nwith open('ytdl_Yp_u1NpbkJg.en.srt') as f:\n content = f.read()\nblocks = re.split(r'\\n\\s*\\n', content.strip())\nsegs = []\nfor b in blocks:\n lines = [l.strip() for l in b.split('\\n') if l.strip()]\n text_lines = []\n for l in lines:\n if re.match(r'^\\d\\d:\\d\\d:\\d\\d', l): continue\n if re.match(r'^\\d+$', l): continue\n text_lines.append(l)\n text = ' '.join(text_lines).strip()\n text = re.sub(r'\\[.*?\\]', '', text).strip()\n if text: segs.append(text)\n# Now dedupe consecutive identical segments\ndedup = []\nprev = None\nfor s in segs:\n if s != prev:\n dedup.append(s)\n prev = s\ntext = ' '.join(dedup)\ntext = re.sub(r'\\s+', ' ', text)\nprint(len(text), 'chars,', len(dedup), 'segs')\nwith open('ytdl_Yp_u1NpbkJg_clean.txt','w') as f:\n f.write(text)\nprint('---FIRST 3000---')\nprint(text[:3000])\n\""
}Output from command in shell e36b88: 231265 chars, 4500 segs ---FIRST 3000--- One of the fuses we have is actually One of the fuses we have is actually once you can get the data in the right once you can get the data in the right once you can get the data in the right place, place, place, the AI models are becoming pretty good. the AI models are becoming pretty good. the AI models are becoming pretty good. The generic agents are fairly I The generic agents are fairly I The generic agents are fairly I mean Ali talked about AGI already here. mean Ali talked about AGI already here. mean Ali talked about AGI already here. They have pretty good reasoning They have pretty good reasoning They have pretty good reasoning capabilities. Actually, I think many of capabilities. Actually, I think many of capabilities. Actually, I think many of the traditional software will be sort of the traditional software will be sort of the traditional software will be sort of rewritten with this new paradigm which rewritten with this new paradigm which rewritten with this new paradigm which is just get the data to be there and is just get the data to be there and is just get the data to be there and then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic will come out. will come out. will come out. >> Yeah. >> Yeah. >> Yeah. >> Um but without the right data, you can't >> Um but without the right data, you can't >> Um but without the right data, you can't really do that. really do that. really do that. >> Before we get into today's episode, I >> Before we get into today's episode, I >> Before we get into today's episode, I just have a small message for listeners. just have a small message for listeners. just have a small message for listeners. Thank you. We would not be able to bring Thank you. We would not be able to bring Thank you. We would not be able to bring you the AI engineering science and you the AI engineering science and you the AI engineering science and entertainment contents that you so entertainment contents that you so entertainment contents that you so clearly want if you didn't choose to clearly want if you didn't choose to clearly want if you didn't choose to also click in and tune into our content. also click in and tune into our content. also click in and tune into our content. We've been approached by sponsors on an We've been approached by sponsors on an We've been approached by sponsors on an almost daily basis, but fortunately almost daily basis, but fortunately almost daily basis, but fortunately enough of you actually subscribe to us enough of you actually subscribe to us enough of you actually subscribe to us to keep all this sustainable without ads to keep all this sustainable without ads to keep all this sustainable without ads and we want to keep it that way. But I and we want to keep it that way. But I and we want to keep it that way. But I just have one favor to ask all of you. just have one favor to ask all of you. just have one favor to ask all of you. T Exit code: 0
The repeats are within each segment - each SRT block contains the phrase repeated 2-3 times. So I need to apply the within-segment dedup. Let me combine both: first dedupe within segment, then dedupe consecutive identical segments across blocks.
{
"command": "cd /tmp && python3 -c \"\nimport re\nwith open('ytdl_Yp_u1NpbkJg.en.srt') as f:\n content = f.read()\nblocks = re.split(r'\\n\\s*\\n', content.strip())\n\ndef dedupe_within(words):\n n = len(words)\n result = []\n i = 0\n while i < n:\n best = None\n maxL = min(40, (n-i)//2)\n for L in range(1, maxL+1):\n chunk = words[i:i+L]\n # check 2x\n if chunk == words[i+L:i+2*L]:\n best = (L, 2)\n # check 3x\n if i+3*L <= n and chunk == words[i+2*L:i+3*L]:\n best = (L, 3)\n break\n if best:\n L, c = best\n result.extend(words[i:i+L])\n i += L*c\n else:\n result.append(words[i])\n i += 1\n return ' '.join(result)\n\nsegs = []\nfor b in blocks:\n lines = [l.strip() for l in b.split('\\n') if l.strip()]\n text_lines = []\n for l in lines:\n if re.match(r'^\\d\\d:\\d\\d:\\d\\d', l): continue\n if re.match(r'^\\d+\\$', l): continue\n text_lines.append(l)\n text = ' '.join(text_lines).strip()\n text = re.sub(r'\\[.*?\\]', '', text).strip()\n if not text: continue\n cleaned = dedupe_within(text.split())\n if cleaned: segs.append(cleaned)\n\n# dedupe consecutive identical\ndedup = []\nprev = None\nfor s in segs:\n if s != prev:\n dedup.append(s); prev = s\ntext = ' '.join(dedup)\ntext = re.sub(r'\\s+', ' ', text)\nprint(len(text), 'chars,', len(dedup), 'segs')\nwith open('ytdl_Yp_u1NpbkJg_clean.txt','w') as f:\n f.write(text)\nprint('---FIRST 2500---')\nprint(text[:2500])\nprint('---LAST 1500---')\nprint(text[-1500:])\n\""
}Output from command in shell 478a15: 227549 chars, 4470 segs ---FIRST 2500--- One of the fuses we have is actually One of the fuses we have is actually once you can get the data in the right once you can get the data in the right once you can get the data in the right place, place, place, the AI models are becoming pretty good. the AI models are becoming pretty good. the AI models are becoming pretty good. The generic agents are fairly I The generic agents are fairly I The generic agents are fairly I mean Ali talked about AGI already here. mean Ali talked about AGI already here. mean Ali talked about AGI already here. They have pretty good reasoning They have pretty good reasoning They have pretty good reasoning capabilities. Actually, I think many of capabilities. Actually, I think many of capabilities. Actually, I think many of the traditional software will be sort of the traditional software will be sort of the traditional software will be sort of rewritten with this new paradigm which rewritten with this new paradigm which rewritten with this new paradigm which is just get the data to be there and is just get the data to be there and is just get the data to be there and then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic then let's slap some AGI on top. Magic will come out. will come out. will come out. >> Yeah. >> Yeah. >> Yeah. >> Um but without the right data, you can't >> Um but without the right data, you can't >> Um but without the right data, you can't really do that. really do that. really do that. >> Before we get into today's episode, I >> Before we get into today's episode, I >> Before we get into today's episode, I just have a small message for listeners. just have a small message for listeners. just have a small message for listeners. Thank you. We would not be able to bring Thank you. We would not be able to bring Thank you. We would not be able to bring you the AI engineering science and you the AI engineering science and you the AI engineering science and entertainment contents that you so entertainment contents that you so entertainment contents that you so clearly want if you didn't choose to clearly want if you didn't choose to clearly want if you didn't choose to also click in and tune into our content. also click in and tune into our content. also click in and tune into our content. We've been approached by sponsors on an We've been approached by sponsors on an We've been approached by sponsors on an almost daily basis, but fortunately almost daily basis, but fortunately almost dail ---LAST 1500--- here is this company going? He was like where is this company going? He was like don't sell until 100 billion or like don't sell until 100 billion or like don't sell until 100 billion or some version of that story, right? some version of that story, right? some version of that story, right? >> It was like the company should be >> It was like the company should be >> It was like the company should be worth a trillion dollars. You're worth a trillion dollars. You're worth a trillion dollars. You're underselling it for 10 billion. underselling it for 10 billion. underselling it for 10 billion. >> And like he doesn't do that for >> And like he doesn't do that for >> And like he doesn't do that for everyone, you know, like everyone, you know, like everyone, you know, like >> >> >> for some reason like you know, I >> for some reason like you know, I think he saw the vision but also the think he saw the vision but also the think he saw the vision but also the infinite runway that you have. infinite runway that you have. infinite runway that you have. >> We're lucky to have Ben. Yeah, he's a >> We're lucky to have Ben. Yeah, he's a >> We're lucky to have Ben. Yeah, he's a big supporter. big supporter. big supporter. >> Yeah, amazing. Okay, well, thank you so >> Yeah, amazing. Okay, well, thank you so >> Yeah, amazing. Okay, well, thank you so much. much. much. >> All right, thank you so much, Sweaks. >> All right, thank you so much, Sweaks. >> All right, thank you so much, Sweaks. >> Exit code: 0
The dedup isn't working because the repeats span across what I'm treating as one segment. Looking more carefully: "One of the fuses we have is actually One of the fuses we have is actually" — this is in ONE segment? Or the dedupe_within isn't catching it because the phrase isn't a clean repeat at the word level (punctuation differs). Wait, looking at the output: "One of the fuses we have is actually One of the fuses we have is actually" - this is 2x not 3x. Then "once you can get the data in the right once you can get the data in the right once you can get the data in the right" - 3x. The issue is my dedupe_within should catch these. Let me check - "One of the fuses we have is actually" repeated - L=7 words. chunk = words[0:7], words[7:14] should equal. Let me test... Actually wait, looking at the original SRT, the issue might be that the same text is split across multiple lines within a single block, and each line is repeated. Let me look at raw SRT.
{
"command": "cd /tmp && head -50 ytdl_Yp_u1NpbkJg.en.srt"
}Output from command in shell b8cebc: 1 00:00:00,000 --> 00:00:02,670 One of the fuses we have is actually 2 00:00:02,670 --> 00:00:02,680 One of the fuses we have is actually 3 00:00:02,680 --> 00:00:04,110 One of the fuses we have is actually once you can get the data in the right 4 00:00:04,110 --> 00:00:04,120 once you can get the data in the right 5 00:00:04,120 --> 00:00:05,270 once you can get the data in the right place, 6 00:00:05,270 --> 00:00:05,280 place, 7 00:00:05,280 --> 00:00:07,230 place, the AI models are becoming pretty good. 8 00:00:07,230 --> 00:00:07,240 the AI models are becoming pretty good. 9 00:00:07,240 --> 00:00:08,910 the AI models are becoming pretty good. The generic agents are fairly [music] I 10 00:00:08,910 --> 00:00:08,920 The generic agents are fairly [music] I Exit code: 0
I see - the YouTube auto-captions have a "rolling" pattern where each block contains the previous line AND the new line. So block 3 has both "One of the fuses..." (carried over) and "once you can get the data...". This is the typical rolling-caption format. The right approach: just take the LAST line of each block (the new content), OR dedupe so that we keep only new words. Actually, the cleanest approach is to take only the new line(s) in each block - but it's tricky because sometimes blocks have 1 line, sometimes 2. Actually, looking at it: block 1 = "One of the fuses we have is actually", block 2 = same (duplicate), block 3 = same + new line. The pattern is: each unique phrase appears in 3 consecutive blocks. So if I just dedupe consecutive identical *lines* (not blocks), I'll get the clean text. Let me re-parse: collect all lines from all blocks (ignoring timestamps/numbers), then dedupe consecutive identical lines.
{
"command": "cd /tmp && python3 -c \"\nimport re\nwith open('ytdl_Yp_u1NpbkJg.en.srt') as f:\n content = f.read()\nblocks = re.split(r'\\n\\s*\\n', content.strip())\nlines_all = []\nfor b in blocks:\n for l in b.split('\\n'):\n l = l.strip()\n if not l: continue\n if re.match(r'^\\d+\\$', l): continue\n if re.match(r'^\\d\\d:\\d\\d:\\d\\d', l): continue\n l = re.sub(r'\\[.*?\\]', '', l).strip()\n if l: lines_all.append(l)\n# dedupe consecutive identical lines\ndedup = []\nprev = None\nfor l in lines_all:\n if l != prev:\n dedup.append(l); prev = l\ntext = ' '.join(dedup)\ntext = re.sub(r'\\s+', ' ', text)\nprint(len(text), 'chars,', len(dedup), 'lines')\nwith open('ytdl_Yp_u1NpbkJg_clean.txt','w') as f:\n f.write(text)\nprint('---FIRST 3000---')\nprint(text[:3000])\n\""
}Output from command in shell 784d33: 77130 chars, 2251 lines ---FIRST 3000--- One of the fuses we have is actually once you can get the data in the right place, the AI models are becoming pretty good. The generic agents are fairly I mean Ali talked about AGI already here. They have pretty good reasoning capabilities. Actually, I think many of the traditional software will be sort of rewritten with this new paradigm which is just get the data to be there and then let's slap some AGI on top. Magic will come out. >> Yeah. >> Um but without the right data, you can't really do that. >> Before we get into today's episode, I just have a small message for listeners. Thank you. We would not be able to bring you the AI engineering science and entertainment contents that you so clearly want if you didn't choose to also click in and tune into our content. We've been approached by sponsors on an almost daily basis, but fortunately enough of you actually subscribe to us to keep all this sustainable without ads and we want to keep it that way. But I just have one favor to ask all of you. The single most powerful completely free thing you can do is to click that subscribe button. It's the only thing I'll ever ask of you and it means absolutely everything to me and my team that works so hard to bring the In Space to you each and every week. If you do it, I promise you we'll never stop working to make this show even better. Now let's get into it. Matei Zaharia from Databricks. Welcome to In Space. >> Thanks for having us. >> Yeah, thanks so much. >> Uh thanks for taking time out. You you have your Databricks Data AI Summit going on. You were just telling me how the first summit that you guys ran was just 50 people. >> Mhm. >> Yeah, it was a little meet-up at Berkeley, I think. We put together a Yeah. >> We did these tutorials and yeah, just teach people Spark. >> Yeah. You know, obviously now it's like I think I had like a the headline number is like 100,000 people around the world, 30,000 in person. Uh it's a crazy community. Well, I mean I just saw the keynote. >> >> Ali is just Did you know that was it obvious that back when that Ali would be like such a great like CEO? Like he's a great presenter. >> What do you think? >> Uh I mean, I think among our group of founders, it was clear that I think he'd be the best at this. And and yeah, it turned out great. And he's I mean, he's ramped up on so many topics going a company. He would just go in and like study at and, you know, become talked all the experts. Like, even if you can't hire the person, you know, learn enough about like finance and sales and whatever it was. Um, and you know, I'd go from there. Yeah. >> I mean, he's obviously very high IQ and have very high EQ, but it wasn't like Ali today is quite different from Ali from like 10 years ago. I think he there's a lot of work that he put in to get to this point. >> Yeah. I mean, no. I mean, to me the the most appealing thing about him is that he's funny. And like it You know, it's >> It's true. Yeah. >> It's hard to make jokes about, Exit code: 0
Now I have clean captions. Let me read the full transcript to summarize.
{
"file_path": "/tmp/ytdl_Yp_u1NpbkJg_clean.txt"
}<file-view path="/tmp/ytdl_Yp_u1NpbkJg_clean.txt" start_line="1" end_line="1" total_lines="1"> 1|One of the fuses we have is actually once you can get the data in the right place, the AI models are becoming pretty good. The generic agents are fairly I mean Ali talked about AGI already here. They have pretty good reasoning capabilities. Actually, I think many of the traditional software will be sort of rewritten with this new paradigm which is just get the data to be there and then let's slap some AGI on top. Magic will come out. >> Yeah. >> Um but without the right data, you can't really do that. >> Before we get into today's episode, I just have a small message for listeners. Thank you. We would not be able to bring you the AI engineering science and entertainment contents that you so clearly want if you didn't choose to also click in and tune into our content. We've been approached by sponsors on an almost daily basis, but fortunately enough of you actually subscribe to us to keep all this sustainable without ads and we want to keep it that way. But I just have one favor to ask all of you. The single most powerful completely free thing you can do is to click that subscribe button. It's the only thing I'll ever ask of you and it means absolutely everything to me and my team that works so hard to bring the In Space to you each and every week. If you do it, I promise you we'll never stop working to make this show even better. Now let's get into it. Matei Zaharia from Databricks. Welcome to In Space. >> Thanks for having us. >> Yeah, thanks so much. >> Uh thanks for taking time out. You you have your Databricks Data AI Summit going on. You were just telling me how the first summit that you guys ran was just 50 people. >> Mhm. >> Yeah, it was a little meet-up at Berkeley, I think. We put together a Yeah. >> We did these tutorials and yeah, just teach people Spark. >> Yeah. You know, obviously now it's like I think I had like a the headline number is like 100,000 people around the world, 30,000 in person. Uh it's a crazy community. Well, I mean I just saw the keyno... [truncated 75130 chars] </file-view>
The file is one long line. Let me read it in chunks via offset/limit or just read the whole thing. It's 77k chars. Let me read it directly with python and split into chunks to read.
{
"command": "cd /tmp && python3 -c \"\nwith open('ytdl_Yp_u1NpbkJg_clean.txt') as f:\n t = f.read()\n# split into ~4000 char chunks at word boundaries\nwords = t.split()\nchunk_size = 700\nfor i in range(0, len(words), chunk_size):\n print(' '.join(words[i:i+chunk_size]))\n print('===CHUNK_BREAK===')\n\" > ytdl_chunks.txt\nwc -l ytdl_chunks.txt"
}Output from command in shell 327bc8:
42 ytdl_chunks.txt
Exit code: 0{
"file_path": "/tmp/ytdl_chunks.txt"
}<file-view path="/tmp/ytdl_chunks.txt" start_line="1" end_line="18" total_lines="42"> 1|One of the fuses we have is actually once you can get the data in the right place, the AI models are becoming pretty good. The generic agents are fairly I mean Ali talked about AGI already here. They have pretty good reasoning capabilities. Actually, I think many of the traditional software will be sort of rewritten with this new paradigm which is just get the data to be there and then let's slap some AGI on top. Magic will come out. >> Yeah. >> Um but without the right data, you can't really do that. >> Before we get into today's episode, I just have a small message for listeners. Thank you. We would not be able to bring you the AI engineering science and entertainment contents that you so clearly want if you didn't choose to also click in and tune into our content. We've been approached by sponsors on an almost daily basis, but fortunately enough of you actually subscribe to us to keep all this sustainable without ads and we want to keep it that way. But I just have one favor to ask all of you. The single most powerful completely free thing you can do is to click that subscribe button. It's the only thing I'll ever ask of you and it means absolutely everything to me and my team that works so hard to bring the In Space to you each and every week. If you do it, I promise you we'll never stop working to make this show even better. Now let's get into it. Matei Zaharia from Databricks. Welcome to In Space. >> Thanks for having us. >> Yeah, thanks so much. >> Uh thanks for taking time out. You you have your Databricks Data AI Summit going on. You were just telling me how the first summit that you guys ran was just 50 people. >> Mhm. >> Yeah, it was a little meet-up at Berkeley, I think. We put together a Yeah. >> We did these tutorials and yeah, just teach people Spark. >> Yeah. You know, obviously now it's like I think I had like a the headline number is like 100,000 people around the world, 30,000 in person. Uh it's a crazy community. Well, I mean I just saw the keyno... [truncated 1584 chars] 2|===CHUNK_BREAK=== 3|has has similar things. But I think probably the two of you are leading the two most unique and differentiated initiatives in the landscape. Maybe we'll start with uh with Omnigents and then we'll we'll go into it. >> I do think that a lot of people are exploring this sort of meta harness concept. What led you to it? >> Yeah. There were actually a couple of like converging lines, which is I think is a good sign that you need something new. So, on the one hand, there's all the coding agent in for internally. We have really great dev infra team. They built something called Isaac that's basically like a wrapper on cloud code and and code X and lets you use them either on the web in like sandboxes or just on your dev machine or on your laptop or whatever. And then you know, they were adding all kinds of stuff there and we saw all the the sort of more advanced engineers like were building their own workflows with tons of agents and they were building their own UI's and stuff on top of even on top of that. And then the other one was that like us building agents, we shipped this like data science agent called Genie on the research team which I co-lead basically. We also build a lot of internal ones for various things and then we have all the customer ones and all of them were running into this thing of like, oh I need to switch model and harness and so on you know, every few months. Plus the agent is like completely useless if you can't share sessions with someone and have history and have search and all this like layer on top of it for collaboration. I thought a bit about it from both contexts and at first people thought it was weird and like why are you doing coding agents and custom agents in the same thing but I said it's it's it's basically the same problems and you you just want to build the stuff that lets you deliver the agent maybe control it if you care about security and make it portable across things. And then we prototyped some things as experiments. We said, ... [truncated 1680 chars] 4|===CHUNK_BREAK=== 5|want some layer on top to coordinate, you do want to design it and build it. So it reminds me of that like agents talking to each other and users talking to agents and and tools. >> Do we know of any other comments or alternative viewpoints? >> I think by the way, we had a debate on exactly we said the benefits with Matter a lot and I I think around the time we decided to do this thing, I was telling Matei, "Hey, it just happened to be there's a particular week that I was coding non-stop from the moment I woke up to like the moment I went to bed. I was like looking at my cloud sessions, my Codex sessions and and one of the things particularly annoying was having to keep my laptop open." >> Mhm. >> I was actually driving to a doctor's appointment and I remember because I want to make sure the whole thing continues working. By the way, it's so comforting to hear you say that because I'm like I don't know if I'm a clown and I'm doing this or like Yeah, yeah, like honestly, I I was driving and I was tethering my laptop to my phone. Keeping on the side, whenever I hit a red light, I started looking at what's going on on my laptop. And I just felt that was ridiculous. >> Yeah. >> It felt like we went back to the dark ages of programming. >> I mean, the productivity you gain from all this coding age is amazing, but uh Like, have you heard of cloud? >> >> It was crazy to me. >> Was it the thing we were working on was the sandboxes or was this before that? >> It was a sandbox. >> Okay. So, you you were >> And so, I was approaching from very different angle. I wanted to like, "Hey, we're going to have cloud sandboxes that actually doesn't shut down. You can get one very quickly, but not just for running agentic sessions. It's actually also for running development." So, I was actually personally building that that week and through building that, I ran into all these issues. And then, I wrote actually a document for my case that, "Here's my wish list of what the actual environm... [truncated 1555 chars] 6|===CHUNK_BREAK=== 7|image of the structure here and we can talk through a little bit of the architecture. I think I just I just want to have people understand cuz like when we're talking about software, it can be very abstract and like like here's actually what we're talking about. You've worked out in open source this entire platform basically and there's a runner component and server component with a sort of uniform API that you've you figured out. Any other sort of element and obviously you can plug in all these persistence layers and and compute layers. This is a whole cloud. This is Agent Cloud. >> Yeah, it's I mean it's got these components to work with it. The you know, a lot of the action happens like on the machine where you deploy your agent to. So, whatever you've got on there, you can run. But yeah, it's I think it's sort of the minimal thing you you want to have hosted like collaborative agents and to have that server. And one of the reasons we open sourced it is anyone building agents, this gives them an app they can start with and customize, which we were seeing in Databricks too like someone would make a nice, you know, agent app and then other teams would ask, "Oh, can I just use yours for my agent?" >> Yeah, I think we had like five or six different Agentic frameworks built by every different team. They do all do more or less the same thing. >> Yeah, you need to basically people want to take something that works in Forkit and you might as well have something open source. Yeah, which which also was another question that which is interesting for a Databricks like what do you choose to open source, what do you choose to make it proprietary? It's It's I mean this goes back to Spark, right? >> Yeah. >> >> One So, I mean one of the reasons to open source something is if you think it's a layer that will actually there'll be some network effect. It'll benefit from many people collaborating on it. So, for example, with Spark, I don't know if you if you know what when when Spar... [truncated 1736 chars] 8|===CHUNK_BREAK=== 9|on. Yeah. >> Yeah, you can look at the merge lines. I actually asked some legend this this morning about the >> 400 merge already? >> Yeah, I I think quite I would guess around half are not from my team. But for example, someone added support for running it on Kubernetes. People added many cloud sandboxes. So, this can launch a cloud sandbox and run your agent in there, which is great for sharing, too, cuz it's not like on your laptop and someone's like running sky code on there. Um so, yeah, many startups have put those in and we expect to see more of them. We also have more agent harnesses already, cursor, CLI, and anti-gravity, also. >> Yeah. >> That's all uh beautiful. I I you know, I I I feel like the last time this happens, there was the rise of the modern data stack. I don't know if it was that useful. I'm I'm actually kind of curious in your your postmortem. I I think most people will agree that it is finally dead. Uh but it maybe this arises to a new modern AI stack that like does the same thing. >> >> I don't know. >> I mean, I think the modern data stack was a pretty useful thing, probably even up until this day. I I think what maybe for the audience who don't actually understand the history. I think the modern data stack is effectively decomposed into you need a layer to ingest the data in. You need a layer to transform your data. Uh then all of this are run and then you need a layer to maybe visualize your data. And all of this runs on some sort of data warehouse or later on as we're doing data warehouse, also lakehouse. I think that concepts are all very powerful and very useful. It's sort of enabled a lot of workloads. What people eventually run into is kind of a question of unification and consolidation. It's, "Hey, do you really need to chop all of this into different pieces and work with so many different vendors and platforms in order to get like a very simple visualization done." Right? So, I think like over time everybody start realizing that cu... [truncated 1621 chars] 10|===CHUNK_BREAK=== 11|in fact, you could plug in your your own UI on top of this uh server. That That's one of the use cases we care a lot about cuz we want to use this in in our own products. >> Yeah, it should be everywhere. >> Yeah. >> I think one of those things that is is really interesting to me is well, first of all, I'll I'll endeavor to do everything and not call it the modern AI stack because I think we have a name. But like yes, like you know, uh so one of the first people that told me about compute uh sandboxing was Nikita from Neon. Cuz a lot of people think about uh Neon as like, well, it's serverless Postgres with like the separation of the compute and storage and uh you know, instant branching and all those things. But actually, every database company is also a compute company. >> Yeah. >> And so he was actually showing to me his whole his sandboxing solution. I don't think he ever launched it. >> So our sandbox solution, the reason we could have built it so quickly was because we realized if you just take the actual lake base architecture and remove the database from it, by the way it was coming from you. Now there are some differences. For example, in the ones that support this particular workload is important to have local persistence. Um because you want your state to persist. Your libraries you don't have to install your library every time. Right? Whereas the Neon architecture, because of the separation of storage from compute, you don't need persistent local disk. So there's some differences. But the at the end of the day, yeah, it's it's uh >> Yeah, so this is when you run like a a coding sandbox. Like if I use that we had the dev infra internally at Databricks, there's like many many like tens of gigabytes of data just for like all the source code and like artifacts and stuff that I built and I want that to come back next time. So but yeah. >> Before the show, we was talking about some statistics that might be surprising at the adoption. It could be internal, coul... [truncated 1709 chars] 12|===CHUNK_BREAK=== 13|agents today have very basic things like you can tell me which tool patterns are allowed or disallowed or whatever. It's like yes or no. But that puts you in a very tough spot. So, just as an example, like should my agent be able to read, you know, some confidential documents? Or or let's say should it be able to install new packages from NPM, which you know, maybe it's a it's compromised. Yes or no. Like maybe maybe I want to allow it. Should my agent be able to publish stuff to the company website? Well, if I'm using at the code on the website, yes. But should it be able to do both? So, it can like grab a confidential document and be prompt injected and leak it? Probably not. So, the thing we decided we need is stateful or what we call contextual policies, where you keep track of the state of that session. It's not like is it allowed to push to the marketing site or not? But like hey, if it did a risky thing, like it installed, you know, a one-day-old package from NPM, or it it read like a thousand confidential docs, then no. Then don't don't do it. Otherwise, maybe it's okay. That's one example of like moving that trade-off. So, it's both more secure and more useful by having a more powerful engine essentially. This requires tracking sessions. The other piece that was interesting there is like there are these very low-level events it's doing and you want some libraries on top that parse them. Like for example, we have a MCP server on Google Drive internally. It's got 60 API calls. Like how do I know which of those like will share a document with stuff on the internet and which ones won't? It's it's annoying. So we designed an Omnigen the policy layer so that it's it's functions and you can have libraries. Like someone can make something that maps the low-level events to high-level ones and then you write a policy about the high-level things that came out. So and that was related to the Panther and Yeah, Panther is will help with that. Panther is kind of a similar... [truncated 1662 chars] 14|===CHUNK_BREAK=== 15|spend a lot of time figuring out like, how can I make it as safe as possible and not annoying. >> Yeah. Is safety and let's call it security a bigger concern than token maxing or token budgets, you know, which one is like >> Oh, yeah, they're both there. I mean, I don't know. I I guess it depends on the type of company you are. So, I think some companies like the budget is is limited and you know, they they really care >> about that. Or I mean, you can be Uber and still be concerned, you know. >> Yeah, oh yeah, totally. Yeah, yeah, yeah. If you have Yeah. Yeah, for for us security is is absolutely critical as a as a, you know, cloud provider. It's it's the most important thing. And token maxing, you know, we we we're not so worried about it yet, but but I've seen the like for example, I talked to some consulting companies. They have like 100,000 employees who are all coding for customers. If those each spend like an extra $1,000 a month, that's that's not fun. You know, we have like only a few thousand engineers. >> What's the policy in Databricks? Is it is it just unlimited or >> unlimited, but we do you know, we use our own product to like analyze the traces and stuff and we have a team that's you know, looking to optimize and and to see if anyone's doing something weird. And we actually had some really cool insights just from analyzing current traces like which models are better at say Rust versus like, you know, TypeScript or whatever. So, yeah, at least in our code base. >> Yeah, amazing. Obviously, I have to ask the token maxing question. Obviously, I think it's a it's a key thing, but but yes, security and control above that and figuring out a sane layer that you can have some autonomy, but not too much. >> Yeah. Yeah, and we want to make it super easy. As an engineer, you should set the thing. So, in Omnigen, you can ask your agent set up a policy on yourself to do this. So, it >> If there's anything I should be showing, I I I don't I don't see it on the Git... [truncated 1522 chars] 16|===CHUNK_BREAK=== 17|you know, we don't want to do but you know, in Spark, if you just want to like, I don't know, like read a table or do like aggregation, it should be awesome out of that out of the box. >> Yeah. People want to catch up on Omnigen, they should watch your keynote, uh they should go through the GitHub in the docs. If they wanted to contribute or they want to build on this ecosystem, where would you call out as the most high-leverage places to get involved? >> Yeah, do get involved in the Discord and then get hub our team is is there is monitoring and some of the things people ask for we just built ourselves. Some of them, you know, we're we're collaborating with with them to build that and also tell us like how you would like to use that cuz I think especially for developers like everyone wants it to work their own way and a really good developer tool like you have to hear the feedback on all the ways and figure out the abstractions and how to let people customize. So we love to hear like if you think hey I you know I don't want it to work this way uh tell us. We really just want to get that compatibility layer across agents and then let you do stuff on top. >> Yeah. Is there any you know in terms of like the startup side I'm a founder I want to I see an opportunity I want to get in front of you. What's your request for like a startup that like you know I wish someone someone was working on this. >> Oh for a startup. >> Yeah. Like you know you got your own startup it's doing well but like you know if you weren't working on your own startup what what is like obvious that you should >> >> You advise many startups too obviously. >> I mean I do think just as a company with a lot of engineers like anything that helps me make sense of how people are using coding agents and and spend but also quality or like you should write you know you should add this skill or you should write this thing or your agents are really horrible at tasks involving this service or like go spend time... [truncated 1656 chars] 18|===CHUNK_BREAK=== </file-view>
{
"file_path": "/tmp/ytdl_chunks.txt",
"offset": 18,
"limit": 25
}<file-view path="/tmp/ytdl_chunks.txt" start_line="18" end_line="36" total_lines="42"> 18|===CHUNK_BREAK=== 19|to the term OLAP. And the differences is on OLTP, you typically have maybe run some transactions on event that looks up at one specific row, we update that row, right? It's a very row-oriented data structure. And on analytics, you're trying to reason on the data, you're trying to compute, "Hey, what's my revenue per store? What's my How's my website doing every day?" And then you eventually want to probably end up running machine learning on it to predict, "Hey, how will my maybe sales be going in the future?" They are so very different architecture, and everybody start with OLTP databases cuz every app, when it becomes serious enough, that needs more than markdown files, you need to have a database. You don't want to lose your data. You want to have some transactional consistency. But, once you want to reason on the data, if you only have like 100 rows, it's probably okay to run it on your Postgres or your on your MySQL database. But, once you have more data and want to run more complicated analysis, the very analysis might crush your save post crash database. So you start doing getting data out of the >> Replication replicate them into the analytic systems. >> Yeah, which is for people elastic search is like a big >> Yeah, so some of them actually get into elastic search for like log analysis. A lot of our customers obviously get into data bricks to run more sophisticated things. And there's this term called CDC. >> CDC change data capture. >> Um and what it does it reads the bin log of the database. And if you don't understand what bin log is fine. The but it's a little delta of the data and then reconstruct based on the delta the state of the database um on the analytic side. But CDC is like a very painful thing. It it's how basically standard in the industry. Everybody uses it. But um it ends up being so if I think many data engineers ends up being woken up at like 3:00 a.m. um because of some pipeline thing. >> You know, my my explanation is like everybody is ... [truncated 1736 chars] 20|===CHUNK_BREAK=== 21|obviously a word play on the term HTab, is that we think this is HTab done right. HTab wants to build a single engine for both. We think you can get 99% of what you need by unifying the storage. And just have a single storage layer. And once you have the single storage layer, if your Postgres databases are writing data in a column-oriented format, everything analytics can just go read that data directly without any delay. Right? There's no pipeline in between, so all the data would immediately be available for reasoning analytics. I think I was telling some customers earlier, hey, when we talked about this is going to be super useful for agents. I actually at first didn't really believe in it myself, even though we wrote that positioning. But then last night I was having dinner with Australian customer and they actually told me, oh hey, one of the big issue we have is we have all these logs from our services and we see SLA dips and want to investigate. But then there's no way for those agents to even understand what's going on in the actual databases themselves. All we see is just like product telemetry of the database and the services. You would actually make those agent 10 times more powerful if you understand, for example, who's actually placing those orders. Um what is happening? What exactly are they doing? So now I'm actually sold on our own message. >> Yeah. >> Um I think it's really kind of it gets you basically the almost all of the benefits of the HTAP holy grail, which is hey, make the data available immediate for reasoning analytics. >> Yeah, I think you know in the way that humans are generally intelligent and want to have the ability and access to to query anything. Even while they do the work, they also need history and they need context and like where else do they get context? That's an analytical workload. >> Exactly. >> >> Yeah, and I remember when we had incidents with with our databases and the engineer said, well, I can't just run a giant query ... [truncated 1751 chars] 22|===CHUNK_BREAK=== 23|And we could use those CPUs to do the transcoding from row to column, where row is good for OLTP, but column's good for analytics. Um so let's do the transcoding at that time. And as a matter of fact, once you transcode the data, the data compresses better. So from those services writing to, for example, S3 or other data lake like object stores, you can actually write them faster cuz now they are now smaller. >> Yeah. >> So there's no overhead, it's no compromise in performance. >> overhead. >> Yeah, but because but we had extra CPUs anyway. >> fleet anyway, yeah. >> So the the debate ended. I mean, it's one of the classics of the tech issue of a lot of debate, but then somebody actually went ahead and just tried to prototype it and it worked. >> But like something this strategic and important to the company, I expect there to be like a kickoff thing, like a design doc, nothing like that. >> Nothing like that. He He just We We were debating in many many meetings, and then we're just debating whether it's possible or not from first principle, and then somebody just did it. >> Yeah, I mean, if you set yourself up so people do that, that would be great. And that happened a bit with Omni John too. I think if if I just had a doc and like we can make these together, everyone would you know, would think oh, what about this? What about this? But then you if you try it out, it helps. And then if you have real users and they bash it and like it's still working or in this case, if you have the workload, you you know what the workload looks like, you can just test the same pattern and yeah. Tech aside, which is very cool, this is like the most important thing, the culture of innovation. And you don't have to ask my permission, you don't have to like do a whole form formal process, just do it, you know. >> Well, especially these days, I think with AI, it's actually easier to do that. >> I think you are very real I mean, I've met a lot of C-suite of like large companies and like ... [truncated 1562 chars] 24|===CHUNK_BREAK=== 25|it incrementally how how do we do it very quickly like many of our products they're built in the span of weeks and then we go to hey like usually my first question to whoever team is building is who's the target customer who are you working with are you on a first name basis with them are you texting with them? I think having that very tight loop. >> Can you bring up another launch that comes to mind with in this kind of thing I just to I just want to give you some background on that way. >> The uh >> Who's the customer? >> Yeah, I'm even was more of an internal thing actually because we would use that for our developer like yeah, basically the whole like AI team got access to it and was using it and we made sure it works from the beginning with our internal code base which is a mono repo that's like enormous. We gave them like some infrastructure. We gave them lots of like token capacity. So it's all the developers. Yeah. We had others. I don't This is I think a public story but >> I was going to ask marketplace open sharing all of them had I I just don't remember exactly which ones publicly referenced it. >> Yeah, they had other Well, very very early in the company there was like Delta Lake which is the transactional storage layer we did. We had our largest customer at the time said like okay, I need some I want something in the cloud cuz you know, I I if the rest of our network is compromised like this thing needs to be separate to store and query the events and then talked to us. He said okay, this is the rate of events per second. This is like the freshness I want. Can you do it? So that was like way larger than any workload we had and we had our engineer working on that my Michael Armbrust and he worked just to make this work and once it worked for them, you know, it worked for everyone else. Yeah, this was early in the company probably like four years in or so. >> 20 2018? >> Yeah, 17 18. >> >> Yeah, clean room which is basically how you share data in a way w... [truncated 1656 chars] 26|===CHUNK_BREAK=== 27|everything is new and sort of pristine. So yeah, it's just different and if you've never worked with enterprises or been in one, you you just won't know about it. >> And the procurement process is probably quite different. There's actually far more stakeholders. >> is one. Yeah. Another piece that's interesting is I think some tech companies you know, people will say oh I can build that myself, right? I I I I I I'll just build that myself. So so then you go >> I don't think people say that about Databricks. >> Uh >> >> Yeah, they do. They do. They do. They do. They do. >> Yeah, I mean yeah, and it depends on the the teams and things. But on the other hand like many of the enterprises say actually I don't. I never want to be in the business of building that. Like I don't want my you know, whatever I'm a retailer or something, I never want to be down because like some weird like nerd like couldn't get streaming pipelines working. That's is what I'm >> Yeah, this makes them great customers to be honest, right? >> But you have to understand that it's hard without having worked there and stuff. Like you may not appreciate. >> Look, I think they're all great. Don't get me wrong. They have different challenges. But the many of the tech companies, for sure there's a lot far more DIY. >> On the flip side, you have people who are they're very much experts in their domain. Like they're building airplanes. They're, you know, designing medicines, whatever. And they just want a bridge to the knowledge where like they don't want to learn, you know, databases or whatever as cool as we think it is even as interesting as the average software engineer might think it is to read a little bit. Like they just never want to know. They just say I have you know, giant like, you know, matrix or whatever with my clinical data. Like how do I, you know, how do I like cluster it or whatever. So, yeah. >> Yeah. Yeah, that's true. Okay, so and then I wanted to actually build out the the sort of dre... [truncated 1754 chars] 28|===CHUNK_BREAK=== 29|turned out it's not perfect and then it start failing and you're too ambitious never launch um and you get killed. The um the engineering team that actually started this, they were brilliant. I think we hired some of the best database engineers um on the planet into Databricks and they were brilliant. Thank god it's not their second system. Many of them have built more than two in the past. >> Nice. >> But, they were still worried about this. "Hey, building a database engine from scratch, I think the conventional wisdom is going to take like 5 years to mature. This will be a very long-term project. It could fail." Um I think one of the engineers kind of joking and say, "Hey, maybe we just call it Project Stream Engine." If we name after co-founder, maybe we don't get cancelled or killed. But, I I think they built something pretty remarkable. Um they went back to they they kind of changed the way the database engines were built from a paradigm point of view. Usually when you build a database engine, you read a lot of academic papers, you try to understand what the latest algorithms and data structures and you put them together and see if they work or not. And there's a high risk of failure there also because whatever that looks really good on paper might work out might might actually look really good in 70% of the workloads, but then it backfires on the other 30%. Um they actually went built a more of a factory for building the databases. So, they spent more time building this factory and the factory takes the decade of traces we have. I think they count as a quadrillion data points in the trace table. >> You don't drop anything? Or you see sample? >> We for sure sample, but the there's like massive amount of things. And the and they use that to build a model. Um like a machine learning model. Not an LM, machine learning model. Machine learning model basically it can very very quickly tell us how any algorithm and how any implementation will perform for any specific ... [truncated 1821 chars] 30|===CHUNK_BREAK=== 31|the This is the eight fallacies of distributed systems. That kind of thing is super useful. >> Yeah, that's it. >> It's like, okay, think through these eight. >> But let me give you a very weird example, but it actually has a profound implication on performance, which is like it's your string is ASCII or does it have Unicode in it? How should I encode this? >> I mean strings are the most complex data types. >> >> So the that like for example if strings are super dense, you could actually convert every string into a like imagine I have to do a aggregation instead of having a hash table, you could actually have an array because if your string is dense enough, if you only have 256 options, you don't need a hash table. You can just do array >> Yeah. >> lookup. >> Yeah. >> Um and that that'll be far faster. >> like a country code or something. >> Yeah. >> So it's actually like probably millions of uh features in that model. But using that, they can one basically prioritize the different algorithms that might actually impact in practice. And many of them are very counterintuitive. It isn't actually things that you think it might work super well actually don't work that well in practice. But also more importantly at runtime, you can dispatch the right algorithm and structure. >> I'm listening to to the the dream. I feel like Databricks is is doing a really good job with the incremental evolution. Do you have to hard cut to a new system at any point or like >> We designed it in a way that it can be incremental. So first we're releasing a new endpoint. Uh but but this goes to the broader ocean versus What we wanted to do is one to the by design, this new engine should be able to do everything we're able to do before and better. Right? It's been particular the better part refers to very low latency low latency workloads that can finish in tens of milliseconds. But we want to roll it out incrementally with incremental capabilities so it doesn't take like 5 years to actually se... [truncated 1778 chars] 32|===CHUNK_BREAK=== 33|SQL, why not just one? But I don't think that's an issue for agents. Agents are very eloquent in Postgres SQL or Spark SQL. It's never going to get confused. As long as the data is there and it's accessible, agents will do fine. That that might have been So, >> Yeah, and the >> 5 years ago might have been a problem for humans. >> That could arise over time also, but it should and this is leads to how to do things incrementally, right? Like you we realize you don't need it right now. We don't need to solve that problem to have a lot of value from from the current Delta app. >> Yeah, okay. I'm going to end the pod with a little bit of more of sort of spicier things. >> >> Everyone has like had the receive within a separation of storage and compute and try to build you know the the clouds. I had the same pitches from Snowflake. How have you succeeded where they failed? >> >> Rough. >> Well, I mean respect that they are a competitor. Objectively, you have outpaced them. >> What is the the core insight from your point of view that you you guys just went different directions? >> Probably the biggest fundamental difference. Both companies started around the same time. Both went to the cloud. Both focused on storage from compute architecture. But the biggest difference one is open. Like Databricks had never had a proprietary format, right? We started with the open sort of ecosystem. Started with Parquet and then evolved into Delta and Iceberg and all that. It's like one big thing. I think that matters a lot. The other one is AI. >> Um I mean before 2022 October 2022 when ChatGPT came out, we had always pitched Databricks as a machine learning plus data. And a lot of the platform were built with machine learning use cases in mind. And obviously AI is a little bit different. And Matei is like spent far more time there than I do. But the whole platform was we never felt hey we're just a data infrastructure platform. >> Like Databricks only yeah. >> I think that they started wi... [truncated 1774 chars] 34|===CHUNK_BREAK=== 35|a minute, so much of the compute is moving upstream into this this other thing." >> You have to go into each other's territory, yeah. >> But I think we did start with like the bigger scope and with the open thing. And And that's important actually. Like as a kind of ghost enterprises, like if your company's existed for like 30 years, you've experienced, you know, being locked into Oracle and like all kinds of like crazy things. And if you're the CTO there and you're setting up the architecture for the future for your company, you're going to want to pick a foundation that's open. And you only want like one way to manage data in your company ideally. You don't want like seven different systems. >> But I think the data format have won. Like, I think now every enterprise wants to put data in open data format. But, uh it was actually very controversial like back then. I think five, six When exactly as one of the Snowflake co-founders actually wrote a blog called Choosing Open Wisely, which basically argued against >> >> Yeah, yeah. >> I think they might have taken it down. You have to find the archive now. >> Oh, I mean, it's it's it's never going away now. Uh no, no, it's still there. I love the the sort of perspective of that only you guys will have because obviously you you you run the company. Uh and I I Thank you for indulging this. It's a incredible uh perspective. >> Maybe one last one. Um as you were talking, I think I have to give Ali a lot of credit. >> Mhm. >> He's an incredible CEO. I think he's the perfect combination IQ, EQ, technology obsession, execution, business acumen. >> Mhm. >> Um and uh and he's also a founder, which makes a lot may him a lot easier for him >> Yeah. >> to mobilize and execute. Um I think that's uh >> Oh, that was that was it. So, did uh you have Ali and he they don't like okay. >> Well, there's >> >> a whole lot of other things, but I think Ali played a pretty big role in the >> I was I was I was I was I thought he was there was li... [truncated 1624 chars] 36|===CHUNK_BREAK=== </file-view>
{
"file_path": "/tmp/ytdl_chunks.txt",
"limit": 7,
"offset": 36
}<file-view path="/tmp/ytdl_chunks.txt" start_line="36" end_line="42" total_lines="42"> 36|===CHUNK_BREAK=== 37|you know, even though we we did launch a open source model DBRX and you know, we we went up to like sort of above the Llama 3 scale, we decided that we really want to focus on there'll be so many people releasing models and instead of doing the general model where like, you know, a big part of the recipe is just throwing a lot of compute and just scale, uh we want to focus on like the next step also of let's say you have the very smart model. How do you make it, you know, useful? For us it was a lot about automating like how like like making it very good at querying data. That's the the first party agents we have called Genie. Uh so it's like a virtual data scientist. Imagine, you know, there's someone who already knows all the stuff in your company inside out and knows all the machine learning libraries, all the data libraries, you know, all the stuff on the web and you can ask them questions, you know. That's um that's what we wanted to do first. So that meant like let's not focus as much on like let's just train some kind of frontier model, but let's build a system using either external models or or um fine-tuned uh customized components. Um we're still doing quite a bit of model training though and in fact we're always, you know, we're procuring like lots of GPUs and stuff all the time to do it. Um and there's a few places where we're doing that. One is uh, there are many high volume use cases where if you have a specialized model, it's just so much better than any of the of the general models you get. Uh, nice example of that is understanding like documents, like PDF, Word documents, stuff like that, parsing them. If you've ever tried to do that, it's frustrating cuz you send it to like, you know, like Claude Fable or whatever, it like almost gets it, but it gets some things wrong. And it's super expensive. You just burned a huge amount of tokens plopping in an image into there. So, our team uh, built this uh, document uh, sort of vision model that takes a page... [truncated 1746 chars] 38|===CHUNK_BREAK=== 39|models. Like the same model generates training environments and trains itself and beats like Opus and GPT 5.5 and stuff at a task. So, I do think it's going to pick up. Like, you know, the thing is the ease of training the algorithms is only going to go up over time. There's a question of when it crosses into mainstream. Like, instead of just like, you know, specialized document parsing thing we did, where like you need a hardcore LLM researcher, when does it get easy enough that anyone can like sort of plop in some stuff and describe a task. >> Yeah. >> Well, you know what makes it easy? Interfaces. And uh, unified APIs. Cuz obviously if it's not interoperable, then you cannot switch. >> That's what we're seeing with these like with with Omnigent and the composable agents. Like you can have sub-agents with specialized models, and then you can train the whole thing. I think that'll help a lot, too. Yeah. >> The last thing I was going to leave, actually, this is I'm sequencing this, so I'm actually kind of proud of myself. Satya, uh, is uh, is uh, you know, talking about this. I interviewed him at Microsoft Build a couple weeks ago. And then he wrote this essay, which I'm sure you've seen, which is the whole mobile building frontier ecosystem. He sounded, uh, when I was talking to him, more like a Databricks CEO >> >> Uh-huh. >> Um, is there is there a I mean, uh, this thing presumably went viral in my circles. I don't know if it did in your circles. What what's the sort of theory of like, uh, you know, I guess tokens as IP, building up the context, you know, he basically said everything but data is the new oil or context is the new oil. Some some version of that, you know, that that you guys have heard before. >> Yeah, I agree. I think that the data you have, as you get better technology around that, like you can just do more in your domain with it. It's not even just about AI. Even when people, uh, you know, started collecting stuff in real time, like I remember al... [truncated 1712 chars] 40|===CHUNK_BREAK=== 41|We've had like GPU compute for a while and that's where a lot of the Mosaic, uh, stack went to to help scale that. >> Yeah. >> But yeah, we found that the engagements, like some of the There's two types of customers. There's some who just want GPUs and libraries to like get data in and out and monitors. So that's what AI runtime is. And then there's some that say, "Hey, you know, can you actually work with me, build evals, build synthetic data, >> Yeah. The more forward deployed solutions architects. >> that's what we're doing. And and as and more things will transition from like being custom to to not. But um that's sort of how it is today. >> Going back to original question, I think one of the thesis we have is actually the ones you can get the data in the right place. The AI models are becoming pretty good. The generic agents are fairly I mean I think I heard you talking about AGI is already here. They have pretty good reasoning capabilities. Actually, I think many of the traditional software will be sort of rewritten uh with this new paradigm, which is just get the data to be there. And then they slap some agent on top. Magic will come out. >> Yeah. >> Um but without the right data, you can't really do that. And it's actually our approach going to security and our approach to going to the uh customer data platform space. >> Yeah. >> Is uh like we we launched two products at Data and AI Summit. One targeting sort of security teams and the other one targeting marketing teams. And those all are have a lot of existing technologies out there. And our I think our approach is just, "Hey, once you get the data in, everything is a lot easier with agents on top." >> Yeah. Yeah. Well, and you guys have been fantastic guests. I just love this discussion. I just love the ability to dive in on the tech side, but also culture and strategy. I hope this isn't the last time we chat. Like I mean, congrats on all the success so far. >> Thank you. Congrats on your success also. >> Y... [truncated 1471 chars] 42|===CHUNK_BREAK=== </file-view>
I now have the full transcript. Let me write a comprehensive summary. The episode: Latent Space podcast — "The Agent Cloud: Databricks' Bet on the Future of AI" with Matei Zaharia and Reynold Xin. ~1:10:05, published 2026-06-24. Key topics covered: 1. Intro - Databricks Data + AI Summit growth (50 people at Berkeley → 100k worldwide, 30k in person) 2. Ali Ghodsi as CEO - his growth, presentation skills 3. Omnia / "Omni-gents" / Agent Cloud - open source agent platform - Origin: coding agents (Isaac wrapper on cloud code/codex) + custom agents (Genie data science agent) - Both needed: switch model/harness, share sessions, history, search, collaboration - Reynold's pain point: coding while driving, tethering laptop - Architecture: runner + server with uniform API, pluggable persistence/compute layers - Open sourced because of network effects (like Spark) - Already 400+ merges, half from non-team; K8s support, cloud sandboxes added by community - Agent harnesses: cursor, CLI, anti-gravity 4. Modern data stack vs modern AI stack - Modern data stack: ingest → transform → visualize, on warehouse/lakehouse - Consolidation trend 5. Sandboxes / compute - Inspired by Neon (Nikita) serverless Postgres - Databricks' sandbox: take lakebase architecture, remove database, add local persistence - Need persistent local disk for dev (tens of GB of source code/artifacts) 6. Security / contextual policies - Stateful policies: track session state, e.g. if agent installed 1-day-old NPM package or read 1000 confidential docs, then block risky actions - Low-level events → high-level abstractions for policy (e.g. MCP server on Google Drive with 60 API calls) - Panther project helps 7. Token budgets vs security - Databricks has unlimited policy but analyzes traces; insights like which models are better at Rust vs TypeScript 8. Startup opportunities - tools to make sense of coding agent usage, spend, quality 9. Lakebase / HTAP done right - OLTP vs OLAP distinction - CDC (change data capture) pain - data engineers woken at 3am - Lakebase: unify storage layer, Postgres writes in column-oriented format → analytics reads directly, no pipeline - Australian customer example: agents 10x more powerful if they can query actual databases - Origin: debate about transcoding row→column using spare CPUs; someone just prototyped it - Culture of innovation: no formal design doc needed, just try it 10. Databricks culture / shipping fast - "Who's the target customer? Are you on first-name basis with them?" - Examples: Isaac (internal dev tool), Delta Lake (driven by largest customer need ~2017-18), clean room 11. Enterprise vs tech company customers - Enterprises don't want to build infrastructure themselves - Domain experts (airplanes, medicines) just want a bridge to knowledge 12. Project Stream Engine / new database engine - Built by brilliant database engineers - Instead of reading academic papers, built a "factory" using decade of traces (quadrillion data points) to train ML model that predicts algorithm performance - Counterintuitive features (e.g. ASCII vs Unicode strings → array lookup vs hash table) - Runtime dispatch of right algorithm - Incremental rollout, new endpoint 13. Snowflake comparison - Both started same time, cloud, storage/compute separation - Differences: Databricks open (Parquet → Delta → Iceberg), AI-first (ML + data from before ChatGPT) - Snowflake's "Choosing Open Wisely" blog post 14. Ali Ghodsi credit as CEO 15. Model strategy - DBRX open source model, but decided not to compete on general frontier models - Focus on making models useful: Genie (virtual data scientist) - Specialized models for high-volume use cases: document parsing (PDF/Word vision model) 16. Training models trend - self-improving models, training environments 17. Satya Nadella essay - tokens as IP, context is the new oil 18. Two types of customers: GPUs+libraries (AI runtime) vs forward-deployed solutions architects 19. Closing thesis: get data in the right place → agents are good → traditional software rewritten as "data + agent on top" - New products at Data + AI Summit: security teams, marketing teams (customer data platform) Let me write a clean summary.
I've cleaned up the auto-generated captions (YouTube's rolling-caption format was tripling every phrase) and read through the full transcript. Here's the summary:
Latent Space podcast · Matei Zaharia & Reynold Xin · ~1h10m · published 2026-06-24
The first summit was a ~50-person Spark tutorial meetup at Berkeley. Now: ~100,000 attendees globally, 30,000 in person. Both praise Ali Ghodsi as CEO — high IQ/EQ, technically obsessed, learned finance/sales by studying experts. "Ali today is quite different from Ali 10 years ago — a lot of work put in."
An open-source platform for hosting, collaborating on, and securing agents.
Origin — two converging pain points:
Reynold's personal pain: Spent a week coding from waking to bedtime; had to keep his laptop open and tethered to his phone while driving to a doctor's appointment, checking it at red lights. "Felt like we went back to the dark ages of programming."
Architecture: A runner component + server component with a uniform API; pluggable persistence and compute layers. You can plug in your own UI. Designed so the same framework serves coding agents and custom agents — "it's basically the same problems."
Why open source: Network effects — like Spark. Inside Databricks there were already 5–6 different agentic frameworks built by different teams doing the same thing. Already ~400 merges, ~half from outside the team (Kubernetes support, multiple cloud sandboxes, cursor/CLI/anti-gravity harnesses).
Inspired by Neon (Nikita's serverless Postgres). Databricks' approach: take the lakebase architecture and remove the database. Key difference from Neon: dev sandboxes need persistent local disk (tens of GB of source code + artifacts must come back next time), whereas Neon's storage/compute separation doesn't need it.
Today's agents only allow/disallow tool patterns (yes/no), which is too coarse. Example tension: should the agent read confidential docs? Install NPM packages? Publish to the company website? Maybe yes to each individually, but no to all three combined (prompt-injection leak risk).
Solution: Stateful/contextual policies that track session state — e.g. "if it installed a 1-day-old NPM package or read 1,000 confidential docs, block the next risky action." Low-level events (e.g. an MCP server on Google Drive with 60 API calls) get mapped by libraries to high-level abstractions; policies are written against the high-level events. Panther is a related internal project that helps.
On token budgets vs security: Databricks gives engineers unlimited tokens but analyzes traces — and has surfaced insights like which models are better at Rust vs TypeScript on their codebase.
Classic OLTP (row-oriented, transactional) vs OLAP (column-oriented, analytical). Today's bridge is CDC (change data capture — reading the database binlog), which is painful and wakes data engineers up at 3am.
Lakebase thesis: Unify the storage layer (you get ~99% of HTAP's benefit). Postgres writes data in column-oriented format; analytics reads it directly with no pipeline in between. An Australian customer anecdote sold Reynold on it: their agents could see service SLA dips but couldn't query the actual order databases — making the data directly available would make those agents 10× more powerful.
Origin story: A debate about whether spare CPUs on Postgres fleets could do row→column transcoding on the fly (compressed data also writes faster to S3). No design doc, no kickoff — "somebody just went ahead and prototyped it and it worked." Both guests highlight this as the key Databricks cultural trait: don't ask permission, just try it.
Brilliant database engineers hired to build an engine from scratch; conventional wisdom says that takes 5+ years to mature and could fail. (One joked about naming it after a co-founder so it wouldn't get cancelled.)
Key innovation — a "factory" for building databases: Instead of reading academic papers and guessing, they trained an ML model (not an LLM) on a decade of traces — ~a quadrillion data points — that predicts how any algorithm/implementation will perform on any workload. Millions of features, many counterintuitive (e.g. ASCII vs Unicode strings → if strings are dense enough, use array lookup instead of a hash table). At runtime, the engine dispatches the right algorithm per workload. Rolling out incrementally via a new endpoint; designed to do everything the old engine did, plus low-latency workloads (tens of ms).
Both companies started around the same time, went cloud, did storage/compute separation. Two fundamental differences:
Databricks released DBRX (open-source, above Llama 3 scale) but decided not to compete on general frontier models — too many players, and the recipe is mostly "throw compute at scale." Instead, focus on the next step: making models useful.
Both agree. Matei: even before AI, when real-time data collection started, more data + better tech let you do more in your domain. Reynold ties it back to Databricks' strategy: get the data in the right place, then "slap an agent on top — magic comes out."
Two flavors of AI customer: (a) just want GPUs + libraries + monitoring (AI Runtime), (b) want forward-deployed SAs to build evals/synthetic data with them.
Two new products launched at the Summit — one for security teams, one for marketing/customer-data platform. Both rest on the same bet: "Once you get the data in the right place, the AI models are pretty good, generic agents have good reasoning — many traditional software products will be rewritten as: get the data there, slap an agent on top. But without the right data, you can't really do that."
Cleaned transcript saved at /tmp/ytdl_Yp_u1NpbkJg_clean.txt if you want to read it directly.