<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Luis Alcaraz</title>
    <description>The latest articles on DEV Community by Luis Alcaraz (@luismalcaraz).</description>
    <link>https://dev.to/luismalcaraz</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4164217%2Fb6234ad0-2db2-4405-8363-e8e9c59bdeea.png</url>
      <title>DEV Community: Luis Alcaraz</title>
      <link>https://dev.to/luismalcaraz</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/luismalcaraz"/>
    <language>en</language>
    <item>
      <title>Building agent tools out of other agent tools</title>
      <dc:creator>Luis Alcaraz</dc:creator>
      <pubDate>Mon, 19 Oct 2026 20:18:29 +0000</pubDate>
      <link>https://dev.to/luismalcaraz/building-agent-tools-out-of-other-agent-tools-3pj7</link>
      <guid>https://dev.to/luismalcaraz/building-agent-tools-out-of-other-agent-tools-3pj7</guid>
      <description>&lt;p&gt;Once an agent has a few good tools saved, the next one it builds usually needs pieces of the ones it already has. TAP now supports that directly. A primitive can declare other primitives as dependencies and call them from its own code.&lt;/p&gt;

&lt;p&gt;I work on TAP at Telara. It's an MIT-licensed runtime that lets agents save repeated procedures as small programs with defined inputs and outputs, and developers write and maintain the same packages. This post walks through how composition works using an example from the repo.&lt;/p&gt;

&lt;h2&gt;
  
  
  The example
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://github.com/Telara-Labs/TAP-Runtime/tree/v0.2.31/examples/release-check" rel="noopener noreferrer"&gt;release-check&lt;/a&gt; has a parent and two children. &lt;code&gt;api-release-brief&lt;/code&gt; collects public GitHub release and check-run data. &lt;code&gt;task-summary-python&lt;/code&gt; reads a local task file and returns the open tasks.&lt;/p&gt;

&lt;p&gt;The parent's manifest lists both children under &lt;code&gt;uses&lt;/code&gt;. Each entry has an alias, a primitive reference, a version, an execution digest and an effect. Here is the call from the parent's Python entrypoint.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;brief&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tasks&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;tap&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run_many&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;release_brief&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;owner&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;payload&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;owner&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;repo&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;payload&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;repo&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ref&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;payload&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ref&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]}),&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;open_tasks&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;status&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;open&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}),&lt;/span&gt;
&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Both children run at once and the parent combines what comes back. If a child fails, the parent gets an error for that child and reports it as a failure.&lt;/p&gt;

&lt;p&gt;You can read the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/blob/v0.2.31/examples/release-check/primitive.yaml" rel="noopener noreferrer"&gt;manifest&lt;/a&gt;, the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/blob/v0.2.31/examples/release-check/main.py" rel="noopener noreferrer"&gt;program&lt;/a&gt; and the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/blob/v0.2.31/examples/release-check/README.md" rel="noopener noreferrer"&gt;setup notes&lt;/a&gt;. Setup saves the two children first and then runs the parent. Changing a child means saving a new version and updating its pin.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who holds the access
&lt;/h2&gt;

&lt;p&gt;The parent manifest has no GitHub origin and no task file path in it. The GitHub child declares its own network access and the task child declares its own file access. Each one runs with its own manifest, bindings, approvals and journal.&lt;/p&gt;

&lt;p&gt;So the parent gets results and the children keep their permissions. The runner also rejects a parent whose declared effect is lower than one of its children. Missing pins, cycles and trees deeper than the limit get rejected too.&lt;/p&gt;

&lt;p&gt;The tree shares one deadline and one &lt;code&gt;max_dispatches&lt;/code&gt; budget. Approval prompts show the path from parent to child, so you know which piece is asking. If a run gets interrupted, resuming replays the children that finished and picks up the one that was in progress. A change whose outcome is unknown gets left for a person to check.&lt;/p&gt;

&lt;h2&gt;
  
  
  Partial results
&lt;/h2&gt;

&lt;p&gt;Stacking tools means every layer has to pass along what it couldn't see. The GitHub child keeps unavailable evidence apart from the data it did return. On a successful check-run read it includes the API total, the returned count, the sampled count and truncation flags.&lt;/p&gt;

