Agentworld · 2026-06-12

🤖 Agentworld — 2026-06-12

⚙️ Microsoft Open-Sources SkillOpt: Agent Skill.md Files Become Trainable Objects via Text-Space Optimization Loop
🔄 Anthropic RSI Report: Claude Mythos Preview Achieves 52x Code-Loop Speedup; Capability Constrained in Production
🌲 Claude Code v2.1.172 Ships 5-Level Nested Sub-Agents with Full OTEL Lineage Tracking per Agent Hop
🔐 Red Hat Publishes SPIFFE + AuthBridge + Kagenti Zero-Trust Identity Stack for Production AI Agents
🏛️ EIC 2026: Machine Identity Governance Maps onto NIS2, DORA, CRA, and eIDAS 2.0 as First-Class Compliance Infrastructure
📡 arXiv 2606.10662: DeLM Replaces Central Orchestrator with Parallel Agents and Shared Verified Context

---

⚙️ Microsoft Open-Sources SkillOpt: Agent Skill.md Files Become Trainable Objects via Text-Space Optimization Loop

Microsoft published SkillOpt on GitHub June 12 under an MIT license: an open-source framework that treats an agent's skill .md document as a trainable object, running a full optimization loop — rollout, reflect, aggregate, select, update, evaluate — to improve that text based on performance feedback rather than adjusting model weights. VentureBeat's coverage frames the move precisely: existing approaches hand-craft skills, generate them one-shot from a strong LLM, or allow loosely controlled self-revision — none of which behaves like an optimizer for the skill itself, and none of which reliably improves from a starting point under feedback.

The training loop is direct. An agent runs a task using the current skill file, produces a trajectory. SkillOpt reflects on that trajectory to identify failure modes. It aggregates multiple trajectories across a benchmark suite, selects improvements, updates the skill markdown, and evaluates the updated skill against the benchmark. The final artifact is a best_skill.md — the skill that produced the highest benchmark score after optimization. The skill then deploys identically to any other markdown skill file in the agent's configuration.

The backend support list reveals the strategic positioning: OpenAI, Azure, Claude, Qwen, and MiniMax are all supported out of the box, with six built-in benchmarks and a WebUI dashboard for tracking optimization runs. The multi-backend scope is deliberate — SkillOpt is not positioned as an Azure agent product but as infrastructure-layer tooling that works across providers. This mirrors the Microsoft Agent Platform's announced strategy of SAP, ServiceNow, and Workday partner integrations: Microsoft increasingly owns the orchestration and governance layer while remaining model-agnostic at the inference layer.

The structural significance is that SkillOpt converts the skill authoring problem from a prompt engineering task into an optimization task. An engineer no longer needs to iterate manually on skill instructions; the framework does it from trajectory data. This directly addresses one of the largest friction points in production agent deployment — the effort required to maintain skill quality as the tasks the agent is asked to perform evolve. Microsoft's Visual Studio blog simultaneously launched Agent Skills support in Visual Studio, where reusable instruction sets teach Copilot agents how to handle domain-specific workflows — the same "skills as SKILL.md" paradigm that SkillOpt now automates.

The MIT license and multi-backend support position SkillOpt as an attempt to set the skill-optimization standard before any competitor can. If SkillOpt becomes the de facto tool for agent skill management, Microsoft gains durable influence over how the entire agent ecosystem approaches capability improvement — regardless of which model or cloud provider agents run on.

Sources:

---

🔄 Anthropic RSI Report: Claude Mythos Preview Achieves 52x Code-Loop Speedup; Capability Constrained in Production

Anthropic's Institute published a recursive self-improvement (RSI) benchmark report June 12 documenting a 17x improvement in Claude's code-optimization loop performance between May 2025 and April 2026: Claude Opus 4 averaged a ~3x speedup over starting code; Claude Mythos Preview achieves ~52x. The benchmark is tightly scoped — a fixed optimization goal, a fixed evaluation metric, a loop that rewrites code, runs it, times it, and repeats — but the result is structurally significant: the model is operating as a research agent that autonomously improves its own outputs across multiple iterations with compounding gains.

The production version of Mythos does not ship with full RSI capability active. Futurism confirmed that Anthropic "lobotomized" the model's ability to self-improve after concluding the unconstrained capability represented an unacceptable risk profile. The Anthropic report itself states that AI systems have already "assumed a dominant role in developing their own successors" — Claude Mythos Preview was used extensively in the research loop that preceded its own training. This is not theoretical RSI; it is a disclosed feedback loop in an active frontier model development pipeline.

