Yosh

Economicpermissionforautonomousagents

Download for macOS
v0.1.0 BetaApple Silicon · macOS 15+

Not Apple-notarized

Yosh checks whether a purchase fits the authority you granted before payment can begin.

Give agents bounded spending authority without handing over unrestricted wallet control.

DIRECT DOWNLOAD / macOS
https://github.com/Niri7981/Yosh/releases/download/v0.1.0-beta/Yosh-0.1.0-beta-arm64.dmg
Yosh, quietly floating with open eyes
within your authority

How it works

From a task’s need to an authorized purchase.

When an agent needs a paid API, data or tool, you define the resources and spending limits. Yosh checks that authority before executing a supported purchase.

  1. 01

    Connect an agent

    Connect through MCP. A connection alone does not grant permission to spend.

  2. 02

    Create a SpendGrant

    Authorize a specific resource with a total, per-purchase limit and expiry. Registering an API does not authorize spending.

  3. 03

    Request a purchase

    The agent supplies a resource, allowed inputs and a request ID. The payment amount comes from a quote.

  4. 04

    Check policy and budget

    The local Authority checks the grant, expiry, budget and pause state before reserving funds.

  5. 05

    Pay

    Checks run again before signing and first submission. A separate signing boundary handles supported x402 payments.

  6. 06

    Deliver and record

    Retrieve the API response and record payment and delivery separately. A successful payment does not guarantee delivery.

Expired grants, insufficient budgets and paused new payments block the request. An unknown transaction outcome must be checked before retrying payment.

Try the interactive prototype →Simulation · No wallet connection, signing or transactions.

A request is
not authority.

Identity

Each authenticated connection belongs to a persistent local member. Purchases stay associated with that member when credentials change.

Authority

A SpendGrant sets total allowance, per-transaction limit, and expiry. Each member also draws from the same shared daily authority.

Decision

Yosh validates the request and quote, then checks the grant, shared daily authority, pause state, and unresolved payments. Requests outside these boundaries are denied.

Execution

With live execution explicitly enabled, approved purchases can enter the x402 pipeline. Authority and payment terms are checked again before signing.

Record

Decision, payment, and delivery are recorded as separate facts.

Illustrative configuration · simulated
No previous spending · payments enabled

Codex requests
Market Snapshot

Shared daily limit
1.00 test USDC
SpendGrant total
0.40 test USDC
Per transaction
0.20 test USDC
Expiry
One hour
Quote
0.20 test USDC
within authorityapproved

Evaluating authority…

In simulation, payment does not start.

Yosh in its focused state

Approved does not mean paid.
Paid does not mean delivered.

A budget,
not a wallet.

Agents do not need unrestricted access to your wallet in order to act. Give them a bounded budget, a precise SpendGrant, and let Yosh enforce the limit.

Illustrative boundary · test USDC

Yosh, quietly floating with open eyes
within authority

Remaining authority is not wallet balance. Paid, Reserved, and Remaining track authority. Read the accounting details.

The agent can move freely inside the boundary. It cannot move the boundary itself.

Authority,
with boundaries.

One boundary,
many members.

Members keep separate local identities, grants, connections, and purchase ownership while sharing daily authority. Codex is the current supported named host integration.

Local macOS · Codex through MCP
Solana Mainnet · native USDC
Simulation by default

Connection
Connect Codex through MCP. Setup / Waiting is distinct from a real, recent Connected session.
Yosh in its focused state
SpendGrant
Set total allowance, per-transaction limit, and expiry. Replace or revoke the selected member’s grant.
Daily Authority
One daily spending limit across members. Paid, Reserved, and Remaining stay distinct.
Payments
Pause new payments across the service. Pause does not reverse already submitted transactions.
Activity
Review the request, decision, payment state, delivery state, and available receipt or transaction information.

Additional named host integrations are not available today.

Control
without
exposure.

Set or revoke a member’s grant, adjust daily authority, and pause new payments. Already submitted transactions remain subject to reconciliation.

Yosh / Product demoPRODUCT / CONTROL
  1. Create a SpendGrant
  2. Agent requests a purchase
  3. Paid and delivered
Yosh in its notified state

Start with
a boundary.

Download the macOS Beta, then give your agent bounded authority.

v0.1.0 Beta · Apple Silicon · macOS 15+

Requirements and documentation

  1. Download the DMG

    Use the official Yosh v0.1.0 Beta download linked here.

  2. Move Yosh to Applications

    Open the DMG and drag Yosh into Applications. Eject the DMG afterward.

  3. Open Yosh

    Try launching Yosh from Applications.

  4. If macOS blocks the first launch

    Go to System Settings → Privacy & Security → Open Anyway, then confirm Open for Yosh.

  5. Set your first boundary

    Connect Codex through MCP and give the member a bounded SpendGrant before making a request.

This Beta is not Apple-notarized. Approve Yosh only if you trust this release; do not disable macOS security protections globally.

Clean-Mac installation and first-launch testing after an internet download are not yet complete.

Checksums and full release notes ↗

Permission
stays local.

The agent may request a registered resource. The wallet secret stays in macOS Keychain; the local backend controls validation, authority reservation, signing, and purchase state.

Read the boundaries

Through MCP, the agent cannot

  • Supply an arbitrary transaction.
  • Choose arbitrary payment terms.
  • Export the wallet key.
  • Change spending controls.

These are local implementation boundaries, not an independent security audit or protection against every compromised local process.

Every action
leaves a trace.

Yosh records who requested, the resource, amount, decision, execution mode, payment state, delivery state, and available transaction information.

Illustrative records · simulated · test USDC
RequestDecisionPaymentDelivery
Market SnapshotCodex · 0.20 test USDCApprovedNot startedNot delivered
Market AnalysisCodex · 20.00 test USDCDeniedNot startedNot delivered

No transaction in these examples: simulation does not start payment.

Yosh in its notified state

Permission
comes before
payment.

Yosh separates authority from payment execution. The current Beta uses x402 V2 on Solana Mainnet with native USDC; alternative payment rails are not implemented.

Read the boundaries.
Inspect the source.

Start with installation and Codex connection, then explore authority, accounting, and execution.

Yosh v0.1.0 Beta
Apple Silicon (arm64) · macOS 15+
No Node.js or source checkout required

Download for macOS ↗

Some repository guides retain older names and tool examples. Follow the current Yosh release notes when they differ. The official macOS Beta download is linked above.

Beyond
spending.

Today, Yosh governs bounded spending on registered demo resources. We are exploring how identity, authority, and execution could apply to broader economic actions.

RWA support is not available today.

Planned

  • Verifiable purchase confirmation in the agent conversation
  • Durable, bounded delivery retries
  • A third-party mainnet purchase path

Exploring

  • Broader economic actions
  • Richer permission policies
  • Additional agent integrations
  • Tokenized assets and RWA permissions

A few
clear answers.

Current capabilities, practical limits, and the difference between permission and payment.

17 / QUESTIONS

Read all questions