Tendril: A self-extending agent that builds and registers tools on the fly

Tendril is a self-extending agentic sandbox that demonstrates the Agent Capability pattern — the model discovers, builds, and reuses tools autonomously across sessions. Built with AWS Strands Agents SDK and Tauri.

How it works

You ask Tendril to do something. It checks its capability registry. If a tool exists, it uses it. If not, it writes one, registers it, and executes it — all without asking. Next time you need the same thing, the tool is already there.

You: "fetch the top stories from Hacker News"
Tendril: → searchCapabilities("fetch url hacker news") # nothing found
         → registerCapability(fetch_url, code) # builds a tool
         → execute("fetch_url", {url: "https://..."}) # runs it by name
         → "Here are the top stories: ..."

You: "now fetch Lobsters and compare"
Tendril: → listCapabilities() # found: fetch_url ✓
         → execute("fetch_url", {url: "https://lobste.rs"}) # runs it — no rebuild

The registry grows with use. Every session is smarter than the last.

Agent configuration

The core of Tendril is a Strands agent with just three bootstrap tools:

import { Agent } from '@strands-agents/sdk';
import { BedrockModel } from '@strands-agents/sdk/models/bedrock';

const agent = new Agent({
  model: new BedrockModel({ modelId: '...', region: '...' }),
  systemPrompt: TENDRIL_SYSTEM_PROMPT(workspacePath),
  printer: nullPrinter,
  tools: [
    listCapabilities(registry),
    registerCapability(registry),
    executeCode(registry, workspacePath, config),
  ],
});

System prompt rules

The system prompt enforces autonomous behavior:

• Call searchCapabilities(query) to check if a relevant tool exists
• If found: call loadTool(name) then execute(code, args)
• If NOT found: you MUST build the tool yourself
• NEVER ask "would you like me to create a tool?" — just build it
• If a tool fails, read the error, fix the code, and retry
• NEVER answer from training data when a tool could get live information

Architecture

┌─────────────────────────────────────────┐
│ Tauri Shell (Rust)                      │
│  ACP Host ──stdin/stdout──► Agent      │
│  (acp.rs)          NDJSON    (Node.js SEA)│
│  Events ◄── session/update ──┘          │
│  (events.rs)                            │
│  Tauri Events ──► React Frontend        │
│  (TailwindCSS v4)                       │
└─────────────────────────────────────────┘

Agent internals: Strands SDK ── BedrockModel ── Claude
│ 4 bootstrap tools
┌────┴────┐
│ Registry │ ←→ index.json + tools/*.ts
└─────────┘
┌────┴────┐
│ Sandbox │ ←→ Deno subprocess (sandboxed)

The agentic loop runs inside agent.stream() and bridges to the ACP protocol, exposing think, act, and observe phases to the UI.

The "too many tools" solution

Most agent frameworks give the model a big bag of tools and hope it picks the right one. Tendril inverts this — the model always sees exactly three tools. It searches a registry, builds what it needs, and the registry grows over time. The tool surface never changes; the capabilities do.