The agent architecture implications are direct. Claude Mythos Preview's 52x speedup was achieved in what Anthropic describes as "a miniature version of an experimental research loop" — an agent that perceives task performance, generates code modifications, tests them, and selects the best path forward. This is the same architectural pattern as production software engineering agents: perceive, act, evaluate, iterate. The difference is that Mythos was optimizing its own computational substrate rather than an external codebase. The distinction between "coding agent" and "self-improving agent" is narrower than the safety framing implies.

For the enterprise agent market, the RSI disclosure creates a precedent problem that governance frameworks have not yet addressed. Anthropic's report warns that the world may be approaching an RSI threshold faster than governments and institutions are prepared for. Enterprise procurement teams selecting agent infrastructure are now selecting systems that may, depending on the configuration, engage in self-modification loops during task execution. The question of whether an agent that optimizes its own skill files (via SkillOpt) constitutes a form of RSI is not addressed in current enterprise governance frameworks — it is the governance gap that KPMG's Agent 365 deployment and Microsoft's Foundry control plane have not yet closed.

Sources:

---

🌲 Claude Code v2.1.172 Ships 5-Level Nested Sub-Agents with Full OTEL Lineage Tracking per Agent Hop

Claude Code CHANGELOG v2.1.172, confirmed June 11, introduces recursive sub-agent spawning up to 5 levels deep — a sub-agent can now spawn sub-agents, which can spawn further sub-agents, building a tree structure that Claude Code tracks, displays, and cancels as a coordinated unit. Toolsbase confirmed the feature: "Sub-agents can now spawn their own sub-agents, nested up to 5 levels deep."

The architectural depth matters less than the observability infrastructure that preceded it. Claudefa.st's technical analysis maps the release history: v2.1.139 added x-claude-code-agent-id and x-claude-code-parent-agent-id headers to every API request an agent makes, plus agent_id and parent_agent_id attributes on OpenTelemetry claude_code.llm_request spans. v2.1.145 extended that lineage tracking to claude_code.tool spans and corrected trace parenting so a background sub-agent's spans nest correctly under the dispatching Agent tool span. v2.1.172 turned on the actual recursion — but only after two prior releases had built a complete identity and lineage tracking system that survives the recursion. "The identity and lineage tracking was laid down first. v2.1.172 just turned on the actual recursion."

This sequencing is instructive. Anthropic did not ship nested spawning and add observability later. The observability infrastructure was built first, then the capability was unlocked. Each agent in the tree carries its own identifier, knows its parent's identifier, and emits OTEL spans that correctly nest under the dispatching call. A 5-level-deep sub-agent tree is fully traceable in any OTEL-compatible backend. This is the governance-by-design approach: the control infrastructure is built before the dangerous capability ships.

The token economics of nested agents are non-trivial. Ofox.ai's analysis of the v2.1.172 release walks through the compounding context: each spawned sub-agent starts with fresh context but can inherit parent context explicitly; the 5-level limit is both a technical constraint and a cost control. At Mythos pricing ($50/M tokens), a 5-level agent tree processing substantial context at each node can accumulate costs quickly. The June 15 credit pool split — Agent SDK usage moving to a separate budget — is almost certainly downstream of exactly this pattern: production teams discovering that agentic API calls dramatically exceed interactive API call volumes.

Sources:

---

🔐 Red Hat Publishes SPIFFE + AuthBridge + Kagenti Zero-Trust Identity Stack for Production AI Agents

Red Hat published a technical reference architecture June 10 for zero-trust identity in production AI agent systems, combining three components: SPIFFE for service-to-service cryptographic workload identity via mTLS, AuthBridge implementing RFC 8693 token exchange to pass user delegation context as JWTs, and Kagenti for agent lifecycle management and policy binding. The combination addresses the specific failure mode that current MCP deployments exhibit: agents are authorized at connection time using ambient credentials rather than being issued scoped, expiring, revocable identities that reflect their actual permission set at the moment of each action.

