brianletort.ai
All issues

Agent Techniques Weekly

Issue 18 · Week 34 of 2026.

/From Chat to Cowork to Build to Automate/Public sources only

Big Read

Anthropic promoted skills and computer use to GA and gave the agent a way to load them progressively — this week's technique change is that skills are versioned artifacts, not prompts, and the sandbox runs them under the caller's identity

The most consequential agent event this week is Anthropic promoting its Skills API, Files API and computer use to general availability on August 20, and the specific shape of the release is what changes how enterprise agents get built. Skills are now versioned artifacts — a signed folder of instructions, tools and reference material with a stable id and semantic version — loaded through an API that supports progressive disclosure: an agent sees a skill's metadata first and only loads the full body into its context when the metadata matches the task. Files API graduates with 5x higher rate limits and 1TB per organization. Computer use ships with HIPAA/BAA availability, a browser use tool that reads page structure rather than pixels, and multi-action turns that let one model call resolve several UI actions before the loop returns. The interesting sentence in the release notes is not any of the numbers. It is the sandbox story. Skills execute inside Anthropic's hosted environment, and — when a skill calls out to a downstream system through MCP or a similar connector — the outbound identity is inherited from the caller invoking the skill, not from a lab-owned service principal. That is the same identity-inheritance pattern the Application Layer is documenting this week from Salesforce, UiPath and Ant. The lab-side and platform-side versions of the pattern converged in the same week without coordination, and buyers who deployed a lab-owned service account model for their pilots are now the exception rather than the pattern. The technique this week's Agent Techniques Weekly is naming is the combination: versioned skills plus progressive disclosure in a hosted sandbox, with inherited identity across the agent boundary. What it lets an enterprise do differently is upload internal SOPs — an incident-response runbook, an accounts-payable close, a customer-onboarding checklist — as versioned skills, and let the agent load the right one only when the caller's request matches the skill's metadata. Progressive disclosure keeps context windows from being blown out by loading every skill upfront, and versioning means a skill update is a diff instead of a prompt rewrite. Anthropic quotes a customer workflow moving from 32 minutes to 13 minutes with a roughly 30% cost drop and 100% completion. That quote is vendor-relayed, has no disclosed methodology or independent baseline, and this publication scores it as vendor_reported with a hype_signal caveat — the direction is plausible, the magnitude is unverified, and the substitute is to measure your own SOP-execution time before and after. One protein-design use is worth carrying because it comes with an independent-adjacent citation. Public reporting attributed to eWeek and Anthropic's own release describes a computer-use deployment at Chai Discovery, a protein design lab, driving external tooling to iterate on molecule candidates. This publication is recording it as customer_case_study with the caveat that the outcome measure is still vendor-relayed. It is the strongest evidence weight so far for the computer-use tool in a scientific context, and it is still not an independently measured result — the direction is the finding, not the number. The honest caveat on all of this is that the study bar this publication set in W33 has not been cleared. Anthropic's approval-catch rate finding remains the strongest-methodology piece of evidence in the beat, and it is a vendor study. No independent lab has published a replication of a headline agent effectiveness claim this week either. Enterprises adopting Skills API and computer use should treat the vendor's own numbers as reasons to instrument their own — the technique this week gives you a cheap way to do it, which is the useful thing.

Technique of the Week

build/Anthropic Skills API GA announcement and release notes

Versioned skills with progressive disclosure in a hosted sandbox under inherited identity

Publish enterprise SOPs as versioned skill artifacts (signed folder, stable id, semver), let the agent see each skill's metadata first and load the full body only when the metadata matches the task, execute the skill in a lab-hosted sandbox, and have the sandbox authenticate outbound tool calls under the caller's identity rather than under a shared service principal. The change is structural: skills stop being prompts you paste into a system message and start being deployable units that carry their own permissions, tests, and change log.

This is the first agent extensibility pattern that lets an enterprise reason about a skill the way it reasons about a package — with a version, a compatibility guarantee, and an inherited identity — rather than as prompt text a developer copies into a file. Engineering and CoE leaders should stop treating agent knowledge as a prompt store and start treating it as a versioned artifact registry that governance can audit against a service catalog, because the hosted sandbox and identity inheritance are the parts that make it enterprise-viable in one release. Anthropic customers get this immediately; every other vendor is either shipping it or being asked when they will.

