The New Gateway to the Autonomous Economic Agent Era: ‘Know Your Agent (KYA)’ and M2M Trust Infrastructure

AI agents are rapidly evolving beyond simple text generation or one-off API calls into 'Autonomous Economic Actors' capable of making their own decisions and allocating resources. The recent release of Sakana AI's next-generation orchestration models, 'Fugu' and 'Fugu Ultra,' clearly illustrates this technological turning point. Built on the TRINITY and Conductor architectures, this system dynamically orchestrates multiple frontier models and combines intra-workflow agent isolation with shared memory technology. It achieved a 73.7% performance score on SWE-Bench Pro, demonstrating high-level task-solving capabilities. This capacity for multi-model control and autonomous workflow execution shows that agents are nearing the technological maturity to handle real capital and conduct economic activities without human intervention.

However, this leap in agent orchestration inevitably brings significant trust gaps and security threats. As agents begin to autonomously perform financial transactions and M2M (Machine-to-Machine) interactions—such as paying for API usage or allocating cloud resources—the verification process of 'who this agent actually represents' and 'whether it is operating within permitted authority' has become a critical bottleneck. In particular, the complex prompt pipelines and multi-model routing mechanisms operating within dynamic orchestration processes are perfect 'black boxes' from an external perspective, making it extremely difficult to detect or debug authorization leaks or funding losses caused by coordination errors.

These structural risks reveal the clear limitations of traditional, human-centric KYC (Know Your Customer) systems. Existing financial infrastructure was designed based on static human entities or individual identities, but the ecosystem of ephemeral agents that appear and vanish in real-time requires 'KYA (Know Your Agent),' a machine-centric, autonomous security verification protocol. Without KYA infrastructure, which can cryptographically authenticate and control an agent's owner, operational lifespan, and specific financial transaction limits, safe collaboration or regulatory compliance between autonomous agents is impossible. This article analyzes the new security threats triggered by the evolution of orchestration models like Fugu and examines the necessity of KYA technical standards and machine identity assurance infrastructure required to build a secure Agentic Web.

The Evolution of Multi-Model Orchestration and the Prelude to Autonomous Economic Activity

AI agents are moving beyond sequential single-task execution into an advanced orchestration phase where they control and coordinate complex multi-model environments themselves. The 'Fugu' and 'Fugu Ultra' orchestration models recently announced by Sakana AI are prime examples of this shift. Fugu introduces the TRINITY (0.6B evolutionary tuning model) and Conductor (7B collaborative strategy model) architectures, based on ICLR 2026 research, to dynamically control heterogeneous frontier models like GPT-5.5, Claude Opus 4.8, and Gemini 3.1 Pro. Notably, it has demonstrated structural progress, including 'intra-workflow agent isolation' to prevent total system collapse and 'persistent shared memory' to reduce unnecessary tool calls.

However, this multi-layered, complex orchestration inevitably brings the downsides of system opacity (black-box routing) and unpredictable cost control. This is exactly why, despite Fugu's impressive 73.7% score on SWE-Bench Pro, concerns about cost inflation and debugging difficulties persist within the developer community.

The problem arises when agents go beyond software modifications or simple information retrieval to become autonomous economic actors that execute 'actual capital,' such as dynamically purchasing cloud resources or paying for premium APIs. Current development frameworks lack the clear control mechanisms needed to manage authorization leaks between agents or financial losses caused by malfunctions as multiple agents organically coordinate routing. Without a reliable procedure to verify which parent agent created a sub-agent and how much of the parent's budget and payment authorization was delegated to the child, large-scale commercialization of autonomous agents is nearly impossible.

Ultimately, as the autonomous range of agents expands, the need for identity and security protocols that can verify in real-time whether 'this agent’s ownership and authorization are legitimate' becomes critical. This is the paradox brought by advanced agent performance, and the decisive reason why we must move beyond the traditional KYC (Know Your Customer) used for human users and establish a new form of 'KYA (Know Your Agent)' trust infrastructure that operates in machine-to-machine (M2M) environments.

The Paradigm Shift from KYC to KYA (Know Your Agent)

The emergence of multi-model orchestration technologies like Sakana AI's Fugu, discussed in the previous section, has dramatically widened the scope of agent actions. As agents evolve beyond merely sending emails for users to generating their own sub-agents, dynamically selecting optimal frontier models, and allocating real assets, security architecture faces unprecedented challenges. In such complex dynamic routing environments, we must verify in real-time not only 'who executed this agent' but also 'what authority was delegated to this agent and whether its current decision-making process is tainted.' This is exactly why the KYA (Know Your Agent) protocol is strongly needed beyond traditional KYC (Know Your Customer).