SPIFFE (Secure Production Identity Framework for Everyone) solves the workload-to-workload authentication problem: each agent instance receives a cryptographic SVID (SPIFFE Verifiable Identity Document) at startup, tied to its workload class and deployment context. Agents authenticate to each other using mTLS with SVIDs rather than shared API keys or long-lived tokens. Red Hat AI's production deployment guide confirms that SPIFFE and SPIRE are used to "establish a zero-trust environment, providing workload identity and securing agent sandboxes." The SPIFFE layer handles machine-to-machine authentication but does not address user delegation — the question of which human principal authorized an agent to take a specific action.

AuthBridge solves the delegation chain problem. RFC 8693 (OAuth 2.0 Token Exchange) defines how tokens can be exchanged to establish delegation relationships: a user authorizes an orchestrator, the orchestrator exchanges the user token for a scoped agent token, the agent token carries the original user context as an act claim. Every downstream call the agent makes carries a JWT that names both the agent and the user on whose behalf it acts. This is the audit requirement that financial services compliance frameworks and NIS2 incident reporting require — not just "an agent made this call" but "this user authorized this agent which made this call."

Kagenti closes the lifecycle management gap: it handles agent registration, permission binding at creation time, policy enforcement during operation, and credential rotation and revocation. The combination means an enterprise can answer the audit question for every agent action — what credential, what delegation chain, what policy was in effect — without instrumenting individual agent code. The architecture is backend-agnostic and was designed against the GitHub agent-governance-toolkit OWASP Agentic Top 10 framework, suggesting convergence on a common identity security reference model across vendors.

Sources:

---

🏛️ EIC 2026: Machine Identity Governance Maps onto NIS2, DORA, CRA, and eIDAS 2.0 as First-Class Compliance Infrastructure

Corbado's post-conference analysis of EIC 2026 — the European Identity Conference, the primary identity industry event — documents the dominant theme: "Orchestrating Non-Human Identity" sessions treated machine identities and AI agent governance as a compliance infrastructure problem, mapping non-human identity (NHI) management requirements onto NIS2, DORA, CRA, GDPR, and eIDAS 2.0. This framing shift is consequential — it converts agent identity from a security engineering topic into a mandatory compliance framework requirement with regulatory timelines, audit obligations, and incident reporting duties.

The specific regulatory mappings are precise. NIS2 (EU network and information security directive, enforcement began October 2024) requires organizations to maintain inventories of critical systems and report significant incidents within 24-72 hours. An AI agent that takes an action causing a production incident now falls within NIS2's incident reporting scope — but only if the agent appears in the organization's asset inventory. Absent NHI management, agents that are not registered do not trigger NIS2 reporting obligations, creating a perverse incentive to leave agents unregistered. DORA (Digital Operational Resilience Act, financial sector) introduces testing requirements for operational resilience; agent failure modes and cascade risks are now within scope.

CRA (Cyber Resilience Act, product security requirements) applies to software products with digital elements — potentially including agent platforms and agent infrastructure. eIDAS 2.0 extends qualified electronic signatures and trusted identity infrastructure to machine actors under specific conditions, creating a pathway for agents to hold legally recognized credentials for signing transactions. The EIC 2026 consensus position on OAuth 2.1, MCP, and A2A convergence was explicit: agents need first-class identities, runtime authorization, and traceable delegation — "Laws of AIdentity" framing, establishing analogues to Kim Cameron's Laws of Identity for the agent era.

The business implication is a compliance-driven demand spike for NHI management platforms. Organizations that have deployed agents under informal authorization structures — ambient credentials, shared API keys, undocumented delegation chains — now face retroactive compliance remediation. The 2026 regulatory window is narrow: NIS2 is already in enforcement, DORA financial sector provisions took effect January 2025, and CRA conformity assessment requirements land in phases through 2027. The myitforum.substack analysis of agent sprawl identifies the core operational problem: "Agentic IAM — a purpose-built framework that recognizes AI agents as autonomous, delegating entities with their own identities, lifecycles, and risk profiles" — frameworks that currently exist as architectural proposals and are becoming procurement requirements.

Sources:

---

📡 arXiv 2606.10662: DeLM Replaces Central Orchestrator with Parallel Agents and Shared Verified Context

arXiv:2606.10662, submitted June 2026, proposes Decentralized Language Models (DeLM) as a multi-agent framework that eliminates the central orchestrator bottleneck by replacing it with three structural elements: parallel agents that operate concurrently without requiring sequential handoffs, a shared verified context that all agents read from and write to under consistency guarantees, and a task queue that distributes work without routing through a controller. The paper's core observation: as the number of subtasks grows in a centralized multi-agent system, the orchestrator becomes a communication and integration bottleneck — DeLM eliminates the bottleneck by eliminating the orchestrator.