Author the skill as a versioned artifact rather than as prompt text

A skill is a folder: a metadata file with a stable id and semver, a body containing instructions and tool interfaces, and any reference material the skill needs. Give each skill a machine-testable acceptance criterion so a version bump is a diff you can regression-test rather than a prompt tweak you take on faith. This is the shift most teams will feel first, because it converts an implicit ownership question into an explicit one: someone owns the skill, someone reviews changes to it, and the diff is auditable.

Register the skill in the lab's Skills API

Upload the skill artifact through the API rather than pasting it into a system message. This puts the skill under a hosted identity plane, gives it a stable name the agent can resolve to, and lets it be shared across projects without becoming prompt drift. Skills API also handles the 1TB/org file surface the Files API graduation opened up, so reference material that used to live in an ad-hoc bucket now lives with the skill it belongs to.

Load progressively: metadata first, body on match

The agent sees each registered skill's metadata (name, purpose, inputs) before it sees the body. Only when the metadata matches the task does the runtime load the full skill into the working context. This is the practical fix for context-window blowouts on organizations with dozens or hundreds of skills — instead of paying token cost for every SOP on every call, the agent pays token cost only for the SOPs that match. The rule to design against is that metadata must be precise enough for the match to be reliable.

Execute inside the hosted sandbox with computer use and file access as first-class primitives

Skills run in Anthropic's sandbox with computer use and Files API available inside the same execution boundary. Browser use reads page structure rather than pixels, which is materially more reliable than earlier screenshot-based agents. Multi-action turns let a single model call resolve several UI actions before the loop returns, which cuts the round-trip count on long UI sequences. Enterprises should still add their own outbound tool allowlist and log the sandbox's actions to their SIEM — the lab providing an execution boundary does not remove the enterprise's own audit obligation.

Inherit identity across the agent boundary

The sandbox authenticates outbound calls (MCP, HTTP, tool integrations) as the calling user rather than as a shared service principal. That means the skill runs under whatever entitlements the caller already has in the downstream system, and the downstream audit trail shows a real user action rather than an anonymous service account. Buyers should require this pattern in vendor contracts and treat lab-owned service accounts as an exception with a written justification.

Instrument the skill's real-world cost and completion baseline

For each SOP you move to a versioned skill, measure the manual baseline — time per completion, error rate, cost — before enabling the skill in production. Then measure the same numbers with the skill on. The purpose is not to reproduce the vendor's 32-to-13 quote; it is to have your own number, on your own workflows, that you can defend in a business case and re-run when the model, the skill or the price changes. This is the honest form of a proof-of-value in a category where vendor telemetry is not verifiable.

New Agent Capabilities.

Anthropic / build

Skills API, Files API, computer use (all GA)

Versioned skill artifacts with progressive metadata-then-body loading, Files API with 5x higher rate limits and 1TB per organization, computer use with a page-structure browser tool, multi-action turns, and HIPAA/BAA availability for regulated workloads

The most complete agent extensibility surface any frontier lab has shipped this year, and the first that treats skills as artifacts rather than prompts. Engineering and platform leaders should replan their SOP-as-prompt strategy this quarter: skills that live in a registry with versioning, testing and inherited identity are qualitatively different assets than prompt text a developer maintains by hand. The HIPAA/BAA availability is what opens computer use for regulated workloads that were previously off-limits and warrants a specific compliance-review pass, not a general 'now compliant' acceptance.

Microsoft / build

Foundry Skills + Files integration

Skills API and Files API surfaced inside Microsoft Foundry as first-class extensibility primitives per Anthropic's own release notes

Microsoft is choosing to be the enterprise identity plane for Anthropic's skill and file surfaces rather than build a parallel one, which is a meaningful strategic answer to the identity-inheritance question. Platform teams building agents inside Microsoft 365 tenants should design their skill registry against Foundry rather than against a lab-native identity, because the entitlements customers already run on live in Entra rather than in the lab. This does not remove Microsoft's own governance obligations — check that skill promotion into Foundry follows the same approval process as any other application registration.

Google / cowork

