# Agents Without Code: Skills, YAML, and Filesystems Replaced Python — Philipp Schmid, Google DeepMind

Philipp Schmid, Google DeepMind

[Talk page](https://ai.engineer/talks/fjF8EKnxKCU-agents-without-code-skills-yaml-filesystems) · [Video](https://www.youtube.com/watch?v=fjF8EKnxKCU)

## Agents Without Code: Skills, YAML, and Filesystems Replaced Python

Philipp Schmid rebuilds a GitHub pull request reviewer three times, moving from a handwritten Python loop to a hosted agent with Bash, files, and search. The progression shows which code can disappear, where execution moves, and why instructions and evaluations remain your responsibility.

### The same reviewer, with less code each time

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

A GitHub pull request reviewer needs to retrieve changes, inspect code, and decide what deserves attention. Philipp Schmid of Google DeepMind builds that same agent three ways, deleting implementation code between versions. The working definition is deliberately small: an agent runs tools in a loop until it achieves its goal. The experiment changes who implements that loop and how the agent obtains its capabilities.

The common interface is the Gemini Interactions API, presented here as an API for both models and agents. It supports server-side state and background execution, alongside tool calls and multimodal inputs and outputs. Selecting a model or a managed agent can therefore preserve the application's basic request interface while changing how much execution the service handles.

Agent activity also needs a richer history than alternating user and model messages. A user request can lead to reasoning, a function call, a function result, and more reasoning before an answer appears. Interactions represents those events as a flat timeline of steps. A tool result can retain its own type instead of being squeezed into the user role merely to return environmental data to the model.

### Version one: Python connects each tool call to its result

[2:12](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=132s)

The first implementation makes the developer responsible for the complete execution cycle. A Python `run` function calls the model, inspects its response, distinguishes a function call from text, matches the requested function to an implementation, and executes it. Results—and errors when something goes wrong—must return to the conversation so the model can choose its next action. That repeated request, dispatch, and return is the agent loop.

Three pieces define the reviewer:

- **System instructions:** A separate prompt file establishes the role of GitHub PR reviewer.
- **Tool declarations:** Handwritten JSON schemas describe the available actions and the arguments the model must generate.
- **Tool implementations:** Python functions send requests to the GitHub API and return the data needed for review.

The declaration tells the model what it may request. The implementation performs the request outside the model.

The demo asks for a review of a pull request in the Gemini Skills repository. Function calls and results begin appearing, showing that the loop reaches the supplied GitHub capabilities. But a request outside that tool set receives a refusal. The model's ability to understand a question does not supply an implementation for answering it: this reviewer can act only through the tools the application defines.

The maintenance cost extends beyond GitHub logic. The application also owns routing, schemas, execution, error handling, and state. Each part is ordinary software, but each adds another place for the agent's execution to break. This is the boilerplate the second version removes.

### Version two: a framework removes the loop, while capabilities stay explicit

[4:58](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=298s)

ADK replaces the custom agent implementation with an agent class that handles tool loops, function calling, retries, and errors. The reviewer keeps the same prompt and Python tools. Its handwritten JSON declarations disappear too: the framework derives the schemas from function signatures and supplies them to the model. Schemas still exist in the execution path; the developer no longer maintains them separately.

The second reviewer retrieves PR data, the diff, and the code needed for inspection. Then comes the revealing question: what is the weather in San Francisco? There is no weather tool, so the expected response remains that the agent cannot obtain it. Packaging the loop in a framework reduces implementation work without expanding the agent's available actions.

The framework owns turn-taking, routing, execution mapping, and schema creation. The application still owns Python tool implementations, domain rules, and the environment that runs them. Extending the reviewer still means adding application code and arranging somewhere for that code to execute.

### A remote agent gets a sandbox—and credentials through a proxy

[7:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=460s)

The third approach uses the Antigravity remote agent on the Gemini API. It shares the harness—the machinery around the model—with the Antigravity IDE, but sharing a harness does not make the agents identical. The IDE agent is described as a coding agent; the API agent is general purpose, with potentially different instructions and tools. In particular, the Gemini API already supplies Google Search.

An `environment` parameter supplies a hosted, isolated cloud sandbox. The agent can run Bash commands, use tools, and save files there. Sources can come from a GitHub repository, a GCS bucket, or inline files. Instead of implementing every GitHub operation as a Python function, the application can provide an environment in which the agent uses existing software.

Authenticated requests pass through a network proxy around the sandbox. The agent initiates an outbound request, and the proxy injects the configured credential on the way to the external service. The agent can use GitHub without receiving the token itself. This separates access to the secret value from the ability to perform authenticated operations; it does not, by itself, limit what those operations may do.

Which component holds the credential, and which component sends the request? The diagram traces that separation. Network access has another control: permitted domains can be restricted, while the default described in the talk allows access to all domains for convenience. The demo later combines credentials for GitHub destinations with general web access that carries no GitHub credentials.

For reuse, the Agents API lets the developer register a configuration under a custom ID. That configuration includes the system instructions, base agent, and environment. Subsequent calls select the ID through the same style of interface used to select a model or the base remote agent. The configuration becomes a reusable agent definition rather than something rebuilt for every request.

An authenticated request without a token inside the sandbox
The sandbox originates the request. The proxy adds the configured credential before it reaches GitHub; network reach and authenticated reach are separate configuration choices.
- Agent sandbox — Runs commands and initiates outbound requests without seeing the credential.
- Network proxy — Injects configured credentials into outbound requests.
- GitHub destinations — The demo configures credentials for GitHub API access and github.com.
- Agent sandbox → Network proxy (Outbound request)
- Network proxy → GitHub destinations (Request with injected credential)

### Version three: the reviewer discovers and installs its CLI

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

In the third demo, the source directory is gone. An `AGENTS.md` file carries the review instructions and tells the agent that it has a GitHub CLI, Bash, and a filesystem. Dedicated functions for accessing a PR or reading its files have disappeared. The model chooses commands using its existing knowledge of the CLI.

There is still one small executable dependency: a Bash script that checks whether the GitHub CLI is installed and downloads and installs it if necessary. This matters immediately. When the review starts, the agent explores the sandbox, tries the CLI, discovers that it is missing, installs it, and proceeds with the review. The environment visibly changes from lacking the required program to containing a usable tool. The model handles that prerequisite through general commands rather than a developer-written branch in the PR-review loop.

The client streams the interaction so calls and results appear while the remote work continues. The same San Francisco weather question now produces a Google Search call and an answer of around 20°C, for July 2 in the demonstration. That is a concrete change from refusal to retrieval through an available general tool. It demonstrates broader task reach, rather than establishing weather accuracy or PR-review quality across repeated runs.

The weather answer also explains the architectural difference. No weather-specific Python wrapper was added. The API agent already had Search, and the model chose it for a question the GitHub CLI could not answer. General tools let the model compose a route to a task without the application naming every task-specific action in advance.

The client still makes an API call. It supplies user input, the environment, and the previous interaction ID to continue a multi-turn conversation. The environment sources include the installer script and `AGENTS.md`; credentials cover both GitHub API access and `github.com`, serving HTTP and Git commands. The backend starts the sandbox, loads the instructions and skills, and runs the repeated tool-call and tool-result cycle.

### The loop moves server side; domain behavior stays yours

[13:10](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=790s)

Where did the deleted Python work go? The following diagram shows the remaining client request beside the execution cycle now handled by the service. One client call can contain many model–tool exchanges. The loop remains essential; its implementation has moved out of the application.

The managed agent also handles conversation and session state, tool routing, and context compaction. The client sends new input instead of rebuilding the entire history or implementing its own compaction step. A remote Linux sandbox supplies the execution environment. These are the infrastructure responsibilities removed from the developer's reviewer.

Three responsibilities remain:

- **Instructions and rules:** Define the desired behavior and domain requirements in `AGENTS.md`.
- **Capabilities and context:** Supply the files, skills, and software the agent needs to accomplish the work.
- **Evaluations:** Decide what successful behavior means and verify the outcomes.

Reducing orchestration code leaves more attention for these product-specific decisions. A hosted loop cannot decide whether a review meets your standards.

One client request, many remote execution steps
The client supplies the new input and continuation ID. The service loads the environment, then repeats model decisions and sandbox actions while managing session state and context.
- Application client — Sends input, environment, and previous interaction ID.
- Managed agent — Loads instructions and skills; manages the loop, routing, session state, and compaction.
- Remote Linux sandbox — Executes commands and provides files.
- Application client → Managed agent (New input and continuation)
- Managed agent → Remote Linux sandbox (Tool call)
- Remote Linux sandbox → Managed agent (Tool result; continue the loop)

### Extend the reviewer with a skill, then reconsider the harness

[14:41](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=881s)

Security scanning makes the extension cost concrete. In the earlier design, adding a scan requires choosing a scanning CLI, wrapping it in a Python function, defining a function schema, registering the tool, and running the updated implementation. In the file-based design, the developer provides skill instructions describing the scanner and, when needed, places the CLI in the environment. The agent can use those additions through its existing execution tools.

A skill does not make the scanning software unnecessary. It removes the need for a new application wrapper when Bash and the supplied program already provide the required action. The extension changes the agent's available knowledge and environment, while its client-side orchestration stays the same.

The talk points to a Git-worktree example that replaced roughly 12,000 lines of TypeScript orchestration with about 200 lines of agent files, skills, and Markdown. It also cites Manus refactoring its harness five times in six months during the previous year. These examples motivate revisiting orchestration as model capabilities change: a workflow that once required hardcoded coordination may become something a model can carry out from instructions.

The closing heuristic is pointed: if the harness grows more complex as the model improves, it is probably being overengineered. New capability should prompt a question about what can be removed. The aim is to benefit from improved model judgment rather than keep adding execution paths that reproduce decisions the model can now make.

### Files carry preferences and handoffs beyond one conversation

[16:11](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=971s)

Files can hold more than capabilities. An agent asked to remember a preference can write a note to disk and reuse it in a later session. A long-running session can also externalize a new feature request as a handoff file, leaving it available for later work. The mechanism is explicit storage followed by retrieval: later work benefits when the relevant file is available and read.

That brings the practical advice back to ownership. Give the agent general tools and room to explore, reason, and find a solution. Keep domain instructions and workflows clear, define useful tools, own the evals, and verify the results. “Build to delete” is the phrase that lands: preserve the behavior the product needs while allowing improved models to retire unnecessary implementation.

The final invitation is to try the harness in AI Studio, where prompting it starts a custom sandbox, then begin building files and skills. API-key setup is offered as another route. A free tier for the API is described as work in progress at the time of the recording, so the invitation does not establish free API availability.

## Key takeaways

- Frameworks can remove handwritten loops and schemas while leaving the developer responsible for tool implementations and hosting.
- The remote reviewer uses Bash, a filesystem, and the GitHub CLI to discover and satisfy an execution prerequisite before continuing its task.
- A network proxy injects credentials outside the sandbox. Keeping the token hidden and limiting authenticated actions are distinct concerns.
- Managed execution moves loops, routing, session state, and compaction server side; instructions, capabilities, evaluations, and outcome verification remain product work.
- Skills and saved files can extend capabilities or carry preferences and handoffs. Improved models should create opportunities to delete orchestration that no longer earns its place.

## Resources

- [Building Managed Agents That Use GitHub Without Exposing Your Token](https://www.philschmid.de/managed-agents-gh) — A practical follow-up focused on the talk's GitHub integration and credential-handling example.
- [How Gemini Managed Agents Works under the Hood](https://www.philschmid.de/how-managed-agents-work) — Further reading on the managed execution machinery that replaces the application's custom loop.
- [8 Tips for Writing Agent Skills](https://www.philschmid.de/agent-skills-tips) — Authoring guidance for turning domain workflows into useful skill instructions.
- [Gemini API skills](https://github.com/google-gemini/gemini-skills) — Installable examples of coding-agent skills for Gemini development, including the Interactions API.

## Related talks

- [Replacing 12K LoC with a 200 LoC Skill](https://ai.engineer/talks/WE_Gnowy3uw-replacing-12k-loc-200-loc-skill) — Develops the orchestration-removal example explicitly mentioned near the end of this recording.
- [Don't Ship Skills Without Evals](https://ai.engineer/talks/0vphxNt4wyk-dont-ship-skills-without-evals) — Expands the responsibility left with the developer: testing skill behavior, detecting regressions, and deciding when guidance can retire.
- [Building Conversational Agents](https://ai.engineer/talks/cVzf49yg0D8-building-conversational-agents) — Provides a longer hands-on treatment of Interactions state, file tools, and the client-managed execution loop.

## Slides

### Agents Without Code

Philipp Schmid introduces a talk on how skills, YAML, and filesystems replaced Python. The title slide pairs the subject with three dated icons spanning January 2025 to June 2026.

[0:19](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=19s) [Title slide introducing how skills, YAML, and filesystems replaced Python, presented by Philipp Schmid.](https://assets.ai.engineer/sites/aiecode2025/sha256/844df20c69f038529e291b791a139b4613f18b313ff2dc4f67bcb39d9e7faf45.webp)

AI ENGINEER WORLD'S FAIR

Agents Without Code

How Skills, YAML, and Filesystems Replaced Python

Philipp Schmid, Staff Engineer, Google DeepMind

Jan 2025
Oct 2025
June 2026

1 / 22

### An LLM Agent Runs Tools in a Loop

Simon Willison defines an LLM agent by its repeated use of tools to achieve a goal.

[0:23](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=23s) [A Simon Willison quote defines an LLM agent as running tools in a loop to achieve a goal.](https://assets.ai.engineer/sites/aiecode2025/sha256/b74ce90c0fff6b9dff38c3edefd2db1a7b05a1ad12bf7c93fe7256fc576ca5af.webp)

"An LLM agent runs tools in a loop to achieve a goal."

- Simon Willison

2 / 22

### Building a GitHub PR Reviewer Agent

Schmid plans to build the same GitHub PR reviewer three ways, with less code and more files in each version.

[0:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=34s) [A section slide introduces three ways to build a GitHub pull request reviewer agent, with each version deleting code.](https://assets.ai.engineer/sites/aiecode2025/sha256/0d0543a0dae54abebd223035b2184163720316aba93669dd35e949972e213483.webp)

Building a GitHub PR Reviewer
Agent

Three ways. Each version deletes code.

Interface text:
3 / 22

### Interactions API

Schmid introduces a live demo of a PR reviewer built with the raw SDK, then plans to inspect and run the code.

[2:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=173s) [Live demo title slide for building a pull request reviewer with the raw SDK.](https://assets.ai.engineer/sites/aiecode2025/sha256/25c6b0f451f7c16e2bf80498bca022d944891cf90eb3c58bf2821c95f4678992.webp)

Interactions API

LIVE DEMO

Building the PR reviewer with raw SDK

8 / 22

### Agent interaction request

The Python agent sends each turn to the Interactions API with its tools and system instruction, then saves the response ID to continue the conversation.

[3:00](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=180s) [Code editor showing a Python agent calling the Interactions API and saving the interaction ID.](https://assets.ai.engineer/sites/aiecode2025/sha256/f8b8dd97fa089827936ab73dedc5da6bdf5c813ae9f835932e5bf9473ea2b417.webp)

import sys
from google import genai
from google.genai import types
from .tools import ALL_TOOL_SCHEMAS, TOOLS_MAP
from .prompts import SYSTEM_INSTRUCTION

class RawSDKAgent:
    def __init__(self, model: str = "gemini-3.5-flash", system_instruction: str = None):
        self.model = model
        self.client = genai.Client()
        self.last_interaction_id = None
        self.conversation_history = []
        self.system_instruction = system_instruction or SYSTEM_INSTRUCTION

    def run(self, contents: str | list) -> str:
        """Runs one turn of the agent.

        Supports string inputs or lists of function result dicts.
        If the model requests tool calls, handles execution recursively.
        """
        # We must re-specify tools and system instruction on every turn as they are interaction-scoped
        response = self.client.interactions.create(
            model=self.model,
            input=contents,
            tools=ALL_TOOL_SCHEMAS,
            system_instruction=self.system_instruction,
            previous_interaction_id=self.last_interaction_id
        )

        # Save interaction ID to continue the conversation thread
        self.last_interaction_id = response.id
        self.conversation_history.append(response)

        # Look for function calls in the steps
        tool_results = []
        for step in response.steps:

Interface text:
aie-worlds-fair-agents — agent.py
Explorer
aie-worlds-fair-agents
.venv
01_python
.venv
src
__pycache__
__init__.py
agent.py
github_client.py
prompts.py
tools.py
.env
main.py
02_framework
03_managed-ag...
assets
CONTENT.md
index.md
presentation.html
prompt.md
Outline
Timeline
01_python > src > agent.py > RawSDKAgent > run
Ln 15, Col 11
Spaces: 4
UTF-8
LF
Python 3.12.12 ('.venv': venv)
Select Python Interpreter
Pyrefly
Antigravity - Settings

### Tool results and error handling

The Python agent collects function results and errors, then sends the accumulated results back through its run function recursively.

[3:17](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=197s) [Code editor showing function results, exception handling and recursive submission of tool results.](https://assets.ai.engineer/sites/aiecode2025/sha256/26326a214f8f6e2e0a0b1d284daee928676a1ecd0b82b965d3e0f10076c6bede.webp)

class RawSDKAgent:
    def run(self, contents: str | list) -> str:

                        [illegible]
                        result_summary = str(result)
                        if len(result_summary) > 150:
                            result_summary = result_summary[:150] + "..."
                        print(f"[illegible] Function_result: {step.name} -> {result_summary}")

                        tool_results.append({
                            "type": "function_result",
                            "call_id": step.id,
                            "name": step.name,
                            "result": str(result)
                        })
                    except Exception as err:
                        print(f"❌ Function_result (Error): {step.name} -> {err}")
                        tool_results.append({
                            "type": "function[illegible]
                            "call_id": st[illegible]
                            "name": step.name,
                            "result": f"Error: {err}",
                            "is_errpr": True
                        })
                else:
                    print(f"❌ Function_result (Unknown Tool): {step.name}")
                    tool_results.append({
                        "type": "function_result",
                        "call_id": step.id,
                        "name": step.name,
                        "result": "Error: Tool not found",
                        "is_error": True
                    })

        # If any tools were executed, send the results back to the model recursively
        if tool_results:
            return self.run(tool_results)

Interface text:
aie-worlds-fair-agents — agent.py
Explorer
aie-worlds-fair-agents
.venv
01_python
.venv
src
__pycache__
__init__.py
agent.py
github_client.py
prompts.py
tools.py
.env
main.py
02_framework
03_managed-ag...
assets
CONTENT.md
index.md
presentation.html
prompt.md
01_python > src > agent.py > RawSDKAgent > run
name: Literal['get_pr_details', 'post_review_comment', 'read_pr_diff', 'read_repo_file']
Outline
Timeline
Ln 62, Col 43 (103 selected)
Spaces: 4
UTF-8
LF
Python
3.12.12 ('.venv': venv)
Select Python Interpreter
Pyrefly
Antigravity - Settings

### Interactions API PR reviewer

The reviewer’s system instruction directs it to inspect a PR, comment on issues and summarize its findings. A separate GitHub client retrieves PR metadata and diffs through API requests.

[3:25](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=205s) [Code editor showing instructions for a pull request reviewer to inspect changes, post comments and summarize its review.](https://assets.ai.engineer/sites/aiecode2025/sha256/fb3a482e7bba0dc74c644dc4d75e5f2e3dc6160cae9db5517835bd934a8a6479.webp)

# System instructions for the PR reviewer agent

SYSTEM_INSTRUCTION = (
    "You are an automated senior GitHub PR reviewer. Your goal is to review a given pull request. "
    "The user may provide the pull request as a repository name and number, or as a full GitHub URL "
    "(e.g., 'https://github.com/owner/repo/pull/num'). First, parse the repository path (e.g., 'owner/repo') "
    "and the pull request number from the input, then call get_pr_details and read_pr_diff. "
    "If you identify any issues (e.g. security flaws, hardcoded secrets, code quality bugs, or logical errors), "
    "call post_review_comment to post comments on specific lines. You can also read specific files in the "
    "repository using read_repo_file to get extra context. "
    "Be detailed but constructive. Once you have finished reviewing and posting comments, "
    "provide a final textual summary of your review, listing the files reviewed and any comments posted."
)

Interface text:
aie-worlds-fair-agents — prompts.py
Explorer
01_python > src > prompts.py
.venv
01_python
  .venv
  src
    __pycache__
    __init__.py
    agent.py
    github_client.py
    prompts.py
    tools.py
  .env
  main.py
02_framework
03_managed-ag...
assets
CONTENT.md
index.md
presentation.html
prompt.md
Tab to Jump
Outline
Timeline
Ln 1, Col 1
Spaces: 4
UTF-8
LF
Python 3.12.12 ('.venv': venv)
Select Python Interpreter
Pyrefly
Antigravity - Settings

[3:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=226s) [Editor showing authentication headers and pull request retrieval functions.](https://assets.ai.engineer/sites/aiecode2025/sha256/2de573ddffd85e8dc5d2e58acc7f68a0e5a0e2779d24e9f5b939770da463cdde.webp)

import os
import requests

def _get_headers(accept_header="application/vnd.github.v3+json"):
    pat = os.environ.get("GITHUB_PAT")
    if not pat:
        raise ValueError("GITHUB_PAT environment variable is not set.")
    return {
        "Authorization": f"token {pat}",
        "Accept": accept_header,
        "User-Agent": "AIE-Worlds-Fair-Agent"
    }

def get_pr_details(repo: str, pr_number: int) -> dict:
    """Retrieves pull request metadata, including the head branch commit SHA."""
    url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
    response = requests.get(url, headers=_get_headers())
    response.raise_for_status()
    data = response.json()
    return {
        "repo": repo,
        "pr_number": pr_number,
        "title": data.get("title"),
        "head_sha": data.get("head", {}).get("sha"),
        "base_sha": data.get("base", {}).get("sha"),
        "state": data.get("state")
    }

def read_pr_diff(repo: str, pr_number: int) -> str:
    """Reads the raw git diff text for a given pull request number."""
    url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
    response = requests.get(url, headers=_get_headers("application/vnd.github.v3.diff"))
    response.raise_for_status()
    return response.text

def read_repo_file(repo: str, file_path: str, ref: str = None) -> str:

Interface text:
aie-worlds-fair-agents — github_client.py
Explorer
01_python > src > github_client.py
.venv
01_python
  .venv
  src
    __pycache__
    __init__.py
    agent.py
    github_client.py
    prompts.py
    tools.py
  .env
  main.py
02_framework
03_managed-ag...
assets
CONTENT.md
index.md
presentation.html
prompt.md
Outline
Timeline
Ln 9, Col 40
Spaces: 4
UTF-8
LF
Python 3.12.12 ('.venv': venv)
Select Python Interpreter
Pyrefly
Antigravity - Settings

### Requesting a pull request review

In the terminal, Schmid asks the reviewer to inspect a Gemini skills pull request and return the review without posting comments or approving it.

[4:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=246s) [Terminal showing the reviewer’s introduction and a request to return a review without posting comments.](https://assets.ai.engineer/sites/aiecode2025/sha256/bf872bcd693561c6f2601fd80ce73927c29ba455172b247175a9edc93bcd233f.webp)

import os
import requests

def _get_headers(accept_header="application/vnd.github.v3+json"):
    pat = os.environ.get("GITHUB_PAT")
    if not pat:
        raise ValueError("GITHUB_PAT environment variable is not set.")
    return {
        "Authorization": f"token {pat}",
        "Accept": accept_header,
        "User-Agent": "AIE-Worlds-Fair-Agent"
    }

def get_pr_details(repo: str, pr_number: int) -> dict:
    """Retrieves pull request metadata, including the head branch commit SHA."""
    url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
    response = requests.get(url, headers=_get_headers())
    response.raise_for_status()

~> % uv run 01_python/main.py
Type 'exit' or 'quit' to end the session.

User > hello

Agent > Hello! I am an automated senior GitHub Pull Request reviewer.

To help you review a pull request, please provide either:
1. The **repository path and pull request number** (e.g., `owner/repo` and `123`), or
2. A **full GitHub Pull Request URL** (e.g., `https://github.com/owner/repo/pull/123`).

Once you share that information, I will analyze the pull request, check for issues (such as security flaws, bugs, quality improvements, or logical errors), post review comments on specific lines if needed, and provide a detailed summary of my review!

User > Review pull request google-gemini/gemini-skills/pull/54 and return your review here, don't write comments or approve it.

Interface text:
aie-worlds-fair-agents — github_client.py
Explorer
aie-worlds-fair-agents
.venv
01_python
.venv
src
__pycache__
__init__.py
agent.py
github_client.py
prompts.py
tools.py
.env
main.py
02_framework
03_managed-ag...
assets
CONTENT.md
index.md
presentation.html
prompt.md
Outline
Timeline
01_python > src > github_client.py
Problems 16
Output
Debug Console
Terminal
Ports
(aie-worlds-fair-agents) philschmid@philschmid-mac [15:38:15] [~/Desktop/aie-worlds-fair-agents]
gpkg
gpkg
Ln 9, Col 40
Spaces: 4
UTF-8
LF
Python
3.12.12 ('.venv': venv)
Select Python Interpreter
Pyrefly
Antigravity - Settings

### Reading the pull request diff

The reviewer calls get_pr_details and read_pr_diff for the Gemini skills pull request. The demo shows the metadata and the start of the diff; Schmid notes that the agent is limited to its defined tools.

[4:28](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=268s) [Terminal showing metadata and diff tool calls, followed by the beginning of a diff.](https://assets.ai.engineer/sites/aiecode2025/sha256/066144373321d048200e2487ae2c8394cab0379a7db24157e8b973559815a214.webp)

import os
import requests

def _get_headers(accept_header="application/vnd.github.v3+json"):
    pat = os.environ.get("GITHUB_PAT")
    if not pat:
        raise ValueError("GITHUB_PAT environment variable is not set.")
    return {
        "Authorization": f"token {pat}",
        "Accept": accept_header,
        "User-Agent": "AIE-Worlds-Fair-Agent"
    }

def get_pr_details(repo: str, pr_number: int) -> dict:
    """Retrieves pull request metadata, including the head branch commit SHA."""
    url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
    response = requests.get(url, headers=_get_headers())
    response.raise_for_status()

Terminal:
→ % uv run 01_python/main.py
1. The **repository path and pull request number** (e.g., `owner/repo` and `123`), or
2. A **full GitHub Pull Request URL** (e.g., `https://github.com/owner/repo/pull/123`).

Once you share that information, I will analyze the pull request, check for issues (such as security flaws, bugs, quality improvements, or logical errors), post review comments on specific lines if needed, and provide a detailed summary of my review!

User > Review pull request google-gemini/gemini-skills/pull/54 and return your review here, don't write comments or approve it.

Function_call: get_pr_details({'repo': 'google-gemini/gemini-skills', 'pr_number': 54})
Function_result: get_pr_details -> {'repo': 'google-gemini/gemini-skills', 'pr_number': 54, 'title': 'fix(gemini-api-dev): use GA model codes, drop retired -preview suffixes', 'head_sha...
Function_call: read_pr_diff({'repo': 'google-gemini/gemini-skills', 'pr_number': 54})
Function_result: read_pr_diff -> diff --git a/skills/gemini-api-dev/SKILL.md b/skills/gemini-api-dev/SKILL.md
index 4a28b78..4053a03 100644
--- a/skills/gemini-api-dev/SKILL.md
+++ b/...

Interface text:
aie-worlds-fair-agents — github_client.py
Explorer
01_python > src > github_client.py
.venv
01_python
.venv
src
__pycache__
__init__.py
agent.py
github_client.py
prompts.py
tools.py
.env
main.py
02_framework
03_managed-ag...
assets
CONTENT.md
index.md
presentation.html
prompt.md
Outline
Timeline
Problems 16
Output
Debug Console
Terminal
Ports
gpkg
gpkg
Ln 9, Col 40
Spaces: 4
UTF-8
LF
Python 3.12.12 ('.venv': venv)
Select Python Interpreter
Pyrefly
Antigravity - Settings

### What We Must Build (Raw SDK)

The API provides token generation and function calling, but developers must build the surrounding agent loop: route tools, define schemas, execute Python functions, and manage state.

[4:48](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=288s) [Comparison of API capabilities with orchestration tasks developers must build.](https://assets.ai.engineer/sites/aiecode2025/sha256/f241c8ac6393fd3b65675e2fbb3e08d665ef68c72375c790407748d021969405.webp)

What We Must Build (Raw SDK)
Why building directly on raw model endpoints requires extensive orchestration

What the API Solves
→ Token generation and native function calling

What We Must Build
→ Execution loops, tool routing, and retries
→ Manual JSON schemas for every tool
→ Resolving function calls to Python executions
→ Managing message lists and session state

9 / 22

### Agent Development Kit

The live demo returns to the same PR reviewer, now managed by a framework.

[5:35](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=335s) [Live demo title introducing a framework-managed pull request reviewer.](https://assets.ai.engineer/sites/aiecode2025/sha256/db15153e0788c34cbecd473811f7f27a047cfb55ce9d2bd400fbef2bdb97c4a8.webp)

LIVE DEMO

Agent Development Kit

Same PR reviewer, now framework-managed

Interface text:
11 / 22

### Agent Development Kit PR reviewer demo

The framework version keeps the prompt and review tools while removing the separate agent file. Schmid says the framework generates tool schemas from function signatures.

[5:47](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=347s) [Editor showing the Python and framework project trees, GitHub client code, and completed review output.](https://assets.ai.engineer/sites/aiecode2025/sha256/1c827d80d88b804963cab7182819cafa9f64dbcf4c0be36616c5a4dbce875864.webp)

import os
import requests

def _get_headers(accept_header="application/vnd.github.v3+json"):
    pat = os.environ.get("GITHUB_PAT")
    if not pat:
        raise ValueError("GITHUB_PAT environment variable is not set.")
    return {
        "Authorization": f"token {pat}",
        "Accept": accept_header,
        "User-Agent": "AIE-Worlds-Fair-Agent"
    }

def get_pr_details(repo: str, pr_number: int) -> dict:
    """Retrieves pull request metadata, including the head branch commit SHA."""
    url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
    response = requests.get(url, headers=_get_headers())
    response.raise_for_status()

Terminal:
(aie-worlds-fair-agents) philschmid@philschmid-mac [15:38:15] [~/Desktop/aie-worlds-fair-agents]
→ % uv run 01_python/main.py
#### **Changes Evaluated:**
1. **`gemini-3.1-flash-lite-preview`** $\rightarrow$ **`gemini-3.1-flash-lite`**
2. **`gemini-3-pro-image-preview`** $\rightarrow$ **`gemini-3-pro-image`**
3. **`gemini-3.1-flash-image-preview`** $\rightarrow$ **`gemini-3.1-flash-image`**

#### **Observations:**
- **Accuracy:** The changes correctly correspond to the official naming updates of the Gemini API models transitioning from experimental/preview status to General Availability (GA).
- **Consistency:** The `gemini-3.1-pro-preview` model has correctly retained its `-preview` suffix, which aligns with its current release phase.
- **Formatting:** The markdown bullet list is clean, syntax is correct, and no formatting errors or broken links are introduced.

This is a minor but critical documentation update to ensure systems and agents utilizing these system instructions refer to the correct GA production endpoints. No issues detected.

User > User >

Interface text:
aie-worlds-fair-agents — github_client.py
Explorer
01_python > src > github_client.py
01_python: .venv, src, __pycache__, __init__.py, agent.py, github_client.py, prompts.py, tools.py, .env, main.py
02_framework: src, __pycache__, __init__.py, github_client.py, prompts.py, tools.py, .env, main.py
03_managed-agents
assets
CONTENT.md
index.md
presentation.html
prompt.md
Outline
Timeline
Problems 16
Output
Debug Console
Terminal
Ports
gpkg
gpkg
Ln 9, Col 40
Spaces: 4
UTF-8
LF
Python 3.12.12 ('.venv': venv)
Select Python Interpreter
Pyrefly
Antigravity - Settings

[5:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=356s) [Editor showing a list of pull request review tools.](https://assets.ai.engineer/sites/aiecode2025/sha256/37a2be0573473e3339eaf322f67f9ba72843c8369eae4280ab31822f3a8acffb.webp)

from .github_client import (
    get_pr_details,
    read_pr_diff,
    read_repo_file,
    post_review_comment,
)

# Export tools list directly
ALL_TOOLS = [
    get_pr_details,
    read_pr_diff,
    read_repo_file,
    post_review_comment,
]

Terminal:
(aie-worlds-fair-agents) philschmid@philschmid-mac [15:38:15] [~/Desktop/aie-worlds-fair-agents]
→ % uv run 01_python/main.py
#### **Changes Evaluated:**
1. **`gemini-3.1-flash-lite-preview`** $\rightarrow$ **`gemini-3.1-flash-lite`**
2. **`gemini-3-pro-image-preview`** $\rightarrow$ **`gemini-3-pro-image`**
3. **`gemini-3.1-flash-image-preview`** $\rightarrow$ **`gemini-3.1-flash-image`**

#### **Observations:**
- **Accuracy:** The changes correctly correspond to the official naming updates of the Gemini API models transitioning from experimental/preview status to General Availability (GA).
- **Consistency:** The `gemini-3.1-pro-preview` model has correctly retained its `-preview` suffix, which aligns with its current release phase.
- **Formatting:** The markdown bullet list is clean, syntax is correct, and no formatting errors or broken links are introduced.

This is a minor but critical documentation update to ensure systems and agents utilizing these system instructions refer to the correct GA production endpoints. No issues detected.

User > User >

Interface text:
aie-worlds-fair-agents — tools.py
Explorer
02_framework > src > tools.py
01_python: .venv, src, __pycache__, __init__.py, agent.py, github_client.py, prompts.py, tools.py, .env, main.py
02_framework: src, __pycache__, __init__.py, github_client.py, prompts.py, tools.py, .env, main.py
03_managed-agents
assets
CONTENT.md
index.md
presentation.html
prompt.md
Outline
Timeline
Problems 16
Output
Debug Console
Terminal
Ports
gpkg
gpkg
Ln 1, Col 1
Spaces: 4
UTF-8
LF
Python 3.12.12 ('.venv': venv)
Select Python Interpreter
Pyrefly
Antigravity - Settings

### Review agent tool calls

The second agent receives a request to review a pull request locally. It fetches the PR details and diff, then calls a tool to read the affected file.

[6:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=382s) [Terminal showing a review agent calling tools and receiving results.](https://assets.ai.engineer/sites/aiecode2025/sha256/fece1842382101238ec47e5c15b99feb42aca37faac36e1d839e0538d95871ca.webp)

def _get_headers(accept_header="application/vnd.github.v3+json"):
    pat = [illegible]
    if not pat:
        raise ValueError("GITHUB_PAT environment variable is not set.")
    return {
        "Authorization": f"token {pat}",
        "Accept": accept_header,
        "User-Agent": "AIE-Worlds-Fair-Agent"
    }

def get_pr_details(repo: str, pr_number: int) -> dict:
    """Retrieves pull request metadata, including the head branch commit SHA."""
    url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
    response = requests.get(url, headers=_get_headers())
    response.raise_for_status()
    data = response.json()
    return {
        "repo": repo,

Terminal:
(aie-worlds-fair-agents) philschmid@philschmid-mac [15:51:09] [~/Desktop/aie-worlds-fair-agents]
-> % uv run 02_framework/main.py
Type your request. Type 'exit' or 'quit' to end.

User > Review pull request google-gemini/gemini-skills/pull/54 and return your review here, don't write comments or approve it.

Function_call: get_pr_details({'pr_number': 54, 'repo': 'google-gemini/gemini-skills'})
Function_call: read_pr_diff({'pr_number': 54, 'repo': 'google-gemini/gemini-skills'})
Function_result: get_pr_details -> {'repo': 'google-gemini/gemini-skills', 'pr_number': 54, 'title': 'fix(gemini-api-dev): use GA model codes, drop retired -preview suffixes', 'head_sha...
Function_result: read_pr_diff -> diff --git a/skills/gemini-api-dev/SKILL.md b/skills/gemini-api-dev/SKILL.md
index 4a28b78..4053a03 100644
--- a/skills/gemini-api-dev/SKILL.md
+++ b/...
Function_call: read_repo_file({'repo': 'google-gemini/gemini-skills', 'ref': '[illegible]', 'file_path': 'skills/gemini-api-dev/SKILL.md'})

Interface text:
aie-worlds-fair-agents — github_client.py
Explorer
01_python: .venv, src, __pycache__, __init__.py, agent.py, github_client.py, prompts.py, tools.py, .env, main.py
02_framework: src, __pycache__, __init__.py, github_client.py, prompts.py, tools.py, .env, main.py
03_managed-agents
assets
CONTENT.md
index.md
presentation.html
prompt.md
Outline
Timeline
02_framework > src > github_client.py
Problems 16  Output  Debug Console  Terminal  Ports
gpkg
gpkg
Ln 1, Col 1  Spaces: 4  UTF-8  LF  Python  3.12.12 ('.venv': venv)  Select Python Interpreter  Pyrefly  Antigravity - Settings

### Review result

The agent reports that the flash-image model name lost its preview suffix while gemini-3.1-pro-preview keeps it. It finds the changes ready to merge and reports no further issues.

[6:29](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=389s) [Terminal showing the agent's findings and review verdict.](https://assets.ai.engineer/sites/aiecode2025/sha256/b8425f2e1f34d0b1781b32ee7c268a703dbf3253adc0ef9ac93386222f959626.webp)

def _get_headers(accept_header="application/vnd.github.v3+json"):
    pat = os.environ.get('GITHUB_PAT')
    if not pat:
        raise ValueError("GITHUB_PAT environment variable is not set.")
    return {
        "Authorization": f"token {pat}",
        "Accept": accept_header,
        "User-Agent": "AIE-Worlds-Fair-Agent"
    }

def get_pr_details(repo: str, pr_number: int) -> dict:
    """Retrieves pull request metadata, including the head branch commit SHA."""
    url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
    response = requests.get(url, headers=_get_headers())
    response.raise_for_status()
    data = response.json()
    return {
        "repo": repo,

Terminal:
→ % uv run 02_framework/main.py
- `gemini-3.1-flash-image-preview` → `gemini-3.1-flash-image`

The `gemini-3.1-pro-preview` is left with its suffix as it is still in preview.

Files Reviewed
- `skills/gemini-api-dev/SKILL.md`

Detailed Findings & Analysis
- Correctness: The updated model names match the standard Google GenAI API GA model identifiers. Removing the `-preview` suffix ensures that models using this skill will invoke the stable GA versions.
- Clarity: Keeping the `gemini-3.1-pro-preview` suffix is correct as that model has not yet moved out of preview.
- Code Quality: The markdown changes are clean and directly update the list under "Current Models".

Verdict
The changes are accurate, correct, and ready for merging. No further issues were found.

User > User >

Interface text:
aie-worlds-fair-agents — github_client.py
Explorer
02_framework > src > github_client.py
.venv
01_python
  .venv
  src
    __pycache__
    __init__.py
    agent.py
    github_client.py
    prompts.py
    tools.py
  .env
  main.py
02_framework
  src
    __pycache__
    __init__.py
    github_client.py
    prompts.py
    tools.py
  .env
  main.py
03_managed-agents
assets
CONTENT.md
index.md
presentation.html
prompt.md
Outline
Timeline
Problems 16
Output
Debug Console
Terminal
Ports
(aie-worlds-fair-agents) philschmid@philschmid-mac [15:51:09] [~/Desktop/aie-worlds-fair-agents]
gpkg
gpkg
Ln 1, Col 1
Spaces: 4
UTF-8
LF
Python
3.12.12 ('.venv': venv)
Select Python Interpreter
Pyrefly
Antigravity - Settings

### What We Still Have to Own

The framework handles routing, dispatch and tool schemas, but developers still write Python for each tool, update code for new rules and host the execution environment.

[7:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=426s) [Two columns compare framework orchestration features with custom code and runtime responsibilities.](https://assets.ai.engineer/sites/aiecode2025/sha256/891499232c41899677ac74b7f578a10e3e10e4216c797bb6563687e7464c0e69.webp)

What We Still Have to Own
Why framework-based orchestration still requires significant developer plumbing

What the Framework Solves
→ Turn-taking loop and routing
→ Execution mapping and dispatching
→ JSON tool schemas from docstrings

What We Still Own
→ Custom Python plumbing code for every tool
→ Adding rules or features requires code updates
→ Hosting runtime environments and local sandboxes

12 / 22

### Managed Agents

A live demo introduces a zero-code managed agent using AGENTS.md and SKILL.md in a remote sandbox.

[9:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=593s) [Live demo title slide introducing managed agents in a remote sandbox.](https://assets.ai.engineer/sites/aiecode2025/sha256/8029fb28acfb52027c7ccf98d421c4cdc001c8ea86aa6e67434f61adca903675.webp)

Managed Agents

LIVE DEMO

Zero code: AGENTS.md + SKILL.md in a remote sandbox

Interface text:
15 / 22

### Managed agent instructions

The PR reviewer’s AGENTS.md gives it a GitHub CLI wrapper and shell access. Schmid explains that the agent can use these instead of purpose-built tools for accessing pull requests.

[10:13](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=613s) [Editor displaying instructions for a pull request reviewer and its environment.](https://assets.ai.engineer/sites/aiecode2025/sha256/dd2d80f5c78daa854acb44e73c4797848d821e8dc596c1681081e16305292d26.webp)

# AGENTS.md

You are an automated senior GitHub PR reviewer. Your goal is to review a given pull request.
You operate in a Unix environment and have access to the GitHub CLI wrapper script at `/workspace/bin/gh`.
Always use this wrapper by running `bash /workspace/bin/gh` for any GitHub operations (like API requests, comments, viewing PRs, checking out code, etc).
Do NOT use the standard `gh` command directly, as it will not have the correct authentication token.

## Environment Details
- The current workspace is at `/workspace`.
- The git repository and related CLI tools are available.
- You can run shell commands, write scripts, or inspect the filesystem to find context.

Interface text:
aie-worlds-fair-agents — AGENTS.md
Explorer
01_python
src
github_client.py
prompts.py
tools.py
.env
main.py
02_framework
src
__pycache__
__init__.py
github_client.py
prompts.py
tools.py
.env
main.py
03_managed-agents
.agents
bin
AGENTS.md
.env
main.py
stream.py
assets
CONTENT.md
index.md
presentation.html
Outline
Timeline

Problems 16  Output  Debug Console  Terminal  Ports
(aie-worlds-fair-agents) philschmid@philschmid-mac [15:51:09] [~/Desktop/aie-worlds-fair-agents]
→ % uv run 02_framework/main.py
[illegible] names match the standard Google GenAI API GA model identifiers. Removing the `-previe[illegible]
[illegible] this skill will invoke the stable GA versions.
- Clarity: Keeping the `gemini-3.1-pro-preview` suffix is correct as that model has not yet moved out of preview.
- Code Quality: The markdown changes are clean and directly update the list under "Current Models".

Verdict
The changes are accurate, correct, and ready for merging. No further issues were found.

User > User > whats the weather in san franciso
Agent > I do not have access to real-time information or weather APIs, so I cannot check the current weather in San Francisco.
I am specifically set up to help you review GitHub pull requests! If you have another PR you'd like me to look at, feel free to share the link or repository and PR number.
User >

Ln 11, Col 88  Spaces: 4  UTF-8  LF  Markdown  Antigravity - Settings

## Full transcript

[0:12](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=12s) Hi everyone. Uh thank you for coming. I

[0:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=14s) know it's the fourth day, last session

[0:16](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=16s) before the keynote starts again and we

[0:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=18s) are going to do something fun. Uh we're

[0:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=20s) going to look into how files are

[0:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=22s) basically replacing Python. And before

[0:25](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=25s) we begin, I would like to start with my

[0:26](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=26s) favorite definition of what is an agent

[0:29](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=29s) from Simon. An LLM agent runs tools uh

[0:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=32s) in a loop until it achieves a goal. And

[0:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=34s) what we are going to do is we are going

[0:36](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=36s) to build uh the same agent, the same

[0:38](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=38s) GitHub PR review agent in three

[0:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=40s) different ways. And we are going to

[0:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=42s) delete code on the way. Each new

[0:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=44s) version, less code, more files

[0:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=46s) basically. Um before we begin, I would

[0:49](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=49s) like to quickly introduce you to the

[0:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=51s) interactions API, which is our new

[0:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=53s) Gemini API. It's a unified interface for

[0:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=56s) um running models and agents. So you can

[0:58](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=58s) use the interactions API to call the

[1:00](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=60s) Gemini models directly or to call our

[1:03](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=63s) new agents, which also comes with

[1:05](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=65s) sandbox. It supports serverside state

[1:07](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=67s) management, background execution. So

[1:09](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=69s) it's perfectly suited for all that's

[1:11](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=71s) coming in the next years. and um the

[1:15](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=75s) capabilities it's the same API for tool

[1:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=78s) call multimodality understanding

[1:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=80s) multimodality generation so you always

[1:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=82s) have the same interface might look very

[1:25](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=85s) familiar if you're using other LLM

[1:27](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=87s) applications we really try to build

[1:29](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=89s) something for developers which you like

[1:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=90s) to use uh to build and that's something

[1:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=92s) we are going to do so something little

[1:36](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=96s) bit different in the interactions API to

[1:38](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=98s) other LLM applications or APIs is that

[1:41](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=101s) we moved away from this term based based

[1:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=104s) uh conversation history to steps. So

[1:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=106s) until I would say a few months ago, most

[1:49](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=109s) of the applications were really

[1:50](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=110s) turnbased. Normally you had a user in

[1:52](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=112s) input and then a model output, a user

[1:54](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=114s) input, a model output, which definitely

[1:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=116s) works for normal chat application. But

[1:58](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=118s) as soon as you start to build agents,

[2:00](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=120s) use reasoning model. We have more than

[2:02](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=122s) just a user role and a model role,

[2:04](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=124s) right? So we have like different inputs,

[2:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=126s) we have different types, we have

[2:08](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=128s) reasoning. So we decided to like make a

[2:11](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=131s) cut, make a change and build something

[2:13](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=133s) really for agents and that's what you

[2:15](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=135s) see on the flat steps timeline on the

[2:16](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=136s) right where you have a user input then

[2:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=138s) you have reasoning you have a function

[2:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=140s) call you have a function result and you

[2:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=142s) no longer need to like abuse the user

[2:24](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=144s) role for passing back data from an

[2:27](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=147s) environment. So

[2:29](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=149s) roughly a year one and a half years ago

[2:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=152s) writing agents mostly meant writing a

[2:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=154s) loop in Python. You needed to define a

[2:36](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=156s) JSON schema. You needed to define Python

[2:39](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=159s) functions. You needed to look at the

[2:41](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=161s) output from the LLM. Need to check if it

[2:43](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=163s) was a function call or if it was a text

[2:45](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=165s) response. And then needed to match it

[2:47](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=167s) against um the type and then like call

[2:49](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=169s) the tool

[2:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=171s) look of if you get an error and then

[2:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=173s) like go back and forth and let's look at

[2:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=176s) some some code example on how this would

[2:58](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=178s) look and also run it and hope that uh

[3:01](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=181s) the demo gods are great to us. So I

[3:04](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=184s) built or I let Gemini build a basic

[3:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=186s) implementation of this Python loop. So

[3:09](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=189s) we have our uh class. We have a run

[3:12](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=192s) function which uses the interactions

[3:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=194s) API. We have all of the weird complex

[3:17](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=197s) passing with function calling with uh

[3:19](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=199s) appending the errors checking if we get

[3:21](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=201s) an error and then we have uh the result

[3:23](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=203s) again. And what we need of course for an

[3:25](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=205s) agent is we also need a system

[3:27](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=207s) instruction. So there's a separate file

[3:29](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=209s) for the system instruction. Very basic.

[3:31](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=211s) QR GitHub PR reviewer and then of course

[3:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=214s) we need tools and for tools we needed to

[3:36](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=216s) write those um JSON schemas

[3:39](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=219s) specifications of description exactly

[3:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=222s) define which uh actions the agent can

[3:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=224s) take and then of course we need the

[3:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=226s) implementation in this case using the

[3:48](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=228s) the basic uh GitHub API just sending

[3:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=231s) some some requests. So we can run this

[3:55](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=235s) um in

[3:58](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=238s) and basically the main main

[3:59](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=239s) implementation is a very simple uh input

[4:02](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=242s) interface and we can say something like

[4:04](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=244s) hello

[4:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=246s) and

[4:08](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=248s) yes we get back hey I'm an agent and

[4:10](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=250s) then we yes ask it to review a pull

[4:13](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=253s) request on the Gemini skills repository

[4:15](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=255s) and what we should see is like the agent

[4:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=258s) should hopefully start soon sending

[4:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=260s) function calls function results function

[4:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=262s) calls function results but it's very

[4:24](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=264s) limited to yes uh great it works very

[4:28](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=268s) limited to the tools we define so if we

[4:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=270s) ask the agent to do something which it

[4:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=272s) does not have the capabilities to it

[4:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=274s) just says hey I cannot do this um which

[4:37](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=277s) is unfortunate but that's how we were

[4:39](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=279s) building agents um raw Python code a lot

[4:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=282s) of files a lot of things which can go

[4:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=284s) wrong a lot of code to manage so what

[4:47](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=287s) happened afterwards

[4:49](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=289s) um or what we we need to do we have like

[4:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=291s) a token generation We have the native

[4:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=293s) function calling and we must execute the

[4:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=296s) loop. We must handle the tool routing.

[4:57](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=297s) We must create a JSON schemas. We must

[5:00](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=300s) write the Python code. We need to

[5:02](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=302s) execute the Python code. We need to

[5:03](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=303s) manage the state. So there's a lot of

[5:04](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=304s) things we need to do to get an agent

[5:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=306s) running. And then we got agent

[5:09](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=309s) frameworks. There were many different

[5:10](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=310s) agent frameworks which abstracted away

[5:12](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=312s) some of that complexity. One example

[5:15](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=315s) here is the ADK framework um where you

[5:17](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=317s) have an agent class now which handles

[5:19](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=319s) all of the tool loops, the function

[5:21](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=321s) calling, the retries, the error handling

[5:24](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=324s) and it made it a little bit easier. We

[5:27](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=327s) basically removed all of the boiler

[5:29](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=329s) plate code which we always needed to

[5:31](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=331s) write for agents put it into a framework

[5:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=334s) and help people build with it. So back

[5:37](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=337s) to the demo and

[5:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=340s) um same example. So we go into the CR2

[5:43](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=343s) and what is very interesting if you let

[5:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=346s) me open both. So we still have our we

[5:50](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=350s) don't have our agent file anymore. So

[5:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=351s) the agent went away. We still have our

[5:54](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=354s) prompt same system prompt. We still have

[5:57](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=357s) our tools in this case also no JSON

[5:59](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=359s) definitions anymore because those agent

[6:01](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=361s) frameworks now use the uh signature of

[6:05](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=365s) our functions to create those JSON

[6:07](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=367s) schemas on the fly to provide the model.

[6:10](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=370s) So let's stop our um agent. Now let's

[6:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=374s) run our second agent.

[6:17](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=377s) Similar interface,

[6:19](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=379s) similar prompt and we should see a

[6:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=382s) similar expected behavior where we have

[6:24](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=384s) function calls. We try to get the PR

[6:26](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=386s) data. We try to get the diff, we try to

[6:29](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=389s) get all of the code we need and it works

[6:33](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=393s) and we wait for for the agent to yes

[6:36](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=396s) continue. But similar difficulty here.

[6:38](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=398s) If I ask it like what's the weather in

[6:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=402s) San Francisco

[6:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=404s) um

[6:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=406s) we should get back hopefully a result

[6:48](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=408s) like hey I cannot do this I don't have

[6:50](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=410s) access to the weather API which

[6:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=411s) obviously makes sense because we did not

[6:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=413s) define any tool still very unfortunate

[6:55](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=415s) because we need to be very explicit on

[6:57](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=417s) what our agent can do and we all know

[6:59](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=419s) nowadays that we just want to prompt

[7:01](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=421s) something and we wanted the agent to do

[7:03](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=423s) whatever it takes to to achieve that

[7:05](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=425s) goal. So what is left for us to do? What

[7:08](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=428s) does the framework solve? The framework

[7:10](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=430s) solves the turn taking loops, the

[7:12](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=432s) routing, the execution mapping, the JSON

[7:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=434s) schema creation for like the different

[7:16](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=436s) function calls, but we still own the

[7:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=438s) Python plumping. So we still need to

[7:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=440s) write those tools with Python code. We

[7:23](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=443s) still need to add specific rules or

[7:26](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=446s) requirements to like make sure whatever

[7:28](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=448s) we want the agent to do and we need to

[7:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=450s) provide the environment where all of the

[7:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=452s) tools are running, where we want to host

[7:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=454s) it. So what comes afterwards? Afterwards

[7:38](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=458s) hopefully comes remote agents and at

[7:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=460s) Google IO we launched the anti-gravity

[7:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=462s) remote agent on the Gemini API. The

[7:45](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=465s) anti-gravity agent uh is powered by the

[7:48](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=468s) same agent harness which powers the

[7:50](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=470s) anti-gravity IDE. Here the same harness

[7:52](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=472s) very important does not mean the same

[7:54](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=474s) agent because the anti-gravity agent is

[7:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=476s) a coding agent at the moment and the uh

[7:58](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=478s) agent available in the Gemini API is a

[8:00](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=480s) general purpose agent. So there might be

[8:02](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=482s) different system instruction, there

[8:04](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=484s) might be slightly different tools

[8:05](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=485s) because the Gemini API already has a

[8:07](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=487s) Google search tool. So we use that what

[8:08](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=488s) we have built and but very importantly

[8:11](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=491s) it comes with this new environment

[8:13](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=493s) parameter and this environment parameter

[8:15](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=495s) here allows the agent to get access to a

[8:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=498s) hosted isolated cloud sandbox where it

[8:21](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=501s) can run tools, where it can run bash

[8:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=502s) commands and where it can save files.

[8:25](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=505s) And those environments can be um

[8:28](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=508s) configured. So you can provide sources

[8:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=510s) and sources can be a GitHub repository,

[8:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=512s) it can be a GCS bucket, it can be inline

[8:35](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=515s) files and of course very important we

[8:37](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=517s) want to make sure that those agents are

[8:39](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=519s) secured and cannot use our credentials

[8:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=522s) in any way possible. So we created a

[8:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=524s) network proxy around the um agent

[8:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=526s) sandbox which basically injects the

[8:49](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=529s) credentials when the agent makes a

[8:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=531s) request from inside the sandbox to

[8:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=533s) outside the sandbox. So the agent never

[8:55](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=535s) really sees your credential. It just

[8:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=536s) knows hey I can call the GitHub API and

[8:59](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=539s) then on the fly we make sure that it

[9:01](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=541s) received the correct token which you

[9:03](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=543s) define and you can also limit which

[9:05](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=545s) domains the agent has access to. So if

[9:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=546s) you want to restrict the agent

[9:08](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=548s) completely on which network access it

[9:10](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=550s) can or which website it can access you

[9:12](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=552s) just leave it blank. By default the

[9:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=554s) agent can access all because I mean it's

[9:16](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=556s) a hassle if you first need to define

[9:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=558s) where to go. So we tried to stay simple

[9:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=560s) and of course making an API call is nice

[9:23](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=563s) but we thought hey people want to reuse

[9:25](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=565s) their configuration want to reuse their

[9:28](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=568s) agents. So we added the agents API where

[9:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=570s) you can define your own custom ID you

[9:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=572s) the same system instruction the same

[9:33](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=573s) base agent the same base environment and

[9:36](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=576s) then you can create that agent and then

[9:38](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=578s) you can use that agent in the same exact

[9:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=580s) way as you use Gemini models or as you

[9:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=582s) use the anti-gravity agent by providing

[9:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=584s) the ID. So all of the existing code can

[9:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=586s) be reused with your own custom agent,

[9:48](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=588s) with your own custom tools, with your

[9:49](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=589s) own custom uh credentials, environments,

[9:52](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=592s) whatever you need for it to to run. So

[9:55](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=595s) let's look at how this will look for SS

[9:58](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=598s) code and as a demo. And

[10:01](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=601s) okay, now 03. And what might be very

[10:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=606s) obvious is that we no longer have a

[10:07](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=607s) source directory. So the code went away.

[10:11](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=611s) We have now an agents M uh folder with

[10:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=614s) an agents MD file with system

[10:16](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=616s) instructions. So very similar system

[10:19](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=619s) instruction. The only difference here is

[10:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=620s) that we tell the agent, hey, you have

[10:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=622s) access to the GitHub CLI. So we no

[10:26](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=626s) longer create specific tools for reading

[10:29](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=629s) files from a GitHub pull request, for

[10:31](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=631s) accessing a GitHub pull request. We just

[10:33](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=633s) tell the agent, hey, you have a GitHub

[10:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=634s) CLI, you have a bash tool, you have file

[10:37](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=637s) systems. try to use it whenever you

[10:39](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=639s) think it's important. And since we don't

[10:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=642s) have the CLI installed, we have a very

[10:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=644s) basic bash script in this case which

[10:45](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=645s) checks, hey, if the GitHub CLI is

[10:47](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=647s) installed, please use it. If not,

[10:49](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=649s) download it and install it on the first

[10:50](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=650s) turn. So, we go into our terminal and we

[10:54](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=654s) run our agent here. In this case, maybe

[10:57](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=657s) important I use a stream version because

[10:59](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=659s) otherwise we would wait like a few

[11:01](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=661s) seconds and we not get back any we would

[11:03](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=663s) not get back any anything back. So same

[11:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=666s) prompt

[11:07](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=667s) and we should soon see um our function

[11:11](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=671s) calls and function results coming in.

[11:13](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=673s) Yes. So in this case since we run inside

[11:15](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=675s) a sandbox the agent first like explores

[11:17](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=677s) the sandbox to really make sure hey do

[11:19](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=679s) we have this GitHub CLI installed and

[11:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=682s) then tries to run it. It did not find it

[11:24](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=684s) on the first turn. So it installs it and

[11:26](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=686s) then we can see the agent doing its

[11:28](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=688s) work. And in this case it's not using

[11:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=690s) the predefined function calls. It's

[11:31](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=691s) using the GitHub CLI and it's already

[11:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=694s) existing knowledge about how it works. I

[11:36](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=696s) have a bash tool. I have like access to

[11:38](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=698s) the file system and I do all of that

[11:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=700s) work to see or to like review the the

[11:43](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=703s) pull request. Let's wait a little bit.

[11:47](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=707s) Okay. And I think the the amazing part

[11:50](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=710s) here is like if we ask the same question

[11:52](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=712s) as before, what's the weather in San

[11:57](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=717s) Francisco?

[11:59](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=719s) We should hopefully see that the agent

[12:02](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=722s) tries to use ah it uses Google search in

[12:04](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=724s) this case on 2nd of July. Let me quickly

[12:07](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=727s) check. Yeah, that's today. And we have

[12:09](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=729s) around 20° Celsius and it works. So the

[12:13](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=733s) agent became more of a general purpose

[12:15](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=735s) agent and we don't need to like specify

[12:17](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=737s) all of the tools. We basically trust the

[12:19](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=739s) model on understanding hey I have a

[12:21](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=741s) specific set of very atomic general

[12:23](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=743s) purpose tools to solve my task or the

[12:26](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=746s) task for the user. And if we look at the

[12:28](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=748s) the code uh for like the the input or

[12:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=752s) like the the sorry the the interface we

[12:35](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=755s) have our sources here. So we have the

[12:38](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=758s) the bash script which install the GitHub

[12:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=760s) CLI. We have the agents MD file and then

[12:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=762s) we say hey you can use the GitHub API

[12:45](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=765s) with credentials. So I want to access or

[12:48](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=768s) use GitHub credentials in a secure way.

[12:50](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=770s) So I created a token for the API and

[12:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=773s) also for github.com since you need both

[12:55](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=775s) URLs. one uses is used for the git uh

[12:57](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=777s) commands. The other one is used for HTT

[12:59](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=779s) commands and then domain all is

[13:00](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=780s) basically hey in addition to the GitHub

[13:02](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=782s) URLs you can use all of the web but you

[13:05](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=785s) don't have credentials for it and then

[13:07](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=787s) it's a it's a simple single API call to

[13:10](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=790s) the anti-gravity agent with your or user

[13:12](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=792s) input with the environment and then also

[13:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=794s) with the previous interaction ID that we

[13:16](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=796s) keep the multi-turn going and that

[13:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=798s) that's all it takes and it's a single

[13:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=800s) API call on the backend side we start

[13:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=802s) that cloud sandbox we load the agents MD

[13:25](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=805s) file and the skills from the environment

[13:27](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=807s) provided to the model and then the model

[13:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=810s) between the API and the sandbox does all

[13:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=812s) of the the looping calling the function

[13:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=814s) returning the function results calling

[13:36](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=816s) the function returning the function

[13:37](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=817s) results and that is all it takes. So

[13:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=820s) where does it leave us? We no longer

[13:43](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=823s) need to execute loops. We no longer need

[13:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=826s) to do two routing. We have a serverside

[13:48](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=828s) conversation and session state. So we

[13:50](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=830s) only need to provide new inputs. The

[13:52](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=832s) context window and the compaction is

[13:54](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=834s) also automatically managed by the agent.

[13:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=836s) So if we continue our conversation at a

[13:58](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=838s) certain point the context is compacted

[14:00](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=840s) and we can continue without the need to

[14:02](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=842s) manage anything and we also get an

[14:04](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=844s) isolated remote Linux sandbox which we

[14:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=846s) can use to run our code. So what is

[14:09](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=849s) still left for us? We need to define

[14:11](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=851s) instructions. We need to define rules

[14:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=854s) behaviors in an agent MD file. We need

[14:16](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=856s) to provide capabilities or context and

[14:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=858s) skills MD and we need to own the evils.

[14:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=860s) So all of the heavy lifting, the

[14:23](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=863s) infrastructure management, all of the

[14:24](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=864s) same code which probably every one of us

[14:26](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=866s) has written of us here like 20 times is

[14:29](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=869s) no longer needed. And you can start

[14:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=870s) really building your product instead of

[14:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=872s) like needing to rewrite the same code

[14:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=874s) over and over again. And very important

[14:37](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=877s) is like, hey, that's great, but what

[14:39](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=879s) about extending? And I think looking

[14:41](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=881s) into how extending previous agents to

[14:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=884s) like those new agents work. It's very

[14:47](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=887s) obvious that previously if we want to do

[14:50](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=890s) like some kind of security scanning on a

[14:52](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=892s) pull request, we would need to define or

[14:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=893s) write a Python function. We would need

[14:55](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=895s) to understand okay which CLI tools do we

[14:57](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=897s) need to use? We need to define a new

[14:59](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=899s) function schema and then we needed to

[15:01](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=901s) add it to our tools need to run it and

[15:03](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=903s) then so there's a lot of things we need

[15:05](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=905s) to do on on agents powered by files. We

[15:08](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=908s) write a skills MD file maybe with some

[15:10](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=910s) additional information on which CLI tool

[15:11](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=911s) to use or maybe provide the CLI tool

[15:13](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=913s) inside the environment and then we

[15:15](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=915s) extended the capabilities. we don't need

[15:16](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=916s) to change our code. We just provide more

[15:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=918s) files to the agent and the agent decides

[15:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=920s) on what we want to do. And I like to

[15:23](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=923s) bring up some very good examples. So at

[15:25](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=925s) a engineer in Europe, Cursor did a great

[15:27](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=927s) talk on how they replaced uh roughly

[15:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=930s) 12,000 lines of TypeScript code with a

[15:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=932s) 200 lines agent files to create

[15:35](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=935s) something similar. So they had a very

[15:37](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=937s) hard-coded code um orchestration for

[15:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=940s) doing git work trees and they were m

[15:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=942s) able to replace it with just a skill and

[15:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=944s) markdown files and there are more I

[15:47](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=947s) would say bitter lessons of ancient

[15:48](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=948s) engineering manos has refactored their

[15:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=951s) harness five times in six months last

[15:53](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=953s) year langen has rearchitected their open

[15:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=956s) deep research three times a year and

[15:57](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=957s) then also worsel has removed 80% of

[16:00](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=960s) their tools to achieve fewer steps

[16:02](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=962s) faster responses and better accuracy so

[16:04](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=964s) there's an obvious trend that with

[16:07](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=967s) better model capabilities, we can remove

[16:09](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=969s) orchestration code. But if your harness

[16:12](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=972s) is getting more complex as the model

[16:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=974s) improves, you are most likely

[16:16](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=976s) overengineering your harness. So if you

[16:18](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=978s) struggle with model improvements and

[16:20](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=980s) adding new capabilities which lead to

[16:22](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=982s) more complexity and more code, you might

[16:24](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=984s) need to rethink a little bit on how your

[16:26](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=986s) agent harness looks. And so where does

[16:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=990s) it end up? Agents are just files. We

[16:33](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=993s) write markdown files to extend

[16:34](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=994s) capabilities. Agents can learn from

[16:37](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=997s) those um can create their own files. So

[16:40](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1000s) if you have a session and tell the agent

[16:42](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1002s) to remember something to take notes of

[16:44](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1004s) rules of preferences, the agent just

[16:46](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1006s) writes it to this and then can reuse it

[16:48](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1008s) in the later session and you can also

[16:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1011s) externalize context. So if you have a

[16:52](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1012s) very long running session and during

[16:54](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1014s) that session you notice hey maybe I want

[16:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1016s) to additionally work on another feature

[16:58](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1018s) you can like just write that information

[17:00](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1020s) that hand off to a file and like tell

[17:02](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1022s) the agent to later pick it up. Uh so

[17:05](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1025s) what are the takeaways? We should not

[17:07](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1027s) fight the model like we should stop

[17:09](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1029s) micromanaging the execution paths

[17:11](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1031s) provide general tools to the agent and

[17:12](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1032s) let the model explore reason and

[17:14](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1034s) discover the right solution. Own what is

[17:17](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1037s) yours meaning focus on your domain

[17:19](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1039s) instructions. Focus on the workflows.

[17:21](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1041s) Focus especially on the evals, define

[17:24](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1044s) clean tools and verify the outcomes and

[17:26](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1046s) really build to delete. Like we have

[17:28](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1048s) seen in the past many many times, the

[17:30](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1050s) better the model get, the more code we

[17:32](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1052s) can remove and the more things we need

[17:33](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1053s) to change and obviously we all want to

[17:35](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1055s) benefit from better models. So what the

[17:39](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1059s) things for you to get to do on Monday,

[17:41](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1061s) you can scan that QR code which brings

[17:43](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1063s) you directly to EI studio where you can

[17:45](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1065s) immediately try out the anti-gravity

[17:47](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1067s) harness. So you can already start

[17:49](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1069s) prompting it. it will start your own

[17:51](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1071s) custom sandbox. If not, um, start or

[17:54](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1074s) create your API key. We are currently

[17:56](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1076s) working on a free tier for the API. So

[17:59](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1079s) hopefully you can start exploring faster

[18:01](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1081s) soon and then definitely start building

[18:03](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1083s) files and skills. And that's it. Thank

[18:06](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1086s) you for for coming.

[18:09](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1089s) [applause]

[18:24](https://www.youtube.com/watch?v=fjF8EKnxKCU&t=1104s) >> [music]