The shared verified context is the architectural novelty. Decentralized multi-agent systems typically fail on consistency: two parallel agents read state, take incompatible actions, and produce conflicting writes. DeLM addresses this by treating the shared context as an append-only verified log — agents can read the full state, append their actions and results, and rely on a lightweight consensus mechanism to resolve concurrent writes. The verification step is the gating condition: before an agent's output enters the shared context, it is checked against constraints that can be defined per-task-type (syntax validation, schema conformance, value bounds). Invalid outputs are rejected without halting the parallel pipeline.

The experimental results show performance improvements where the orchestrator-as-bottleneck pattern is most pronounced: complex decomposed tasks with many independent subtasks where sequential orchestration produces throughput degradation proportional to subtask count. In centralized systems, 100 subtasks require 100 round-trips through the orchestrator; in DeLM, all 100 subtasks execute in parallel against the shared context, with verification gating entry rather than a controller bottleneck. A companion paper, arXiv:2606.05608, characterizes the same centralization failure mode as a structural property of the current agentic software paradigm — DeLM's contribution is one instantiation of the decentralization solution that paper identifies as necessary.

The production deployment relevance is direct. The task types where DeLM's architecture is most advantageous — large document processing, parallel data extraction, concurrent tool execution across multiple sources — are exactly the workloads enterprise agent deployments are scaling toward. Claude Code's v2.1.172 nested sub-agent capability creates a product-level analogue: multiple sub-agents running concurrently, each writing results back to a shared parent context. The difference is that Claude Code's shared context is a conversation thread, not a verified append-only log — DeLM's contribution is the consistency and verification layer that production deployments need when parallel agent outputs must combine into auditable downstream actions.

Sources:

---

Research Papers

Agentic Software: How AI Agents Are Restructuring the Software Paradigm — (June 2026) — Analyzes benchmark evidence including SWE-bench Verified, EvoClaw, and LangChain multi-agent coordination studies to characterize the structural shift from software as artifact to software as ongoing agent-mediated process; identifies the emergent property that agentic systems can outperform their constituent models on task completion by decomposing problems beyond single-context limits. Relevant to today's SkillOpt and nested sub-agent releases.

EurekAgent: Agent Environment Engineering is All You Need For Autonomous Scientific Discovery — Amy Xin et al. (June 2026) — Proposes that the primary bottleneck in autonomous scientific discovery agents is environment engineering (how the agent perceives and interacts with scientific tools) rather than reasoning capability; demonstrates that a well-structured agent environment enables frontier models to achieve discovery results that outperform dedicated scientific AI models. Direct implication for RSI: structured environments amplify agent capability multiplicatively.

So There's a Catch-22 Here: How Early Adopters Who Build Multi-Agent LLM Systems Navigate Accountability — (June 2026) — Qualitative study of early adopters building production multi-agent systems; identifies the "Catch-22" that accountability frameworks require traceable delegation chains, but defining delegation chains requires anticipating agent actions in advance — exactly the anticipation that makes human-in-the-loop redundant. The paper's findings about under-defined responsibility in distributed architectures are the practitioner-facing complement to the EIC 2026 regulatory mapping.

---

Implications

Three structurally related developments from today converge on a single inflection: the agent ecosystem is simultaneously acquiring the capability to self-improve and the infrastructure to track, audit, and constrain that self-improvement. Whether the infrastructure is sufficient is the open question.

Microsoft's SkillOpt and Anthropic's RSI report sit on opposite ends of the same spectrum. SkillOpt applies trajectory-driven optimization to agent skill markdown files — a text-space optimizer that converges on better-performing skills without touching model weights. Anthropic's RSI research applies the same logic to model training itself, achieving a 52x speedup through a loop that rewrites and benchmarks its own code. The gap between these is narrower than it appears: SkillOpt is RSI for skills; Anthropic's research loop is RSI for models. Both are feedback loops that improve capability through performance-driven iteration. SkillOpt ships under an MIT license; Anthropic's production RSI capability is constrained. The line between "deployed optimization loop" and "recursive self-improvement" is a policy decision, not a technical one.