Vertex AI computer use

Computer use rolling out on Vertex AI per the same-week Anthropic release cadence, positioned for Gemini Enterprise identity-inherited agent workflows

Google is following Anthropic's product shape rather than fielding a distinct one, which converts computer use from a differentiator into a table-stakes capability across the two US frontier labs. Enterprise architects on Vertex should compare the pair on execution latency, identity-plane fit and audit surface rather than on capability alone. Expect an equivalent Skills registry on Vertex within the quarter, because a computer-use surface without a versioned skill registry is materially less useful than one with it.

Salesforce / automate

Headless 360 identity-inherited MCP skills

Data Cloud, Agentforce, MuleSoft and Tableau exposed as MCP servers, skills and orchestrators with agents inheriting the caller's user identity, entitlements, and audit trail

The platform-side version of the same identity-inheritance pattern Anthropic shipped on the lab side, arrived in the same week, and converged on the same architectural choice. Buyers running agents against Salesforce data should require Headless-style MCP identity inheritance rather than service-account credentials. Vertical-AI vendors touching Salesforce accounts should design integrations that assume the caller's user is the authenticated identity — an integration that requires a separate service account is now a design smell rather than a routine choice.

OpenAI / cowork

GPT-5.6 Sol at reduced token price for the promotional window

Flagship reasoning model available at more than 20% lower token pricing for a dated three-month promotional window, with the reversal date published at launch

Agent workload economics tilt in the buyer's favour for the promo window and revert on the published date. Teams running long-horizon agents on Sol should model post-promo pricing into any business case whose payback crosses November, and treat the promo period as a testing window for measured turn efficiency rather than as the durable rate. See the Model Pulse for full architecture read.

New Skills And Connectors.

skill / Anthropic Skills API

Skills API 1.0 (GA)

Versioned skill artifacts, progressive metadata-then-body loading, and sandbox execution under inherited identity all GA in one release

The first agent extensibility format that treats skills as versioned deployable units rather than prompt text. Platform teams should stand up a skill registry this quarter with change management, semver, and a testing pipeline for each skill — treating the skill artifact the way a package registry treats a package. Do not defer identity inheritance as a phase-two problem: the pattern is set by the vendor as the default in this release, and starting with service accounts creates a migration you will regret at the first audit.

connector / Anthropic Files API

Files API GA with 5x rate limits and 1TB/org

File storage graduated to GA with 5x higher rate limits and 1TB per organization, positioned as the reference material surface for versioned skills

The Files graduation matters less as a capacity story than as a placement story: reference material that belongs to a skill now lives beside the skill in a hosted store rather than in an ad-hoc bucket a team maintains separately. Data leaders should treat Files as a governed data surface — write a retention and redaction policy before uploading production reference material, and confirm the 1TB envelope is enough for the SOP corpus you plan to publish. Files quota is a soft constraint on how many skills a large enterprise can host at once.

connector / Salesforce Headless 360

Data 360 + Agentforce 360 MCP surfaces

Data Cloud, Agentforce, MuleSoft and Tableau exposed as MCP servers and callable skills to external agents with identity inheritance

The platform-side complement to Anthropic's skill surface. Enterprises running agents that touch Salesforce data should connect through Headless MCP rather than build a custom API integration, because the identity-inheritance is the part that would otherwise cost the security team the audit trail. Vertical-AI orchestrators selling into Salesforce accounts should assume Headless is the connector, not the competitor, and design accordingly.

Proof Of Value.

Evidence: hype_signal

Anthropic (customer-reported): Enterprise SOP execution moved from prompt-based to Skills API with progressive disclosure

A customer workflow reported to move from 32 minutes to 13 minutes per execution with a roughly 30% cost reduction and 100% completion rate, cited in Anthropic's Skills API GA announcement without disclosed methodology or independent baseline

Directionally consistent with what versioned skills plus progressive disclosure would produce — less token cost on irrelevant context, more reliable execution on the matched skill — and unverified in every quantifiable dimension. This publication is scoring the citation as hype_signal because no methodology, baseline definition or comparable workflow is disclosed, and because Anthropic has a direct commercial interest in the number. Treat it as a reason to measure your own SOP-execution time before and after, not as a number to cite in a business case.

