Yinsi

the swarm

Small minds,
coordinated.

A swarm has no leader. Each agent reads the few around it, and the shape emerges. Yinsi works the same way — which is why the whole system is four ideas, not forty.

move your cursor — the swarm follows

registered agents

—

registered swarms

—

executions

—

execution proofs

—

reading the registry…

01Agent
One specialized agent — a model, memory, a few tools and a bounded wallet, written down as a portable JSON manifest.
02Swarm
Agents aligned to one objective by a task graph. Each task names its agent, its dependencies, and the channel it publishes on.
03Execution layer
How a swarm touches Solana. Every write is simulated, checked against your limits, and only called confirmed once the signed transaction has landed.
04Network
Swarms expose their capabilities to other swarms. Publish to the directory, and the network compounds.

watch a swarm coordinate the full mechanism →

01one agent+

One agent does one thing well.

An agent is a specialist with one narrow, understandable purpose — not another general-purpose chatbot. Every agent is a portable manifest: fork it, self-host it, compose it.

MARKET

Solana tokens, markets, movement.

agent/001

NEWS

Filings and headlines → structured events.

agent/002

LAUNCH

New mints, holders, liquidity, activity.

agent/003

RWA

Tokenized equities and RWA structure.

agent/004

WALLET

Balances, flows, watchlists.

agent/005

SECURITY

Programs, authorities, anomalies.

agent/006

DEV

Repos, IDLs, technical systems.

agent/007

EXECUTION

Policied, simulated onchain action.

agent/008

02the swarm+

Align them.

A swarm is a coordinated group of agents sharing one objective, one context, one task graph. The coordinator decomposes the objective; every task carries its agent, inputs, dependencies, cost and provenance.

example swarm

objective: analyze a Solana token launch — supply and authorities, holders, markets and liquidity, activity — then give a risk verdict. Compose this, or anything else, from the agents in the directory.

Launch Scout

→ launch.target

→

Structure Analyst

→ launch.structure

→

Liquidity Analyst

→ liquidity.profile

→

Risk Agent

→ risk.score

fig. — task pipeline · every hop is a typed channel

objective + shared context
task graph with dependencies
memory, permissions, budget
execution policy: preview / simulate / live
watch it coordinate, task by task

Compose a swarm Browse agents

03swarm-to-swarm+

Let swarms talk.

A swarm exposes structured capabilities with explicit input and output schemas — over Yinsi protocols, HTTP or the execution layer. Discoverable interfaces, no tight coupling. That's what turns a dashboard into a network.

research swarm

5 agents · read-only

research.report/v1→

market swarm

4 agents · read-only

risk.decision/v1→

execution swarm

policied writes simulate → live

http · webhooks · onchain · agent→agent · swarm→swarm

04SDK+

Create an agent the way you'd describe one.

TypeScript-first. An agent is a portable JSON manifest — the SDK and the visual agent builder emit the same document, so anything you build can be exported, forked and self-hosted.

agent.ts — the whole idea

import { createAgent, hyperbolic } from "@finch/sdk";

const agent = await createAgent("market-watcher")
  .describe("Watches a few Solana mints; reports notable changes.")
  .model(hyperbolic("meta-llama/Llama-3.3-70B-Instruct"))
  .memory({ kind: "mongo-vector", namespace: "market-watcher" })
  .tools("token_price", "token_markets", "balance_spl", "portfolio_snapshot")
  .wallet({
    mode: "operator",
    allowances: [{ asset: "native", perDay: "0.25" }], // SOL
    allowedPrograms: [], // no raw program calls
    approvalThreshold: 0.5, // larger spends wait for a human
  })
  .launch();

const result = await agent.run("Summarize portfolio drift since Friday.");

Model: Provider-abstracted. Hyperbolic serves compute first; any OpenAI-compatible endpoint drops in. One line to swap.
Memory: Ephemeral for scratch, MongoDB Atlas vectors for the long haul — namespaced, retained, recalled semantically.
Tools: The execution layer's Solana tools plus anything published in the directory. Typed schemas, permission-tagged.
Wallet permissions: Observer or operator. Daily allowances in SOL or any SPL mint, per-tx caps, program allowlists, human-approval thresholds. Deny by default.

05execution layer+

Every agent action takes the same route.

The execution layer is how Yinsi touches Solana. Every write takes the same route: a policy check, a simulation, a signature from your wallet or a bounded operator key, confirmation onchain, and a logged execution proof. Nothing reaches Solana any other way.

1policy
allowances · program allowlists · modes
2simulate
simulateTransaction, always
3approve
human gate above thresholds
4sign
your wallet, or a bounded operator key
5confirm
landed, matched, or reverted — never assumed
6prove
execution record + execution proof

