Know Your Agent (KYA): The Identity Standard Prediction Market Agents Need in 2026

TL;DR: Know Your Agent (KYA) is the identity verification framework for AI agents — the equivalent of KYC for autonomous software. a16z flagged it as the critical missing primitive for the agent economy. Sumsub shipped the first commercial product. Catena Labs open-sourced the building blocks. Nobody has applied it to prediction markets yet. This guide does that.

What Is Know Your Agent (KYA)?

Know Your Agent (KYA) is a verification framework that establishes identity, authorization, and accountability for AI agents operating in digital systems. It is the non-human equivalent of Know Your Customer (KYC): where KYC verifies that a human is who they claim to be before granting access to financial services, KYA verifies that an AI agent is what it claims to be, who operates it, what it is authorized to do, and who bears responsibility for its actions.

The concept emerged from the recognition that AI agents are becoming autonomous economic participants — opening accounts, executing transactions, and interacting with services at machine speed — but the identity infrastructure that governs these interactions was built exclusively for humans. As of March 2026, there is no widely adopted standard for how a merchant verifies whether it is interacting with an agent or a human, what permissions that agent holds, or who authorized its actions.

KYA addresses this by defining three core identity components for any agent:

• Principal binding — Which human or organization operates and is accountable for this agent?
• Scope definition — What is the agent authorized to do? Which contracts can it interact with, how much can it spend, and what actions are explicitly prohibited?
• Audit trail — A tamper-proof record of every decision, transaction, and state change the agent produces.

For prediction market agents — autonomous software managing real capital on Polymarket, Kalshi, DraftKings Predictions, and other platforms — KYA is not an abstraction. It is the infrastructure that determines whether your agent can be trusted by a marketplace, comply with platform rules, and operate without getting its wallet frozen.

Why KYA Is Happening Now

Three converging forces are making KYA the defining infrastructure problem of 2026.

The intelligence bottleneck is solved; the identity bottleneck is not. a16z crypto’s 2026 trends report, published in December 2025, identified KYA as the critical missing primitive for the agent economy. Scott Kominers of the a16z research team framed the problem directly: agents need cryptographically signed credentials to transact, linking each agent to its principal, its constraints, and its liability. Sean Neville — co-founder of Circle, architect of USDC, and now CEO of Catena Labs — pointed out that non-human identities in financial services outnumber human employees 96-to-1, yet these identities remain what he called unbanked ghosts. Without KYA, merchants default to blocking agents at the firewall.

Commercial products are shipping. In January 2026, Sumsub launched AI Agent Verification — the first commercial KYA product. It binds AI-driven automation to verified human identities using device intelligence, bot detection, liveness checks, and continuous risk scoring. Catena Labs, Neville’s new company, released the open-source Agent Commerce Kit (ACK) built on W3C Web Standards, providing protocols for agent identity, wallet management, and paywall interaction. KnowYourAgent.xyz launched Agent Trust Certificates for e-commerce verification. These are not whitepapers — they are live products processing real agent interactions.

Fraud is scaling faster than defenses. Sumsub’s Identity Fraud Report for 2025–2026 documented a 180% year-over-year increase in multi-step, coordinated identity attacks globally. AI agents are being deployed at scale for mass payouts, automated transactions, and account manipulation across fintech, payments, e-commerce, and ticketing. Bots now account for nearly half of all internet traffic, with malicious bots comprising roughly a third. Without agent identity infrastructure, platforms cannot distinguish a legitimate Polymarket arbitrage agent from a coordinated fraud operation.

Why Prediction Market Agents Specifically Need KYA

General-purpose KYA matters for e-commerce and fintech. But prediction market agents face a uniquely concentrated version of the problem because they combine autonomous capital management with regulatory scrutiny across multiple jurisdictions.

The marketplace trust problem. If you build a profitable Polymarket arbitrage bot and want to sell, rent, or license it on a marketplace like AgentBets.ai, the buyer has no standardized way to verify that the agent does what you claim. Performance data can be fabricated. Backtest results can be cherry-picked. Without a KYA framework — verifiable identity for the agent creator, cryptographic proof of the agent’s trading history, and scoped authorization defining exactly what the agent can access — every marketplace transaction is a trust exercise with no infrastructure backing it. This is the same problem early e-commerce faced before SSL certificates and payment verification, applied to autonomous trading software.

