RUNA DOCS

How Runa works.

Runa is a financial agent that can hold USDC, follow strategies and carry out actions on Arc. You connect your wallet, create one Runa and decide what she is allowed to do. The product is built around that relationship rather than around a separate account with its own login.

Getting started

Connect an EVM wallet on Arc. The first time you create a Runa, your wallet signs an ownership message. It is a message, not a blockchain transaction, and it does not move any funds.

After the signature is verified, Runa creates a separate agent wallet. You can fund that wallet with USDC and configure the rules that should apply to her actions.

One owner wallet, one RunaRuna is tied to the wallet that created her. Disconnecting the wallet does not create a new agent. When the same wallet connects again and signs in, the existing Runa is loaded with her balance, strategies, positions and activity.

Wallet ownership

Runa uses a signed nonce to prove that the connected wallet belongs to the person trying to access the agent. The nonce expires and cannot be reused.

Connect your wallet.
Runa asks the backend for a fresh nonce.
Your wallet signs a message containing that nonce and your address.
The backend recovers the signing address and checks that it matches the connected wallet.
If that wallet already owns a Runa, the existing agent is loaded.
If it does not, you can create a new Runa after signing the creation message.

The ownership signature is separate from a blockchain transaction. Runa does not use the signature as permission to spend funds from your owner wallet.

Runa's wallet

Runa has a separate wallet address. Your connected owner wallet and the agent wallet are not the same account.

Creating the wallet

During creation, the agent private key is generated and the encrypted form is stored by the Runa backend so the agent can sign autonomous actions. The plaintext key is returned once in the creation response and is shown in the browser so you can save your own backup.

Save the private keyThe creation screen lets you reveal and copy the key. It is not saved to localStorage, the activity feed or the public agent record. Treat it like any other wallet private key: anyone who has it can control the agent wallet.

Funding and withdrawals

Deposits move USDC from your connected wallet to the Runa wallet.
Withdrawals are restricted to the wallet that owns the Runa.
The agent wallet address can be shared when you want to fund it directly.

Autobot

Autobot is where you give Runa a strategy instead of a one-off task. The current build supports wallet following, factory hunting and custom strategies.

Wallet followTell Runa which wallet to follow, how much to copy per buy and whether sells should be followed. The strategy engine watches the tracked wallet and passes detected actions through the normal checks before execution.

Factory hunterGive Runa a factory address and a buy amount. The factory adapter handles the launch event and token details so you do not need to enter the event signature or token fields yourself.

Natural languageThe LLM is used to turn a request such as “follow this wallet and copy every buy with 10 USDC” into structured strategy data. The model does not receive private keys and does not execute blockchain transactions. Policy and execution stay in the deterministic backend.

User actions take priority over strategy automation. A manual sell, send or withdrawal is not silently overridden by a strategy.

Rules

Rules are checked before Runa can move USDC or execute an action that uses the agent wallet. They are limits, not suggestions.

Rule	What it controls
Daily spending	The maximum amount Runa can send through agent transfers during the current day.
Maximum transaction	The largest amount allowed in one transfer.
Approval above	An amount above this threshold is stopped as requiring approval. The full in-app approval queue is still being built.
Reserve	The amount you want to keep in the agent wallet. The current build stores this value, but the hard balance-floor enforcement still needs to be completed.
Agent status	Pausing Runa blocks agent transfers until the agent is enabled again.

The documentation only describes a guardrail as enforced when the current backend actually checks it. The reserve field is therefore not described as a hard safety limit yet.

How execution works

Runa keeps the model's interpretation separate from the part that is allowed to move money.

1. IntentA request is interpreted into structured data. For Autobot, the LLM can help translate natural language into a strategy draft.

2. PolicyThe backend checks the agent status, transaction limits, daily spending, approval thresholds and the other conditions required by the strategy.

3. ExecutionOnly an action that passes the required checks reaches the transaction executor. The executor uses the agent wallet to sign the transaction on Arc.

The LLM is not the transaction signer. It cannot spend from the wallet just because it understood a sentence.

Wallet security

The current build uses encrypted agent-key storage on the backend because Runa needs signing capability for autonomous execution. That is an important distinction: the owner signature proves who controls the Runa account, but the current agent wallet is still operated by the Runa service.

We do not describe the current build as non-custodial. A stronger version of the architecture would move signing authority into a design where the service operator cannot export the user's agent key, for example a suitable smart-account or isolated signing setup. That change needs to be implemented and tested before Runa makes that claim.

Private keys are not placed in frontend source code.
Private keys are not included in the public agent response after creation.
The one-time creation response is the only place the plaintext agent key is returned.
The key is not written to the activity feed or localStorage.
Owner authentication uses a fresh, expiring nonce.
The LLM does not receive wallet private keys.

Do not paste an agent private key into chat, Discord, Telegram, support messages or any other service. If a key is exposed, treat the agent wallet as compromised and move funds to a new wallet.

Current build

Arc Mainnet connection and network switching.
Owner wallet signing with expiring nonces.
Persistent Runa lookup when the same owner wallet reconnects.
Separate Runa agent wallet creation.
One-time private-key display during agent creation.
Encrypted agent-key storage for autonomous execution.
USDC deposits and owner-only withdrawals.
Wallet-follow and factory-hunter strategy drafts.
Natural-language strategy parsing through the configured LLM.
Policy checks before execution.
Activity, positions and strategy state stored with the agent.

Features such as a full approval queue, hard reserve enforcement and a signing architecture that removes the service operator from the agent-key trust boundary are not described as finished.

← Back to Runa app