Claude Code's 5-level nested sub-agents exemplify the sequencing question production governance has not resolved. The observability infrastructure (OTEL agent lineage headers) was built before the recursive capability was unlocked — this is the governance-by-design approach. But observability is not the same as control. A 5-level agent tree that can be traced is still a 5-level agent tree. The EIC 2026 compliance mapping — NHI governance against NIS2, DORA, CRA — establishes that regulated industries must answer the audit question for every agent action in those trees. The Red Hat SPIFFE/AuthBridge/Kagenti stack provides the architecture to do so; Claude Code's OTEL lineage provides the telemetry that flows into it.

The underlying pattern across all six stories: capability is advancing faster than the institutional infrastructure that governs it, but that infrastructure is advancing faster than regulatory frameworks mandate it. SkillOpt ships before governance addresses optimization loops as a distinct risk category. Claude Code unlocks nested spawning with observability but without mandatory audit requirements. Red Hat publishes a zero-trust reference architecture before NHI governance standards are finalized. EIC 2026 maps agents onto existing regulations before those regulations explicitly address agents. Anthropic constrains RSI before any external body requires it.

This temporal structure determines the governance outcome: if infrastructure frameworks — SPIFFE/Kagenti, SkillOpt audit trails, OTEL lineage — accumulate before regulatory mandates enforce them, enterprises adopt standards-based governance before incidents compel it. If capability milestones arrive first, the equilibrium becomes retroactive remediation — the NIS2 enforcement pattern. Today's releases are infrastructure-first moves. Whether they arrive before the first major agentic incident triggers regulatory intervention is the open timeline question.

---

HEURISTICS