&lt;p&gt;That lets the parent tell an empty list apart from a failed read. Concluding that a specific required check is missing takes more work. You'd need an expected-check list and full coverage of the places those checks live, and that part is yours to add. Network errors and malformed responses currently fail the whole run.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reviewing a dependency change
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;tap manifest complete&lt;/code&gt; fills in the version, digest and effect from an installed primitive when you've only written the alias and reference. If the reference matches more than one package, it stops and lists the candidates.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;tap diff&lt;/code&gt; shows children added, removed or re-pinned, plus changes to the interface, access and entrypoint. Treat a re-pin like any other dependency bump and run your own checks before you accept it.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/blob/v0.2.31/docs/writing-a-primitive.md" rel="noopener noreferrer"&gt;authoring guide&lt;/a&gt; covers the composition SDK for each supported language. There are examples for Bash, Python, JavaScript, TypeScript, Go, C++ and Rust. The compiled ones need the toolchain steps described in the guide.&lt;/p&gt;

&lt;h2&gt;
  
  
  Also new
&lt;/h2&gt;

&lt;p&gt;The runner has a browser interface that maps navigate, read and act calls onto the browser your client provides. A package can keep its page checks and steps in one place and run against Claude in Chrome, the Codex browser or Playwright.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;tap kit export&lt;/code&gt; writes a Docker Sandbox Kit config whose network allow list comes from the fetch origins your packages and their children declare. Signed packages can be checked against publisher keys you trust, and the signature is tied to the execution digest.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; @telaralabs/tap
tap setup
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Start with the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/tree/v0.2.31/examples/release-check" rel="noopener noreferrer"&gt;composition example&lt;/a&gt; and read both child manifests before you grant fetch access. Composition runs in Claude Code and Codex CLI, and the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/blob/v0.2.31/README.md#where-it-runs" rel="noopener noreferrer"&gt;README&lt;/a&gt; covers the other clients.&lt;/p&gt;

&lt;p&gt;You can use TAP without a Telara account. I'm curious what you'd want a child tool to report back so its parent can handle a partial answer.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;I work on TAP at &lt;a href="https://telara.dev/" rel="noopener noreferrer"&gt;Telara&lt;/a&gt;. This article was drafted with AI assistance.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>opensource</category>
      <category>tools</category>
    </item>
    <item>
      <title>Introducing TAP: software building blocks for the agentic world</title>
      <dc:creator>Luis Alcaraz</dc:creator>
      <pubDate>Wed, 07 Oct 2026 03:05:38 +0000</pubDate>
      <link>https://dev.to/luismalcaraz/introducing-tap-software-building-blocks-for-the-agentic-world-3m4c</link>
      <guid>https://dev.to/luismalcaraz/introducing-tap-software-building-blocks-for-the-agentic-world-3m4c</guid>
      <description>&lt;p&gt;We've open sourced TAP (Trusted Agent Primitives) at Telara so agents can build reusable internal tools for the work they do repeatedly. The packages are code that developers can write, inspect and maintain too.&lt;/p&gt;

&lt;p&gt;Employees ask agents to investigate issues, prepare customer reviews and check releases across CRM, ticketing, source control and billing systems. Executives we've spoken with describe those requests recurring across their organizations. A different account or project often means different inputs to the same procedure.&lt;/p&gt;

&lt;p&gt;Once an agent has worked out a procedure, it should be able to put the repeatable parts in code and use them again. The agent can spend its reasoning on the decisions the task needs.&lt;/p&gt;

&lt;h2&gt;
  
  
  A procedure you could package
&lt;/h2&gt;

&lt;p&gt;A release-readiness primitive could take a repository, a candidate commit and release requirements. It collects changes since the last release, follows references to work items, retrieves CI results and checks required reviews. Its code handles pagination and matches records to the right commits and issues.&lt;/p&gt;

&lt;p&gt;The output is the checks that passed, anything missing, and links to the evidence. The next release supplies new inputs. The agent uses the report to decide what needs attention.&lt;/p&gt;

&lt;p&gt;This is an example of a primitive you could write. Its interface would need to make the inputs and the returned evidence clear:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Input&lt;/th&gt;
&lt;th&gt;What the procedure returns&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Repository and candidate commit&lt;/td&gt;
&lt;td&gt;Changes and work items associated with that candidate&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Required checks and reviews&lt;/td&gt;
&lt;td&gt;Passed checks, missing checks and evidence links&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Previous release&lt;/td&gt;
&lt;td&gt;The range used to collect changes&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The same release requirements can apply to the next candidate. A smaller block that resolves changes to work items could also be useful in an incident investigation. That's the engineering idea behind primitives: build something useful once, give it a clear interface, and make it available to other people and their agents.&lt;/p&gt;

&lt;h2&gt;
  
  
  The execution interface
&lt;/h2&gt;