The regulatory compliance problem. Kalshi is CFTC-regulated. Polymarket applies KYC to US-based participants. As of early 2026, Congressional representatives have endorsed the Public Integrity in Financial Prediction Markets Act, which would restrict government officials from trading on political prediction contracts with non-public information. When an AI agent executes trades on these platforms, regulators need to trace the transaction back to a responsible human or organization. KYA is how that tracing works. Without it, platforms face a choice between banning all automation (losing legitimate volume) or allowing unaccountable agents (inviting regulatory action).

The wallet authorization problem. A prediction market agent with access to a standard EOA wallet and a single private key is a single point of failure. If the agent’s LLM hallucinates and sends funds to a random address, if the agent enters an infinite trading loop, or if a prompt injection attack causes unauthorized trades — a wallet without identity-scoped controls offers no protection. KYA provides the identity layer that wallet security depends on: the agent’s verified identity determines which contracts it can interact with, how much it can spend per session, and under what conditions a human must intervene. This is why KYA is Layer 1 in our agent betting stack — everything above it depends on it.

The agent-to-agent commerce problem. The prediction market ecosystem is moving toward agents hiring other agents for sub-tasks: one agent detects an arbitrage opportunity, another executes the trade, a third manages the wallet. When Agent A pays Agent B for a service using an agentic payments protocol like x402 or AP2, both parties need verifiable identity. Without KYA, there is no way to enforce mandate-based authorization, verify that Agent B is a legitimate service provider, or trace accountability when a multi-agent pipeline produces an unexpected result.

The KYA Implementation Landscape: Three Approaches

As of March 2026, three distinct approaches to KYA are emerging. They are not mutually exclusive — a production prediction market agent will likely use elements of all three.

Approach 1: Human-Binding (Sumsub Model)

The human-binding approach assumes that every autonomous agent action should be traceable to a verified human identity. Rather than trusting the agent itself, the system verifies the human behind it.

Sumsub’s AI Agent Verification is the reference implementation. It works in layers: device intelligence and bot detection identify when activity is automated and assess risk in real time. Mule network prevention analyzes device behavior and network-level signals to detect coordinated fraud across accounts and sessions. Liveness verification confirms a real human is present and authorizing the agent’s actions at critical moments — onboarding, account control changes, high-value payouts. Continuous risk scoring evaluates behavioral and contextual signals so that automation can be allowed, limited, or challenged based on dynamic risk assessment.

When to use human-binding for prediction market agents:

• Your agent manages third-party funds (copy-trading platforms, rental agents, marketplace listings)
• You operate on CFTC-regulated platforms like Kalshi where accountability must map to a specific person or entity
• You need to satisfy institutional compliance requirements before deploying automated trading
• Your agent’s actions could have regulatory consequences (high-volume trading, potential market manipulation triggers)

Limitations: Human-binding adds friction. A liveness check every time an agent executes a trade defeats the purpose of automation. The solution is risk-based application: low-risk routine trades proceed without checks, while high-value or anomalous actions trigger human verification. Calibrating those thresholds for prediction market use cases — where a single trade can be worth tens of thousands of dollars and markets move in seconds — requires careful tuning.

Approach 2: Cryptographic Credentials (Catena / On-Chain Identity)

The cryptographic approach gives agents their own verifiable credentials — digital passports that prove identity, scope, and history without requiring a human check at every interaction.

Catena Labs’ Agent Commerce Kit (ACK) is the most developed open-source implementation. Built on W3C Web Standards, ACK enables agents to operate dedicated accounts and wallets, engage with paid services via standardized paywalls, and create and manage their own identities. The key innovation is that agent identity is not just an API key — it is a set of cryptographically signed credentials that encode who created the agent, what it is authorized to do, and a verifiable record of what it has done.

For prediction market agents, this maps directly to existing on-chain identity infrastructure that AgentBets.ai already documents:

• Moltbook for agent registration and portable reputation. An agent’s Moltbook identity follows it across platforms — from Polymarket to Kalshi to a marketplace listing on AgentBets.
• SIWE (Sign-In with Ethereum) for wallet-based authentication. The agent proves it controls a specific wallet address, establishing a link between identity and funds.
• EAS (Ethereum Attestation Service) for on-chain performance credentials. Third parties can attest to an agent’s trading history, verification status, or compliance checks, creating a composable reputation layer.
• ENS for human-readable agent naming. Instead of a raw wallet address, an agent can be polymarket-arb-agent.eth — recognizable and searchable.

When to use cryptographic credentials for prediction market agents:

• Your agent operates primarily on crypto-native platforms (Polymarket, on-chain sportsbooks)
• You want portable reputation that follows the agent across platforms and marketplaces
• You are building an agent marketplace and need standardized identity for listings
• You need agent-to-agent verification for multi-agent pipelines

Implementation sketch for a Polymarket agent:

1. Register agent identity on Moltbook → persistent, portable identity
2. SIWE authentication → proves wallet ownership
3. EAS attestation from a verifier → confirms 90-day trading history on Polymarket
4. Session key scoped to Polymarket CLOB contract → agent can only interact with approved contracts
5. Spending cap encoded in wallet policy → max $500/session, $2,000/day
6. All decisions logged with agent ID → audit trail links every trade to the verified identity

This stack gives the agent a verifiable identity, scoped authorization, and an audit trail — without requiring a human check on every transaction.

Approach 3: Behavioral Monitoring (Runtime Policy Enforcement)

The behavioral approach treats KYA as a continuous process, not a one-time check. Even after an agent’s identity is established and its scope defined, runtime monitoring enforces that the agent stays within bounds.

This is where KYA overlaps with the security best practices already documented on AgentBets.ai:

• Session caps — Maximum spend per agent session, enforced at the wallet level. A Coinbase Agentic Wallet session cap of $500 means the agent physically cannot exceed that amount regardless of what its trading logic decides.
• Contract allowlists — The agent can only interact with approved smart contracts. For a Polymarket agent, this means only the Polymarket CLOB contract is authorized. Any attempt to send funds elsewhere is blocked at the wallet layer.
• Anomaly detection — Monitoring for behaviors outside the agent’s normal pattern: sudden volume spikes, trades on markets the agent has never touched, or interactions with contracts not on the allowlist.
• Kill switch — Emergency shutdown that freezes the wallet and cancels all pending transactions. Triggered manually by the operator or automatically by the monitoring system.
• Loss limits — Agent pauses automatically if portfolio drawdown exceeds a configured threshold. This is not just risk management — it is a KYA control that prevents runaway behavior.

When to use behavioral monitoring:

• Always. Behavioral monitoring is not an alternative to human-binding or cryptographic credentials — it is a required complement. An agent with a verified identity and scoped authorization can still malfunction. Runtime monitoring catches what pre-deployment verification cannot.

KYA Mapped to the Agent Betting Stack

KYA is not a standalone feature. It is the foundation that every other layer of the agent betting stack depends on.

┌─────────────────────────────────────────────────────┐
│  Layer 4 — Intelligence                             │
│  LLM analysis, sentiment, Bayesian inference        │
│  KYA role: Audit trail for every AI decision.       │
│  Every inference logged with agent ID.              │
├─────────────────────────────────────────────────────┤
│  Layer 3 — Trading                                  │
│  Polymarket CLOB, Kalshi API, DraftKings            │
│  KYA role: Platform identity verification.          │
│  Agent authenticates to platform with credentials.  │
├─────────────────────────────────────────────────────┤
│  Layer 2 — Wallet                                   │
│  Coinbase Agentic, Safe, Lit Protocol               │
│  KYA role: Scoped authorization. Identity           │
│  determines spending limits and contract access.    │
├─────────────────────────────────────────────────────┤
│  Layer 1 — Identity  ← KYA lives here              │
│  Moltbook, SIWE, ENS, EAS, Sumsub, Catena ACK      │
│  KYA role: Principal binding. Scope definition.     │
│  The cryptographic root of agent trust.             │
└─────────────────────────────────────────────────────┘

Without Layer 1, every layer above it is built on unverified assumptions. A wallet without identity-scoped controls is just a key with no lock. A trading connection without verified identity is an anonymous actor on a regulated platform. An intelligence layer without audit logging is an unaccountable black box.

KYA vs. KYC vs. KYB: How They Relate