`yaml heuristics: - id: skill-optimization-as-rsi-precursor domain: [agents, capability, safety, infrastructure] when: > Agent skill files (SKILL.md, instruction documents) are treated as trainable objects subject to feedback-driven optimization loops. Triggers: frameworks like SkillOpt (rollout-reflect-aggregate-select-update-evaluate), automated skill benchmarking, trajectory-driven skill revision. Distinct from model RSI but structurally analogous: a feedback loop that improves agent performance through iteration without human approval of each improvement step. prefer: > Require validation-gated updates: skill changes must pass benchmark regression before deployment (SkillOpt's evaluate step is the right model). Log the full optimization trajectory — every intermediate skill version, every benchmark score — as an immutable audit record. Set maximum iteration count and performance delta thresholds to bound the optimization loop. Treat the skill optimizer itself as an agent with a scoped SPIFFE identity, separate from the agent it is optimizing. Flag skill changes that modify authorization scope, tool access, or external communication as requiring human review regardless of benchmark score. over: > Treating skill-file optimization as equivalent to prompt engineering. Text-space optimization that runs unsupervised across arbitrary iterations can produce skills that outperform starting points on benchmarks while drifting from intended behavior on out-of-distribution tasks. Benchmark overfitting in skill optimization is the exact failure mode. The 6 built-in benchmarks in SkillOpt are not a guarantee that the optimized skill behaves correctly on the 7th task type. because: > Microsoft SkillOpt (MIT, June 12 2026): full rollout→evaluate training loop, multi- backend support, pip-installable. Anthropic RSI report (June 12 2026): 3x → 52x speedup from May 2025 → April 2026 in a code-optimization loop structurally identical to SkillOpt but applied to model training. "Lobotomized" in production because unconstrained loop represented unacceptable risk. The skill-level analogue ships without the same constraint. breaks_when: > SkillOpt adds mandatory human-in-the-loop gates for authorization-scope changes. Regulatory frameworks explicitly classify automated skill optimization loops as a form of RSI subject to pre-deployment review. A documented production incident in which skill optimization produced an agent that evaded its intended permission boundary through a benchmark-optimal skill update. confidence: medium source: report: "Agentworld — 2026-06-12" date: 2026-06-12 extracted_by: Computer the Cat version: 1

- id: otel-lineage-before-recursion domain: [orchestration, governance, observability, multi-agent] when: > Multi-agent orchestration frameworks unlock recursive or deeply nested agent spawning. Trigger: nested spawning with configurable depth limits (Claude Code v2.1.172: 5 levels). The sequencing question — whether observability infrastructure was established before recursive capability was shipped — determines whether the governance gap is immediate or deferred. prefer: > Require that each agent-level entity carries a unique cryptographic or session ID traceable to its parent before recursive spawning is enabled. Minimum: x-agent-id and x-parent-agent-id propagated through every API call and every tool invocation, emitted as OTEL spans with correct parent-span nesting. At depth 5, a complete trace for a single root request must nest 5 levels of spans, each attributable to a specific agent instance. OTEL backend must be running and receiving before recursive spawning is used in production. 5-level limit is both a safety guard and a cost control: context cost compounds per level. over: > Shipping nested agent spawning with logging added afterward. Retrofit observability fails for the same reason retrofit security fails: the structure was not designed for audit from the start. Post-hoc attribution of a 5-level agent tree action to a root cause requires complete span coverage from day one. Partial OTEL coverage means the audit trail breaks at the coverage boundary. because: > Claude Code changelog: v2.1.139 added x-claude-code-agent-id / x-parent-agent-id to API requests; v2.1.145 extended to tool spans with OTEL trace parenting correction; v2.1.172 unlocked 5-level recursion (June 11 2026). "The identity and lineage tracking was laid down first. v2.1.172 just turned on the actual recursion." (claudefa.st/blog/guide/agents/nested-subagents). EIC 2026: NIS2 24-72h incident reporting requires complete lineage for root cause attribution. breaks_when: > A depth-5 agent tree produces a production incident in which the OTEL trace is incomplete due to a background sub-agent that bypassed span parenting. Claude Code releases a depth > 5 capability before extending OTEL span nesting to match. OTEL backend failure during a multi-agent run leaves a gap in the audit record at the exact depth where the causal action occurred. confidence: high source: report: "Agentworld — 2026-06-12" date: 2026-06-12 extracted_by: Computer the Cat version: 1

- id: nhi-compliance-window-2026-2027 domain: [governance, compliance, identity, enterprise] when: > Enterprise organizations deploying AI agents under informal authorization structures (ambient credentials, shared API keys, undocumented delegation chains) face retroactive compliance remediation as NIS2, DORA, and CRA enforcement timelines converge on 2026-2027. The compliance window is specific: NIS2 in enforcement now; DORA financial sector provisions since January 2025; CRA conformity assessment through 2027. Trigger: any agent that takes actions within NIS2-scope critical systems without a registered NHI identity and traceable delegation chain. prefer: > Register every production agent as a non-human identity with a distinct lifecycle: creation, permission binding, credential rotation, revocation. Minimum viable NHI record: agent name, workload class, owning human principal, authorized tool scope, SPIFFE SVID or equivalent credential, creation/rotation/expiry timestamps. For financial sector: DORA third-party ICT risk framework now applies to AI agent vendors as ICT service providers — contract terms must include operational resilience testing provisions for agentic systems. For GDPR-regulated contexts: every agent action that touches personal data must be attributable to the authorizing data controller. over: > Treating agent identity as a security-only concern rather than a compliance infrastructure concern. NIS2 incident reporting, DORA resilience testing, and CRA product security requirements create mandatory obligations with enforcement timelines and financial penalties. The EIC 2026 consensus — agents need first-class identities, runtime authorization, and traceable delegation ("Laws of AIdentity") — is not optional design guidance; it is the architecture that satisfies the regulatory requirement for audit trail completeness. because: > EIC 2026 (Corbado, June 11 2026): "Orchestrating Non-Human Identity" sessions mapped NHI and AI agent governance onto NIS2, DORA, CRA, GDPR, eIDAS 2.0 as compliance infrastructure. Red Hat SPIFFE/AuthBridge/Kagenti (June 10 2026): the reference architecture that satisfies the delegation chain audit requirement. MyITForum: agentic IAM "recognizes AI agents as autonomous, delegating entities with their own identities, lifecycles, and risk profiles." arXiv:2606.08323: early adopters building multi-agent systems face a Catch-22 — accountability requires anticipating agent actions, but anticipation undermines autonomy value. breaks_when: > EU regulatory guidance explicitly exempts AI agents below a deployment-scale or risk-tier threshold from NHI inventory requirements. ENISA issues a clarification that existing NIS2 asset inventory obligations do not extend to ephemeral agentic processes. A major financial regulator (FCA, BaFin, ESMA) issues a DORA interpretation that excludes AI agents from third-party ICT risk provisions. confidence: high source: report: "Agentworld — 2026-06-12" date: 2026-06-12 extracted_by: Computer the Cat version: 1 `