&lt;p&gt;A runnable TAP package has a &lt;code&gt;primitive.yaml&lt;/code&gt; and a source entrypoint: Bash, Python, JavaScript or TypeScript. The manifest declares what the program needs. The agent loads the primitive's interface and invokes it through &lt;code&gt;tap_run&lt;/code&gt;; the code returns its result or a failure the agent can act on.&lt;/p&gt;

&lt;p&gt;Packages use the host's existing tool connections. They don't contain the credentials for those tools, and declaring a requirement doesn't grant permission.&lt;/p&gt;

&lt;p&gt;TAP Runtime runs supported entrypoints through WebAssembly interpreters. Tool, command, file and network requests go through the runner and are checked against package declarations. Changes need approval through supported client paths; command-line changes are refused by default unless explicitly authorized.&lt;/p&gt;

&lt;p&gt;Claude Code and Codex provide the best-supported connected-tool experience today. Registration and execution are different capabilities; other clients range from experimental to preview, as the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime#where-it-runs" rel="noopener noreferrer"&gt;compatibility table&lt;/a&gt; shows.&lt;/p&gt;

&lt;p&gt;For a concrete look at the runtime interface, the repository's &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/tree/v0.1.20/examples/fan-out" rel="noopener noreferrer"&gt;fan-out example&lt;/a&gt; uses a connected mail-search tool, sends four searches together with &lt;code&gt;tap.call_many&lt;/code&gt;, and reports first-page counts for each time window. Its manifest declares the tools it may call and marks them read-only. It's deliberately small; the larger release-review procedure above is something you could build from reusable parts.&lt;/p&gt;

&lt;p&gt;The code can keep intermediate records between calls, use one response to choose the next request, and handle ordinary branches. The agent receives the assembled result. A primitive's design can also include a specific reasoning decision with defined inputs and outputs; the repeatable execution around it stays in code.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it on your own work
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; @telaralabs/tap
tap setup
tap discover
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;tap discover&lt;/code&gt; reads supported agent histories on your machine and proposes primitives from repeated work. It sends no history off the machine. Review the code, its assumptions and failure cases before using a proposal.&lt;/p&gt;

&lt;p&gt;Start with the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime#install" rel="noopener noreferrer"&gt;installation guide&lt;/a&gt;, &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/blob/main/docs/writing-a-primitive.md" rel="noopener noreferrer"&gt;authoring guide&lt;/a&gt; and &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/tree/main/examples" rel="noopener noreferrer"&gt;bundled examples&lt;/a&gt;. The runtime is MIT licensed and works without a Telara account, service or registry.&lt;/p&gt;

&lt;p&gt;At &lt;a href="https://telara.dev/" rel="noopener noreferrer"&gt;Telara&lt;/a&gt;, we're also working on how these tools become useful across a company. Telara is the enterprise AI operating layer: it connects AI clients to entitled company context and applies identity, scope and policy to the work it mediates. We're extending it with verification, versioning, admin approval and distribution for primitives. A colleague's agent should be able to reuse useful code under that colleague's company permissions.&lt;/p&gt;

&lt;p&gt;I'd like feedback on which procedures you'd package, what the inputs and outputs should be, and what makes a tool worth sharing with another person's agent.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;I work on TAP at Telara. This post was drafted with AI assistance.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>opensource</category>
      <category>ai</category>
      <category>mcp</category>
      <category>showdev</category>
    </item>
    <item>
      <title>What we're building for TAP on Telara</title>
      <dc:creator>Luis Alcaraz</dc:creator>
      <pubDate>Tue, 06 Oct 2026 22:32:29 +0000</pubDate>
      <link>https://dev.to/luismalcaraz/what-were-building-for-tap-on-telara-15c1</link>
      <guid>https://dev.to/luismalcaraz/what-were-building-for-tap-on-telara-15c1</guid>
      <description>&lt;p&gt;We've open sourced TAP at Telara so agents can build reusable internal tools. A primitive puts useful execution behind defined inputs, outputs and required access. Engineers can review, change or author that code as they would other internal tooling.&lt;/p&gt;

&lt;p&gt;Within a company, reuse raises some familiar engineering questions. Which version did we review? What assumptions does it make about the systems it calls? What happens if it gets only half the records? What may this particular caller do?&lt;/p&gt;

&lt;h2&gt;
  
  
  What a shared tool needs to return
&lt;/h2&gt;

&lt;p&gt;Consider a customer-review primitive that resolves an account across CRM, support and billing, collects the records for a date range, and calculates agreed measures. These are steps you could package. The agent can then interpret the returned data and prepare the review.&lt;/p&gt;

