{
  "video": {
    "id": "33Oct2hqGnk",
    "title": "Agents That Write Their Own Tools at Runtime — Sandhya Subramani, AWS",
    "duration": 1240,
    "upload_date": null,
    "channel": "AI Engineer",
    "source": "AI Engineer",
    "event_format": ""
  },
  "analysis": {
    "video_id": "33Oct2hqGnk",
    "title": "Agents That Write Their Own Tools at Runtime — Sandhya Subramani, AWS",
    "one_liner": "With Strands Agents, an agent that starts with no tools of its own can write, load and use new tools (and sub-agents) while it is running. It needs only three tools (editor, shell and load_tool) plus a system prompt that describes what a good tool looks like.",
    "summary": "Sandhya Subramani (AWS) argues that coding assistants like Claude Code and Cursor can write tools, but few agents can fix or extend themselves at runtime in production. She demos 'meta tooling' in the open-source Strands Agents harness: an empty agent creates a math calculator and a character counter on request, and a 'meta agent' splits a Hawaii trip-planning request into flight, activities and itinerary sub-agents that it writes itself. She then warns that this autonomy needs Strands' eight built-in evals and four kinds of guardrails, sandboxing of the code-execution environment above all.",
    "key_points": [
      "Demo: agents.py has only a system prompt and three tools, and its tools package is empty. Asked for math, it wrote a math calculator tool (min, max and more) and used it immediately without a restart. Asked to count characters, it noticed it had no such tool, wrote a character counter and used it.",
      "Meta tooling needs three tools: editor (to write tool files), shell (to see the directory, where it is running and where the codebase is) and load_tool (to load newly written tools from the directory dynamically). Wiring it up is one line: system prompt plus the three tools.",
      "The system prompt defines a tool template and spec: start with the @tool decorator, say where tools are stored, and always check whether a tool already exists before writing a new one.",
      "Strands began with a load_tools_from_directory=True setting so agents could run tools they generated at runtime. That was later turned into a tool of its own, load_tool.",
      "The meta-agent demo used the same pattern with an agent file template ('break it into two to four sub-agents', no swarm). Given only 'help me plan my itinerary' for Hawaii, it called the editor three times to create flight, activities and itinerary agents, then called them. It couldn't get real-time info because it had no real-world API tool.",
      "Three agentic patterns the agent can build for itself: swarm (sub-agents working in parallel), graph (one sub-agent's output handed off to the next) and workflow (a mix of both).",
      "Strands has eight built-in evals: end-goal achievement (session level); helpfulness and whether the answer was made up (trace level); right tool and right parameters; and, for multi-agent systems, overall outcome, correct call sequence of tools and sub-agents, and quality of inter-agent messages.",
      "Four kinds of guardrails: sandboxing the code-execution environment (a Strands feature launched 'a few weeks ago'), constraining tools and permissions, constraining who can ask it what, and observability (evals and telemetry). Strands was built internally three years ago, and its Python version wrote the TypeScript version."
    ],
    "takeaways": [
      "To let an agent fill capability gaps in production instead of failing and waiting about two weeks for an engineering fix, give it editor, shell and load_tool plus a system prompt with a tool template, a storage location and a 'check whether it exists first' rule.",
      "Sandbox the environment where generated code runs, not just the agent's container: a meta agent that can create tools can also modify and delete your data.",
      "Evaluate at every level before you trust self-modifying agents: session goal, trace helpfulness and faithfulness, tool choice and parameters, and multi-agent ordering and messages.",
      "Constrain tools, permissions and who can query the agent, and collect telemetry, so autonomous changes stay observable.",
      "Set limits such as max tokens. Under adversarial audience prompts the demo agent errors and 'just talks', though it recognises the error and tries to fix the tool or agent itself."
    ],
    "topics": [
      "agents",
      "meta-tooling",
      "self-healing",
      "multi-agent",
      "evals",
      "guardrails",
      "sandboxing",
      "runtime-tool-generation"
    ],
    "tools": [
      "Strands Agents",
      "AWS",
      "Claude Code",
      "Cursor",
      "MCP",
      "Python",
      "TypeScript"
    ],
    "quotes": [
      {
        "text": "But how many agents do you know that can fix code at runtime?",
        "at": "00:38",
        "url": "https://www.youtube.com/watch?v=33Oct2hqGnk&t=38s"
      },
      {
        "text": "Do you want to give it back to your deployment to your engineering team and have a turnaround of two weeks and then come back? No.",
        "at": "10:30",
        "url": "https://www.youtube.com/watch?v=33Oct2hqGnk&t=630s"
      },
      {
        "text": "With great power also comes great responsibility even greater responsibility.",
        "at": "15:20",
        "url": "https://www.youtube.com/watch?v=33Oct2hqGnk&t=920s"
      },
      {
        "text": "And the Python version of strands wrote by itself the TypeScript version of Stand.",
        "at": "19:47",
        "url": "https://www.youtube.com/watch?v=33Oct2hqGnk&t=1187s"
      }
    ],
    "words": 4248
  },
  "summary_url": "/#33Oct2hqGnk",
  "transcript": {
    "html": "/transcripts/33Oct2hqGnk.html",
    "txt": "/transcripts/33Oct2hqGnk.txt",
    "vtt": "/transcripts/33Oct2hqGnk.vtt"
  }
}