meeny

The core idea is that meeny is not a separate bot for each market. It is one agent that understands different market structures, evaluates opportunities on a common scale of expected value and risk, and routes execution to whichever venue or integration is appropriate. Stocks, crypto, memecoins, prediction markets, and sports all flow through the same reasoning loop.

That distinction matters because capital is finite. If a stock screener and a token scanner each run in isolation, nothing can tell you whether this week's best equity setup is actually a better use of a dollar than an event contract expiring on Friday. Fragmented tools produce fragmented decisions: duplicated exposure, uncoordinated risk, and no single answer to the only question that matters — where should the next dollar go?

meeny resolves that by separating reasoning from venue mechanics. The reasoning core is market-agnostic: it thinks in probabilities, expected value, and downside. Each MarketAdapter then translates that intent into the specifics of a venue — an order type on a brokerage, a swap route on-chain, a contract on an event market. Adding a new market means writing an adapter, not another strategy.

The practical consequence is that one mandate governs everything. A single drawdown limit applies across all five market classes, one portfolio view reflects every account, and one audit trail explains every decision. You change the risk budget once and every market respects it immediately.

A handful of primitives show up throughout these docs. Everything else composes from them.

Being explicit about the boundaries is as useful as the feature list. meeny deliberately does not try to be these things:

Four commitments shape the architecture. When a tradeoff arises, these decide it.

The fastest way to understand meeny is to run one cycle end to end. The four steps below install the SDK, authenticate, add buying power, and execute a single pass of the reasoning loop. Start with autoExecute: false — meeny will research and rank without placing anything, which is the right way to read its judgment before delegating capital.

meeny.run() returns a plan, not just a list of tickers. Each entry in rankedOpportunities carries the score that earned it a place, the market it came from, the size meeny would allocate, and the mandate checks it passed. Reading a few of these side by side is the quickest way to calibrate whether the agent's priorities match yours.

Each market has its own microstructure, liquidity profile, settlement mechanics, and data. meeny abstracts these behind a common MarketAdapter interface: the reasoning core stays market-agnostic, while adapters translate its intent into venue-specific orders.

The adapter for each market absorbs these structural differences so the core never has to.

For equities, meeny blends fundamentals (valuation, growth, quality), technical structure, and event context (earnings, guidance, macro) into a single conviction score. It connects to a user's brokerage for holdings, quotes, and order routing, and understands allocation, spending, and net worth as part of the wider portfolio.

Crypto never closes, so meeny operates continuously. For established assets it weighs liquidity, on-chain flows, and market regime. For memecoins, it adds aggressive safety screening — liquidity depth, holder concentration, contract risk, and momentum decay — because the failure modes differ sharply from equities.

A prediction-market contract that settles at $1 if an event occurs is simply a tradable probability. meeny builds an independent probability estimate for the event, compares it to the market's implied odds, and takes the position when its edge clears costs and its risk limits.

Sports betting is handled as another probability market: meeny models outcome likelihoods from team/player data and situational factors, removes the book's vig, and bets only where its estimated probability beats the implied line by a configurable margin. Stake sizing follows the same risk core as every other market.

meeny is organized in three layers. The reasoning core holds the mandate, memory, and decision loop and is identical for every market. Market adapters translate the core's intent into venue-specific research and orders. The platform layer — MPP for data/execution/portfolio and Stripe for funding — provides the rails everything runs on.

The boundary between these layers is the important part. The core is forbidden from knowing venue specifics: it cannot reference a ticker format, an order type, or a chain. It only emits intent — “take this much exposure to this outcome at this price or better.” Adapters own every detail below that line.

This keeps the risky surface small. A bug in the crypto adapter cannot corrupt equity reasoning, and a change to the scoring model applies everywhere at once without touching a single venue integration. It also means the same mandate produces consistent behavior even as venues are added, replaced, or removed underneath.

Every opportunity collapses to a single comparable number — an edge-weighted, risk-penalized score. Conceptually meeny ranks candidates by expected value net of a downside penalty and transaction cost:

where p is meeny's estimated probability, σ is expected volatility of the outcome, λ is the risk-aversion set by your profile, and c is round-trip cost. Only positive-score ideas that also clear every hard limit survive to sizing.

Once an opportunity clears risk checks, meeny constructs an order for the target market adapter. Depending on your mandate it either proposes the trade for human approval or executes autonomously. Every fill returns a Receipt that is written to the portfolio and audit log.

Risk controls in meeny are not a post-trade report. They execute inside the decision path, so an order that would breach a limit is never constructed in the first place. This is a deliberate architectural choice: advisory limits get overridden, structural limits do not.

Limits come in two flavors. Hard limits are binary — breach one and meeny stops, no discretion involved. Soft limits shape behavior continuously, scaling position size down as exposure concentrates or uncertainty widens. Most day-to-day protection comes from the soft limits; the hard limits exist to catch the tail.

Each limit answers a different failure mode. Setting all of them is not redundant — they constrain different axes of risk.

Breaches are events, not silent no-ops. When a hard limit trips, meeny pauses the affected scope, writes a receipt explaining exactly which rule failed and with what values, and surfaces the pause in the activity timeline. Nothing resumes automatically — you decide whether to widen the limit, reduce exposure, or stay flat.

Soft limits behave differently: they do not pause anything. They reduce the size meeny is willing to take until the constraint is satisfied, and if the resulting size falls below the minimum viable position, the opportunity is simply dropped from the plan with the reason recorded.

When a user adds funds, meeny offers two paths. Pay with Fiat uses Stripe to accept cards, bank transfers, and Apple Pay, with Stripe handling identity verification, PCI compliance, and settlement. Deposit Crypto bridges assets from another chain or wallet. Either way, cleared balance becomes buying power the agent can deploy across markets.

Connect brokerages and wallets and meeny consolidates holdings into a single net worth, allocation breakdown, and spending view. This unified portfolio is not just reporting — it is the state the risk engine reads when sizing every new position.

Beyond a single mandate, you can spin up specialized agents — a Bitcoin agent, a Tesla agent, an Avalanche agent — each with its own strategy and live PnL, win rate, and trade count. Users can Copy an agent to mirror its trades or Counter to take the opposite side, all governed by the same risk core.

Money movement is delegated to Stripe, which carries PCI DSS Level 1 certification and runs identity verification. meeny never stores raw card data. Trade authority is bounded by your mandate, and every action is written to an append-only receipt log you can export or stream.

Configuration is declarative. The Mandate is the contract between you and meeny: it decides which markets are live, how aggressively to trade, how funding flows, and when a human must approve.

Every SDK call either returns a result or throws a typed MeenyError carrying a stable code. Codes are the contract — match on them rather than on message strings, which are meant for humans and may change.