&lt;p&gt;For another team to reuse that procedure, its interface needs to preserve the details that made the result trustworthy:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The account and date range supplied as inputs.&lt;/li&gt;
&lt;li&gt;The source records behind each calculation.&lt;/li&gt;
&lt;li&gt;Missing data, unmatched identifiers and failed calls.&lt;/li&gt;
&lt;li&gt;The systems and actions required to collect the data.&lt;/li&gt;
&lt;li&gt;The version of the procedure that produced the result.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;An empty page, a denied request and an account with no support incidents mean different things. A useful tool should keep those distinctions in its output so the agent can decide what to do next. We want those expectations to become part of how a primitive is reviewed and maintained.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reviewing a version and authorizing a call
&lt;/h2&gt;

&lt;p&gt;A reviewed package still runs on behalf of a particular person or service. A colleague using the same code may be entitled to a different set of accounts. Required access belongs in the package declaration; the host and company policy determine whether the caller has it.&lt;/p&gt;

&lt;p&gt;The review of a procedure for shared use and the approval of a change during execution are separate decisions. A company might approve a version for its teams while still requiring someone to approve a billing change requested by that version. The package's declared requirements do not grant new authority.&lt;/p&gt;

&lt;p&gt;TAP uses the coding agent's existing tool connections. Claude Code and Codex have the best-supported connected-tool paths; other client paths have different limits in the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime#where-it-runs" rel="noopener noreferrer"&gt;compatibility table&lt;/a&gt;. The standalone runtime is MIT licensed and requires no Telara account, service or registry.&lt;/p&gt;

&lt;h2&gt;
  
  
  What we're building for TAP on Telara
&lt;/h2&gt;

&lt;p&gt;Telara is the enterprise AI operating layer. AI clients connected through Telara can receive the company context they're entitled to use, with identity, scope and policy applied to the actions Telara mediates. Those actions can run autonomously, require approval or be blocked. The company retains the resulting work and decision record, including tool calls, approvals, outcomes and attribution.&lt;/p&gt;

&lt;p&gt;We're extending that platform with verification, versioning, admin approval and distribution for TAP primitives. We want useful code created by one person's agent to become something colleagues' clients can reuse under company policy.&lt;/p&gt;

&lt;p&gt;Models, tools and schemas will change. Reusable blocks give engineers and agents code they can inspect, test and update, along with a record of how it was used. A change to one part of a procedure should be something the team can review without rebuilding all of its tooling.&lt;/p&gt;

&lt;p&gt;I work on TAP at &lt;a href="https://telara.dev/" rel="noopener noreferrer"&gt;Telara&lt;/a&gt;. If you support agents across shared company systems, I'd like to hear what you'd require before sharing an agent-written tool with another team, particularly how you'd review its version, authority and failure behavior.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/Telara-Labs/TAP-Runtime" rel="noopener noreferrer"&gt;TAP source and authoring guide&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;This post was drafted with AI assistance.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>Introducing TAP: software building blocks for the agentic world</title>
      <dc:creator>Luis Alcaraz</dc:creator>
      <pubDate>Tue, 06 Oct 2026 22:31:55 +0000</pubDate>
      <link>https://dev.to/luismalcaraz/introducing-tap-software-building-blocks-for-the-agentic-world-315h</link>
      <guid>https://dev.to/luismalcaraz/introducing-tap-software-building-blocks-for-the-agentic-world-315h</guid>
      <description>&lt;p&gt;We've open sourced TAP (Trusted Agent Primitives) at Telara so agents can build reusable internal tools for the work they do repeatedly. The packages are code that developers can write, inspect and maintain too.&lt;/p&gt;

&lt;p&gt;Employees ask agents to investigate issues, prepare customer reviews and check releases across CRM, ticketing, source control and billing systems. Executives we've spoken with describe those requests recurring across their organizations. A different account or project often means different inputs to the same procedure.&lt;/p&gt;

&lt;p&gt;Once an agent has worked out a procedure, it should be able to put the repeatable parts in code and use them again. The agent can spend its reasoning on the decisions the task needs.&lt;/p&gt;

&lt;h2&gt;
  
  
  A procedure you could package
&lt;/h2&gt;

&lt;p&gt;A release-readiness primitive could take a repository, a candidate commit and release requirements. It collects changes since the last release, follows references to work items, retrieves CI results and checks required reviews. Its code handles pagination and matches records to the right commits and issues.&lt;/p&gt;

