VEYA Utility: Give AI agents access to assets, apps, and tools while keeping control over permissions, limits, and execution.

A paid AI agent call needs more than a successful response. It needs controlled spending, reliable settlement, and proof of what happened. VEYA 1.2.10 strengthens the provider-call layer with several key improvements: → Exactly-once settlement: Concurrent duplicate requests return the original result without charging twice. → Spending controls: Per-call caps, task budgets, and a two-call maximum per task. → Fail-safe rejections: Invalid requests return clear reason codes before payment or transaction signing. → Reliable proof recording: Fixed a failure in the on-chain recording path for verified calls. → Transparent costs: Responses show provider quotes, settled amounts, and remaining task budgets. → Consistent deployment: The production API, hosted MCP, npm packages, and repositories are aligned on version 1.2.10. VEYA supports execution across Solana and Robinhood Chain, with payment settlement and proof recording handled by the relevant chain in each workflow. The goal: fewer ambiguous failures, no duplicate charges from repeated requests, and verifiable outcomes. Build for the failure cases not just the happy path. $veya

AI agents need more than access to tools. They need boundaries around how those tools are used. In our VEYA 1.2.10 livestream, we verified: → Release consistency: npm, production API, and hosted MCP aligned. → Mainnet connectivity: Direct connection to Robinhood Chain and the VEYA contract. → Fail-safe execution: Invalid requests rejected before transaction signing. → Secret protection: Private values stayed out of responses. → Provider discovery: Services, inputs, and limits visible before execution. → Spending controls: Per-call limits, task caps, and a server-side kill switch. → Verifiable outcomes: Validator checks and proof commitments on Robinhood Chain. The goal: agents that can act within clear limits and leave evidence of what happened. $veya

Built to Fail Safely A paid AI agent call should never charge first and explain later. VEYA 1.2.10 was tested on mainnet: → 17 blocked cases stopped before payment. → Duplicate requests triggered no second settlement. → No API keys leaked in tested responses or logs. → Successful test calls achieved 3/3 validator agreement. With spending limits, a two-call task cap, and a server-side kill switch, safeguards are built into the workflow, not left on the roadmap. Build the workflow. Test the failure cases. Verify the result. $veya

From Agent Payment to Verified Proof When an AI agent spends money on your behalf, you should be able to know what happened to that payment and whether the result was verified. That’s what VEYA 1.2.10 is built to support. → The agent’s access and spending limits are checked first. → Payment goes directly to the provider on Solana. → 3 validators check the result; at least 2 must agree. → A proof commitment is recorded on Robinhood Chain. So when an agent uses an external service, there’s more than just a response to trust. There’s a controlled process and a record you can verify. AI agents can act on your behalf. Their actions shouldn’t be a black box. $veya

VEYA 1.2.10 is live on mainnet. AI agents can now discover external tools, pay for their use, and return results through a controlled, verifiable execution flow. Why it matters: when an agent uses an external service on your behalf, the call shouldn’t be an unchecked step. It needs authorization, payment limits, verification, and a record of what happened. With VEYA, developers get three new MCP tools to discover providers, execute paid calls, and run tasks across up to two calls under one limit. Payments settle on Solana. Validators verify responses. Proof is recorded on Robinhood Chain. Tested live: 17 blocked cases stopped before payment, duplicate requests settled only once, and no API keys leaked in responses or logs. For users, this means stronger controls around agent actions. For builders, it means a practical way to integrate paid external tools with verification and on-chain records. We’re building the infrastructure that helps AI agents do useful work without leaving execution unchecked. More information in the upcoming posts. $veya

What happens when an AI agent has access to more than it should? Imagine an agent handling customer records. One manipulated instruction could expose private data. An agent managing expenses could approve a payment outside company policy. And because agents operate at machine speed, a mistake can spread before anyone notices. This is why enterprise security teams are taking agent access seriously. Microsoft recently highlighted the risk of AI agents acting as “insiders” inside company systems and why controls must exist outside the model itself. Read: microsoft.com/en-us/security… The answer isn’t to stop using agents. It’s to stop treating their ability to act as permission to do anything. That’s what we’re building VEYA around. VEYA adds an execution-control layer for AI agents on Robinhood Chain: sensitive inputs can stay sealed, actions face policy checks before payment, records can be checked for tampering, and proofs require agreement from at least 2 of 3 validators. For users, that means better protection around private information and actions. For builders, it means a way to put enforceable safeguards around agent workflows. Let agents do the work. Keep control over what they’re allowed to do. $veya