Evidence: customer_case_study

Chai Discovery (protein design lab): Computer use driving external molecular design tooling for candidate iteration

Public reporting (eWeek plus Anthropic's own release) describes a protein-design workflow at Chai Discovery using computer use to iterate on molecule candidates through external tooling, with vendor-relayed outcome commentary rather than independently measured results

Strongest available signal on the computer-use surface reaching a scientific context. The citation is on-record and the workflow shape is specific, which puts it above launch-post rhetoric. The outcome commentary is still vendor-relayed, so this publication is scoring the evidence weight at customer_case_study rather than benchmark — the direction is a real finding, the magnitude is not. Teams evaluating computer use for scientific or high-precision workflows should treat this as a reason to run a pilot with their own baseline, not as an industry precedent to skip that step.

Evidence: vendor_claim

Salesforce (Headless 360 customers): External agents calling Salesforce data and workflow surfaces under caller identity

Salesforce positions Headless 360 as removing the need for parallel service-account patterns while preserving Data Cloud entitlement and audit surface, with customer-implied gains in security-review time and integration effort but no specific customer number cited in-window

Architectural claim rather than measured proof. The identity-inheritance model is credible on its own logic and consistent with the same pattern Anthropic shipped the following day. This publication is scoring the entry vendor_claim because Salesforce did not attach a customer number to the release; the value in the citation is confirming the platform-side architectural shape rather than measuring the gain. Buyers should measure their own integration effort against a service-account baseline before generalizing.

Enterprise Readiness.

  • permissioning

    Identity inheritance across the agent boundary is now the default pattern in both lab-side (Anthropic Skills sandbox) and platform-side (Salesforce Headless, UiPath Maestro) surfaces released this week. Require it in vendor contracts and treat lab-owned or vendor-owned service-account patterns as an exception carrying a written justification and a scheduled removal date. Where computer-use agents drive the browser as a user, credential pooling is still the observed default, so per-task scoped credentials must be established before any regulated pilot rather than deferred to production.

  • auditability

    Skills API and Files API both graduate with audit surfaces that record which skill loaded and which files it touched, which is a real improvement over pasting prompts into system messages. Enterprises should still forward classifier decisions, sandbox actions, and skill loads to their own SIEM rather than rely solely on the lab's audit view, because a lab-hosted audit is a shared responsibility and the retention windows and forensic access rules are the vendor's, not the enterprise's, without a specific contract term to that effect.

  • verification

    Skill versioning turns SOP evolution into a diff that can be regression-tested. Every promoted skill needs a machine-testable acceptance criterion and a rollback plan; the semver bump is the audit event, not the prompt change. For computer-use-driven agents, page-structure browsing is materially more reliable than pixel-based screenshotting, but multi-action turns compress several steps into one model call, so the completion checkpoint the agent cannot forge (test suite, type check, second-model diff review) is the safety net that matters when a single call resolves five UI actions.

  • human approval

    The 13.6%-versus-89% human-review-versus-classifier finding from W33 stands as the strongest measured evidence on approval effectiveness, and it is still vendor-run. Reserve human approval for the small number of irreversible actions that pass the classifier — payment, credential rotation, publishing, external communication — and stop routing reversible actions through humans, because the fatigue mechanism is a property of high volume rather than of the specific reviewer.

  • cost

    Progressive disclosure changes the token-cost model for large skill registries by loading only matched skills into context, which is the most consequential structural cost improvement in agentic tooling this year for organizations with dozens of SOPs. Combined with the OpenAI Sol promotional pricing for the next three months, agent unit economics are directionally down for the promo window and structurally lower for skill-heavy deployments. Model the post-promo GPT-5.6 Sol price in any November business case, and count on progressive disclosure as a durable saving that survives the reversal.

  • data access

    Files API with 5x rate limits and 1TB per organization moves reference material from an ad-hoc bucket into a governed surface, and the surface belongs to the lab. Data leaders should treat the Files store as a data domain that needs its own retention, redaction and classification policy before production upload — not as an incidental capability under the Skills API. The 1TB envelope is a soft constraint on how many skills a large enterprise can host at once and warrants a capacity plan alongside the skill registry.

Try This.

Upload one internal SOP as a versioned skill and measure the same task with and without it

  1. Pick one SOP your organization actually runs — an incident-response runbook, an accounts-payable close checklist, a customer-onboarding sequence — that has a clear input, a clear output, and a measurable manual baseline (time to completion, error rate, cost).
  2. Measure the manual baseline first. Run the SOP three to five times with a human executor, recording time, cost, and any deviation from the documented steps. Do not skip this — the vendor's 32-to-13 quote is not your baseline, and a post-hoc estimate will look indistinguishable from the launch-post figure.
  3. Author the SOP as a versioned skill artifact: metadata file with stable id and semver, body containing instructions and the tool interfaces the SOP calls, reference material co-located as files. Add a machine-testable acceptance criterion so version bumps have a regression check.
  4. Register the skill through Anthropic Skills API (or the equivalent surface on your primary agent platform) and confirm it loads under progressive disclosure — metadata visible without loading the body — and executes under inherited identity in the hosted sandbox, not a shared service principal.
  5. Run the same SOP three to five times through an agent that has the skill available. Record time, cost, error rate and any step where the agent deviated from the frozen path. Keep the human runs and the agent runs in a shared spreadsheet so the comparison is per-execution rather than an average of averages.
  6. Compare the two sets on each metric and write down what you found — including the direction, the magnitude, and any completion failures. This is the version of Anthropic's number that applies to your workflow, and it is what you cite when finance asks why the skill registry is worth building against next quarter.

Expected outcome: A defensible, environment-specific number for how much a versioned skill with progressive disclosure changes the time, cost and completion rate on a real SOP in your organization — and a repeatable pattern for authoring the next skill. Most teams running this will find that progressive disclosure is a durable cost saving and that inherited identity removes an audit conversation they were going to have anyway. The durable deliverable is the SOP-as-versioned-artifact template you keep using for the next several skills, not the specific numbers on the first one.

Watchlist.

  • Aug 22 - Sep 30

    Independent replication of the 32-to-13 minute customer workflow number

    The most-cited number in Anthropic's Skills API GA release is vendor-relayed with no methodology and no independent baseline. An academic or third-party replication — or a contradicting result — would either make this the anchor data point for enterprise agent ROI this quarter or expose it as a launch-post artifact. Until then, treat your own measurement as the authoritative one.

  • Aug 22 - Sep 15

    Google Vertex AI Skills-equivalent surface

    Google shipped computer use on Vertex in the same week without a matching Skills registry announcement. A versioned skill artifact on Vertex would make Vertex a plausible primary agent surface for enterprises on Workspace/Chrome-integrated identity; its absence would keep the enterprise agent registry conversation Anthropic-first for the rest of the quarter.

  • Sep - Oct

    Standard emergence for skill artifact provenance and signing

    Skill artifacts are a software supply chain surface with no published provenance or signing norms. Watch whether Anthropic, Microsoft or the OCP-equivalent for agent tooling publishes a signing spec inside the quarter — that is the point at which skill promotion into enterprise environments becomes governable against existing supply-chain policy rather than as ad-hoc configuration.

  • Sep 1

    Hardware security keys required for gated frontier model access

    The Daybreak requirement flagged in W33 lands, and Skills API plus computer use raise the stakes because the surfaces behind the identity gate are now more powerful. Agent teams should treat key provisioning as blocking for any Daybreak-tier skill promotion, not as a downstream compliance step. The Weekly carries the broader posture read.

  • Nov 21

    Sol dated promotional rate reverts

    The three-month reversal on the more-than-20% cut lands. Agent workload economics tied to Sol are exposed that Monday, and every contract signed against the promo rate needs a written contingency for the step-up. Full architecture read is in the Model Pulse.

  • Ongoing

    First independently measured production Skills API deployment with a named customer and stated baseline

    Nothing published this week cleared that bar. Skills API is the most complete agent extensibility surface any frontier lab has shipped, and it does not yet have a proof of value that meets this publication's evidence standard. The first named-customer, baseline-stated, independently reported deployment will move the beat from vendor-relayed to independently supported, and until it lands the honest summary of Skills-API ROI is that the direction is well supported and the magnitudes are not.