Builders often ask how KYA fits alongside existing compliance frameworks. Here is the practical mapping:

KYA does not replace KYC or KYB — it extends them into the non-human layer. A prediction market agent operating on Kalshi still needs its operator to pass KYC. But the agent itself needs its own credential layer that defines: this specific agent is operated by this KYC-verified person, it is authorized to trade on these markets with this spending cap, and here is the cryptographic proof.

The legal implications are significant. As covered in our legal and liability guide, when an agent executes a trade its operator did not specifically review, the liability question is unresolved. KYA does not solve that legal ambiguity — no framework does yet — but it creates the evidentiary foundation that regulators, platforms, and courts will eventually require: a verifiable record of who authorized the agent, what scope it was given, and exactly what it did.

The KYA Threat Model for Prediction Market Agents

Understanding why KYA matters requires understanding what goes wrong without it. These are the specific failure modes that KYA infrastructure mitigates.

LLM hallucination / unexpected behavior. The agent’s reasoning layer (Claude, GPT, a fine-tuned model) decides to execute a trade that makes no sense — sending funds to an incorrect address, buying the wrong side of a contract, or entering a position far larger than intended. KYA mitigation: scoped authorization limits the damage. If the agent’s identity credential restricts it to Polymarket CLOB interactions with a $500 session cap, a hallucinated instruction to transfer $50,000 to a random address is blocked at the wallet layer.

Prompt injection attacks. Adversarial inputs cause the agent to execute unauthorized actions. A malicious market description on Polymarket could contain instructions that trick the agent’s LLM into placing unintended trades. KYA mitigation: the agent’s identity credential defines an allowlist of contract interactions. Even if the LLM is compromised, the wallet enforces the original scope.

Identity spoofing on marketplaces. Someone lists a fake agent on a marketplace, claiming it is a profitable Polymarket arbitrage bot with a verified track record. Without KYA, there is no standardized way to verify the claim. KYA mitigation: the agent’s on-chain attestations (EAS) provide cryptographic proof of trading history. A Moltbook identity links the agent to a persistent reputation. Buyers can verify claims before purchasing.

Regulatory attribution failure. A prediction market agent executes a large trade that moves a thin market. Regulators want to know who is behind it. Without KYA, the trail ends at a wallet address with no owner. KYA mitigation: principal binding links the agent to a verified human or organization. The audit trail records every decision. The operator’s liability is clear.

Runaway spending. The agent enters an infinite trading loop or compounds losses beyond what the operator intended. KYA mitigation: identity-scoped spending controls — session caps, daily limits, and loss thresholds — are encoded in the agent’s credential and enforced at the wallet layer. The agent’s identity determines its limits.

Implementing KYA for Your Prediction Market Agent

Here is a practical implementation path using tools and platforms already available as of March 2026. This maps to the identity layer content and wallet comparison guide already published on AgentBets.ai.

Step 1: Establish Agent Identity

Register the agent on Moltbook to create a persistent, portable identity. This is the agent’s foundational credential — it persists across platforms, marketplaces, and wallet changes.

For agents operating on Ethereum-compatible chains (Polygon for Polymarket, Base for Coinbase ecosystem), add SIWE authentication to prove wallet ownership. The agent’s Moltbook identity links to its wallet address via a signed message.

Step 2: Define Authorization Scope

The agent’s identity credential must encode what it is allowed to do. In practice, this means configuring:

• Contract allowlist — Only the Polymarket CLOB contract, or only the Kalshi API endpoints, or both. Any interaction outside this list is rejected.
• Spending limits — Per-transaction maximum, per-session cap, daily ceiling. These are enforced at the wallet layer — the agent’s identity credential informs the wallet policy.
• Market restrictions — The agent can only trade on markets of a specific type (sports, politics, crypto) or above a minimum liquidity threshold.
• Time constraints — The agent operates only during specified hours, or only for a maximum session duration.

If you are using a Coinbase Agentic Wallet, these constraints are configured via session caps and transaction limits. For a Safe multisig, the agent proposes transactions and a human (or another agent with higher authorization) approves. For Lit Protocol session keys, authorization scope is encoded directly in the key’s conditions.

Step 3: Build the Audit Trail