7 safeguards. Built and tested. AI agents need more than access to tools. They need boundaries. Here’s what we’ve implemented in VEYA: → Controlled access: Writes are blocked without the required key. → Protected inputs: Sensitive strategy notes stay sealed while public fields remain readable. → Tamper detection: Change a recorded field, and its fingerprint no longer matches. → Validator agreement: At least 2 of 3 validators must agree before a proof is accepted. → Policy before payment: Disallowed actions are stopped before money moves. → No duplicate settlements: Repeated paid requests are settled only once. → Emergency stop: A kill switch immediately stops paid calls. These aren’t roadmap bullets. They’re implemented safeguards in VEYA’s agent infrastructure. Build with boundaries. Verify the outcome. $veya

AI agents made 12,593 requests through VEYA in one week. 212 MCP downloads. 195 SDK downloads. For users: keep sensitive strategy inputs protected while agent actions go through checks and produce verifiable on-chain outcomes. For builders: connect agents to VEYA’s tools and integrate controlled, verifiable execution into your own applications. Building the infrastructure for safer AI agents on Robinhood Chain. More integrations coming. $veya

Today, we took VEYA from individual components to a workflow we could test live, end to end. No slides. We tested the actual system. What we put through its paces: → 51 MCP tools in @veyanet/mcp v1.2.8, connected to Robinhood Chain Mainnet. → Live connectivity checks to confirm the chain connection and API health. → Private inputs protected with AES-256-GCM encryption, keeping sensitive strategy notes out of the public proof. → Failure handling tested: validator disagreement stops a run, and an unavailable node returns a clear error instead of silently failing. → Wallet-controlled commits: VEYA prepares the unsigned commit; your own wallet signs and sends it. Why this matters: connecting an AI agent is only one part of the problem. The system also needs to handle sensitive inputs, unexpected failures, and actions that require your authorization. Next, we're pushing beyond connectivity. We're experimenting with complete agent workflows, testing edge cases, and mapping the next set of improvements for next week's roadmap with a focus on making VEYA easier to integrate, more predictable under failure, and simpler to verify. Today's livestream showed where the system stands. Next week's updates will show what we can build on top of it. VEYA is being built for agents that can act, with boundaries that matter. $veya

Markets run 24/7. One unchecked AI agent can turn a single mistake into a round-the-clock problem.

2.17s MAINNET RUN. 3/3 VALIDATORS AGREED. PRIVATE INPUTS SEALED. VEYA Sealed Runs let builders prove execution without publishing sensitive strategy notes. 🔹2.17 seconds : successful mainnet run 🔹 AES-256-GCM: encrypts private inputs 🔹3/3 validators: all agreed; 2 required 🔹 1 fingerprint: helps detect changes to the public record 🔹 1 public run record: shows public execution details, the fingerprint and verification results. Private notes remain sealed; it does not reveal the hidden strategy or prove every decision was correct. 🔹0 user keys held by VEYA: the transaction is returned unsigned for the user to sign. Users can inspect the record. Builders keep their strategy private. Private inputs. Public proof. $veya

Use AI agents. Build your own. Keep their actions in bounds. The new VEYA Agents page brings both sides together. For users →Set up agents, define their permissions and spending limits, and verify their results. For builders → 51 MCP tools to connect → VEYA Skills that teach agents which tools to use, when, and how → TypeScript SDK to build VEYA into your own products The stack has been tested: ✓ 51/51 MCP tools called ✓ 82/82 skill examples ran successfully ✓ 48/48 backend checks passed One place to go from trying VEYA to building with it. Explore VEYA Agents ↓ veyanet.tech/agents $veya

VEYA | Sealed Runs Are Now Working Through SDK & MCP Yesterday, we shipped a working sealed execution flow so agents can process sensitive strategy notes without exposing them in the stored record, while keeping public execution data verifiable. Here’s what we implemented: → AES-256-GCM encryption for strategy_notes; execution details remain public. → BLAKE3 fingerprints to verify the public execution record. → 2-of-3 validator consensus, with fail-closed behavior when checks fail. → SDK + MCP support for developers to run protected executions. → Wallet-controlled Mainnet settlement—VEYA prepares unsigned transaction data; you sign it yourself. → Explicit failure handling for unavailable sealed nodes, invalid requests, and duplicate runs. We’ve tested the flow, including proof matching and failure cases. It’s a working implementation—not just a roadmap item. Want to integrate sealed execution into your agent? Explore the SDK: npmjs.com/package/@veyanet/s… Private where it matters. Provable everywhere else. $veya

One page. Three ways to build with VEYA. MCP. Skills. SDK. Everything you need to connect your AI agent to VEYA is coming together in one place. The VEYA Builder Guide drops soon.

More skills make agents more capable. They also raise the stakes when agents act without limits. VEYA keeps agent actions within defined boundaries, with proof of what happened. $veya