&lt;p&gt;The output is the checks that passed, anything missing, and links to the evidence. The next release supplies new inputs. The agent uses the report to decide what needs attention.&lt;/p&gt;

&lt;p&gt;This is an example of a primitive you could write. Its interface would need to make the inputs and the returned evidence clear:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Input&lt;/th&gt;
&lt;th&gt;What the procedure returns&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Repository and candidate commit&lt;/td&gt;
&lt;td&gt;Changes and work items associated with that candidate&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Required checks and reviews&lt;/td&gt;
&lt;td&gt;Passed checks, missing checks and evidence links&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Previous release&lt;/td&gt;
&lt;td&gt;The range used to collect changes&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The same release requirements can apply to the next candidate. A smaller block that resolves changes to work items could also be useful in an incident investigation. That's the engineering idea behind primitives: build something useful once, give it a clear interface, and make it available to other people and their agents.&lt;/p&gt;

&lt;h2&gt;
  
  
  The execution interface
&lt;/h2&gt;

&lt;p&gt;A runnable TAP package has a &lt;code&gt;primitive.yaml&lt;/code&gt; and a source entrypoint: Bash, Python, JavaScript or TypeScript. The manifest declares what the program needs. The agent loads the primitive's interface and invokes it through &lt;code&gt;tap_run&lt;/code&gt;; the code returns its result or a failure the agent can act on.&lt;/p&gt;

&lt;p&gt;Packages use the host's existing tool connections. They don't contain the credentials for those tools, and declaring a requirement doesn't grant permission.&lt;/p&gt;

&lt;p&gt;TAP Runtime runs supported entrypoints through WebAssembly interpreters. Tool, command, file and network requests go through the runner and are checked against package declarations. Changes need approval through supported client paths; command-line changes are refused by default unless explicitly authorized.&lt;/p&gt;

&lt;p&gt;Claude Code and Codex provide the best-supported connected-tool experience today. Registration and execution are different capabilities; other clients range from experimental to preview, as the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime#where-it-runs" rel="noopener noreferrer"&gt;compatibility table&lt;/a&gt; shows.&lt;/p&gt;

&lt;p&gt;For a concrete look at the runtime interface, the repository's &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/tree/v0.1.20/examples/fan-out" rel="noopener noreferrer"&gt;fan-out example&lt;/a&gt; uses a connected mail-search tool, sends four searches together with &lt;code&gt;tap.call_many&lt;/code&gt;, and reports first-page counts for each time window. Its manifest declares the tools it may call and marks them read-only. It's deliberately small; the larger release-review procedure above is something you could build from reusable parts.&lt;/p&gt;

&lt;p&gt;The code can keep intermediate records between calls, use one response to choose the next request, and handle ordinary branches. The agent receives the assembled result. A primitive's design can also include a specific reasoning decision with defined inputs and outputs; the repeatable execution around it stays in code.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it on your own work
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; @telaralabs/tap
tap setup
tap discover
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;tap discover&lt;/code&gt; reads supported agent histories on your machine and proposes primitives from repeated work. It sends no history off the machine. Review the code, its assumptions and failure cases before using a proposal.&lt;/p&gt;

&lt;p&gt;Start with the &lt;a href="https://github.com/Telara-Labs/TAP-Runtime#install" rel="noopener noreferrer"&gt;installation guide&lt;/a&gt;, &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/blob/main/docs/writing-a-primitive.md" rel="noopener noreferrer"&gt;authoring guide&lt;/a&gt; and &lt;a href="https://github.com/Telara-Labs/TAP-Runtime/tree/main/examples" rel="noopener noreferrer"&gt;bundled examples&lt;/a&gt;. The runtime is MIT licensed and works without a Telara account, service or registry.&lt;/p&gt;

&lt;p&gt;At &lt;a href="https://telara.dev/" rel="noopener noreferrer"&gt;Telara&lt;/a&gt;, we're also working on how these tools become useful across a company. Telara is the enterprise AI operating layer: it connects AI clients to entitled company context and applies identity, scope and policy to the work it mediates. We're extending it with verification, versioning, admin approval and distribution for primitives. A colleague's agent should be able to reuse useful code under that colleague's company permissions.&lt;/p&gt;

&lt;p&gt;I'd like feedback on which procedures you'd package, what the inputs and outputs should be, and what makes a tool worth sharing with another person's agent.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;I work on TAP at Telara. This post was drafted with AI assistance.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>opensource</category>
      <category>ai</category>
      <category>mcp</category>
      <category>showdev</category>
    </item>
  </channel>
</rss>