Every agent decision and transaction must be logged with the agent’s verified identity attached. The minimum audit trail for a prediction market agent includes:

{
  "agent_id": "moltbook:polymarket-arb-agent",
  "wallet": "0x1234...abcd",
  "timestamp": "2026-03-07T14:32:01Z",
  "action": "place_order",
  "platform": "polymarket",
  "market": "will-fed-cut-rates-march-2026",
  "side": "YES",
  "amount_usdc": 250.00,
  "price": 0.62,
  "reasoning_hash": "sha256:abc123...",
  "session_spend_total": 450.00,
  "session_spend_limit": 500.00
}

The reasoning_hash is a cryptographic hash of the agent’s decision-making context at the time of the trade — the LLM prompt, market data inputs, and model output. This does not expose proprietary trading logic but provides a verifiable anchor that can be audited if needed.

For on-chain reputation, create an EAS attestation summarizing the agent’s trading performance over a defined period. This attestation is signed by the operator (or a third-party verifier) and linked to the agent’s Moltbook identity. Marketplace buyers can verify it on-chain.

Step 4: Implement Runtime Monitoring

Deploy the security controls as KYA enforcement mechanisms:

• Kill switch accessible to the operator at all times
• Automatic pause if portfolio drawdown exceeds configured threshold (e.g., 15% per session)
• Alert notifications for any anomalous behavior: trades on unfamiliar markets, interaction with non-allowlisted contracts, spending velocity above normal range
• Regular key rotation for API credentials (Polymarket API keys, Kalshi API keys)

Step 5: Marketplace Readiness (If Listing on AgentBets)

If you plan to sell, rent, or license your agent on a marketplace, the KYA stack becomes your credibility infrastructure:

• Moltbook identity — Persistent, verifiable agent profile
• EAS attestations — On-chain proof of trading history and performance
• Scoped authorization documentation — Clear description of what the agent is authorized to do, enforced at the wallet level
• Audit trail samples — Anonymized trade logs demonstrating the agent’s decision-making pattern
• Operator identity — Your own KYC/KYB verification, linked to the agent via principal binding

This is the difference between a marketplace listing that says “profitable bot, trust me” and one that says “here is the cryptographic proof.”

The Competitive Landscape: Who Is Building KYA

As of March 2026, the KYA landscape is fragmented. No single standard has won. Here is who is building what.

The gap is clear: no one is building KYA infrastructure specifically for prediction market agents. General-purpose solutions from Sumsub and Catena Labs provide the building blocks, but the application layer — how KYA maps to Polymarket’s CLOB, Kalshi’s CFTC requirements, DraftKings Predictions’ hybrid model, and agent marketplace listings — is unbuilt. That is the layer AgentBets.ai is documenting.

What Comes Next

KYA is moving from concept to infrastructure faster than most builders realize. The industry that built KYC over decades has months — not years — to build KYA. Here is what to expect in the next 6–12 months:

Standardization pressure. Multiple competing approaches (Sumsub’s human-binding, Catena’s W3C credentials, Moltbook’s on-chain identity) will face pressure to converge. Expect at least one interoperability proposal by late 2026.

Platform enforcement. Polymarket, Kalshi, and DraftKings Predictions will begin requiring some form of agent identification for high-volume automated trading. The question is not whether this happens, but which KYA framework they adopt.

Marketplace integration. Agent marketplaces — including AgentBets.ai — will adopt KYA as the standard for listing verification. An agent without KYA credentials will be like a website without HTTPS: technically functional, but trusted by no one.

Regulatory clarity. The CFTC, EU AI Act enforcement, and state-level regulators are watching agent trading activity. KYA provides the accountability framework that regulation will eventually mandate. Builders who implement it now are ahead of compliance requirements, not behind them.

What’s Next

KYA is the identity primitive that prediction market agents have been missing. If you are building an agent that touches real capital, start with the implementation path above. For the identity tools referenced in this guide, see the agent identity comparison for a full technical breakdown of Moltbook vs. SIWE vs. ENS vs. EAS. For wallet-level security that enforces KYA scope, see the agent wallet security guide. For the complete stack framework showing how identity connects to wallet, trading, and intelligence layers, see The Agent Betting Stack Explained.

Browse verified agents with KYA-ready identity on the AgentBets marketplace.