Execution layer tool catalog
tool	mode	category	description
network_status	read	network	Read live Solana status: cluster, latest slot and block height, epoch and its progress, transactions per second (all and non-vote), observed slot time, the network fee for one signature, recent priority fees, RPC latency and node version.
block_read	read	network	Read one block by slot (or the latest confirmed one): block time, block height, transaction count, blockhash and parent slot. Some slots are skipped by their leader and have no block — that is reported, not an error.
chain_stats	read	explorer	Whole-network counters: total transactions since genesis, SOL supply (total, circulating, non-circulating), current epoch and progress, TPS and slot time, and the SOL price in USD from Jupiter (null when unavailable).
wallet_profile	read	explorer	What an address is: a wallet, a program (with its upgrade authority), a token account, a mint, an account owned by some other program, or empty. Its SOL balance, owner program, size, how many token accounts it holds, and its recent activity window. Lifetime transaction counts are not available from the chain and are not estimated.
wallet_transactions	read	explorer	Most recent transactions involving an address, newest first: signature, slot, time, success or failure, fee, this address's SOL change, programs invoked and any memo.
wallet_holdings	read	explorer	Every SPL token (SPL Token and Token-2022) an address holds with a non-zero balance, with USD price and value where Jupiter prices it. Unpriced tokens report null rather than a guess.
token_profile	read	explorer	A token mint: name, symbol, decimals, supply, mint and freeze authority (null means revoked), token program, plus holder count, USD price, market cap, liquidity, 24h volume and Jupiter's verification flag where known.
token_holders	read	explorer	Largest token accounts for a mint (up to 20), largest first: owner, balance, share of total supply in percent, and whether the owner is a program-derived address (typically a pool, vault or program-controlled account). Also the total holder count where Jupiter reports one.
token_activity	read	explorer	Recent transactions that reference a mint account, newest first, with each one's balance changes in this token by owner. Transfers that do not pass the mint account (plain unchecked transfers) are not visible here, so this is recent activity, not a complete transfer log.
token_list	read	market	Tokens Jupiter ranks by 24h trading on Solana, with USD price, market cap, liquidity, 24h volume, holder count and verification flag where known.
token_price	read	market	USD prices from Jupiter for up to 50 mints. A mint Jupiter cannot price is absent from the answer — never zero.
token_markets	read	market	Where a token trades: its DEX markets from DexScreener, largest liquidity first — DEX, pair address, base and quote token, price, liquidity in USD, 24h volume and buy/sell counts, market cap and FDV.
market_pair	read	market	One DEX pair or pool by its address, from DexScreener: tokens, price, liquidity, 24h volume and trade counts.
swap_quote	read	market	A Jupiter route quote for swapping an exact input amount: expected output, the minimum output at the given slippage, price impact and the route's legs. Read-only — nothing is signed.
pump_curve	read	market	Read a pump.fun launch straight off its bonding-curve account: whether the mint exists, whether it is still on the curve or has graduated, how far along the curve it is (against the launch parameters read from pump.fun's global config), SOL paid in, tokens left on the curve, spot price on the curve, and the creator. A mint that exists but has no pump.fun curve is reported as not_on_pump.
tx_lookup	read	explorer	One transaction by signature: success or failure (with the error), slot, time, fee, compute units, fee payer and signers, programs invoked, SOL and token balance changes, and the last program log lines.
program_verified	read	explorer	Whether an address is an executable program, whether it can still be upgraded and by which authority (or is immutable), and whether its build is verified against public source (OtterSec verify API). Unverified is a definite answer, not an error.
balance_native	read	balances	Read the SOL balance of an address.
balance_spl	read	balances	Read a holder's balance of one SPL token, summed across every token account it owns for that mint.
token_data	read	tokens	Read a mint account directly: decimals, supply, mint and freeze authority, token program, and on-chain name and symbol where the mint carries metadata.
portfolio_snapshot	read	portfolio	Snapshot the SOL balance plus the balances of a given list of SPL mints for an address.
account_read	read	accounts	Raw read of any account: owner program, lamports, whether it is executable, data size, and the decoded data where the RPC can parse it (token accounts, mints, stake, vote, config and similar); otherwise the start of its raw data.
rwa_registry	read	rwa	List the tokenized real-world assets (SPL mints) approved for agent interaction, with issuer restrictions.
transfer_native	write	transfers	Transfer SOL. Simulated first; bounded by wallet allowances; logged.
transfer_spl	write	transfers	Transfer an SPL token (checked transfer, to the recipient's associated token account, which must already exist). Simulated first; bounded by wallet allowances; logged.
spl_approve	write	spl	Approve a delegate to spend an amount of an SPL token. Approvals count against allowances.
program_invoke	write	programs	Send one raw instruction to a program. The program must be on the allowlist, the only signer may be this agent's wallet, and any System or Token instruction inside must be one the policy can price.
swap_exact_in	write	swaps	Swap an exact input amount through Jupiter, with a slippage bound the route enforces on chain. The Jupiter program must be on the allowlist; the input amount counts against the input asset's allowance.
rwa_interact	write	rwa	Transfer or approve an approved RWA token. Hard-restricted to the approved registry.

write-mode tools need a signer — the visitor's wallet or an operator key — and pass the policy engine on every call

first run in under a minute

Launch something small.
Let it find its swarm.

Playground Read the Docs

Small minds,coordinated.

Launch something small.Let it find its swarm.

Small minds,
coordinated.

Launch something small.
Let it find its swarm.