KYC, the foundation of traditional finance and web architecture, is optimized for statically verifying the physical identities of human users (resident registration cards, passports, biometric information, etc.). It was designed to align with human decision-making speeds and realistic compliance cycles. KYA, on the other hand, targets the machine learning agent ecosystem that interacts in milliseconds (ms). A KYA protocol must be able to cryptographically prove an agent’s security profile, including its ownership, authorization limits (allocated budget and transaction caps), and the integrity of its runtime environment, instantly.

In particular, black-box routing mechanisms such as the 'lack of debugging transparency' noted in Fugu’s multi-model coordination highlight the need for KYA. If an orchestrator agent brokers work to an unauthorized, malicious sub-agent, or if authorization leaks occur due to vulnerabilities in the internal prompt pipeline, it can lead to cascading financial and operational damage. Therefore, an ideal KYA architecture must serve as a defense line that combines integrity verification within a Trusted Execution Environment (TEE) and cryptographically signed dynamic token mechanisms to transparently yet securely control all API calls and state transitions between agents.

Challenges and Technical Barriers in Building M2M Trust Infrastructure

To build practical agent identity security, certain technical challenges must be addressed. The complex prompt pipelines and routing mechanisms used by agents often function as opaque 'black boxes' from the outside, making it difficult to detect identity and authorization abuse in real-time.

The recently emerged multi-model orchestration architecture like Sakana AI's 'Fugu' is a prime example highlighting these challenges. Fugu uses TRINITY (0.6B evolutionary tuning model) and Conductor (7B collaborative strategy model) trained via GRPO (Group Relative Policy Optimization) to recursively explore collaborative strategies based on natural language and dynamically control public frontier models. In such highly dynamic routing environments, it is extremely difficult to verify in real-time which sub-agent made a specific decision at a given time, and whether the credentials or execution permissions used for that decision were legitimately delegated. Furthermore, the opacity such as 'lack of debugging transparency' pointed out by Fugu's developer community creates a serious barrier for security administrators to trace the cause of abnormal transactions.

Another security vulnerability lies in credential leakage and the ambiguity of execution scope. In multi-model environments, orchestrators use 'Persistent Shared Memory' to minimize redundant tool calls or 'Intra-workflow Agent Isolation' to prevent collapse between sub-agents. However, during the process of sharing memory, there is a risk that sensitive API tokens or financial transaction signing keys might leak to other unauthorized sub-agents. If isolation boundaries are not perfectly controlled, temporary permissions granted for specific tasks could propagate to the entire workflow, leading to massive cost inflation or authorization abuse incidents.

To overcome these barriers, it is urgent to establish technical standards that combine cryptographic signatures and Decentralized Identity (DID) technology with the agent orchestration layer. For machine-to-machine (M2M) autonomous trust to form without human intervention, unique cryptographic key pairs must be assigned the moment an agent is created, and all API calls and transactions performed by the agent must include a digital signature. In addition, a 'Verifiable Credential (VC)' model must be introduced to cryptographically prove the scope of authority a sub-agent has received from a master agent within dynamically changing workflows. A secure agent economy can only be realized when standardized trust infrastructure is secured to resolve technical opacity and enable transparent auditing of interactions between agents.

The Journey Toward a Trusted Agentic Web

The limits of the future envisioned by autonomous economic agents do not merely rest on the reasoning performance of language models or the ingenuity of orchestration techniques. Rather, those limits will be defined by the security barriers of the environment in which agents interact and the maturity of the trust infrastructure. While multi-model orchestration architectures like Sakana AI's Fugu and Fugu Ultra have raised the bar for technical autonomy, they have simultaneously clearly revealed that existing human-centric security systems cannot sustain an autonomous agent ecosystem.

If the 'Know Your Customer (KYC)' system that dominated traditional finance and platform environments was premised on human identity and legal responsibility, the upcoming 'Know Your Agent (KYA)' system aims to build trust relationships between machines (M2M). Intricately woven prompt pipelines and GRPO-based dynamic decision-making processes are essentially opaque black boxes when viewed from the outside. Such opacity can lead to serious vulnerabilities, including unauthorized use of privileges, authorization leaks, and budget depletion beyond control limits. Therefore, for agents to be recognized as independent economic entities, standard protocols capable of cryptographically verifying the scope of delegated authority and the traceability of orchestration paths are essential.

Ultimately, for a stable transition to the 'Agentic Web,' standardization efforts integrating Decentralized Identity (DID), Zero Trust security architecture, and isolated sandbox mechanisms must go hand-in-hand with quantitative improvements in benchmark scores. Beyond mere displays of technical performance, a true machine-to-machine autonomous collaboration ecosystem will only blossom when KYA standards, which define safe and verifiable transaction boundaries, are firmly established. It is time for developers and security architects to focus not only on designing the agent's clever brains but also on building the infrastructure that paves the territory of trust upon which they will operate.