> ## Documentation Index
> Fetch the complete documentation index at: https://docs.defiloops.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Connect a wallet, add money, describe a strategy, and press Run

This is the whole loop. Get an account, put money in it, say what you want,
check the plan, run it. Everything after that is a variation on these steps.

<Steps>
  <Step title="Connect a wallet you control">
    Open the **Accounts** page in the console and connect your wallet.

    <Warning>
      **If your account was created for you in the console, nobody holds its key.** The
      key was generated, the address kept, and the key itself discarded. That is enough
      for the agent to work through and enough for nothing else.

      Until you connect a wallet you control and prove it here, the way out exists in
      the contract and you are not the one who can walk it.
    </Warning>

    One decision here cannot be changed later: whether your owner is an ordinary
    wallet, a [Safe](/safe), or a passkey. That choice is baked into your account's
    address, so there is no migration. A different choice is a different account at a
    different address.

    An ordinary wallet is the default. It is also the only one of the three that is
    not marked unaudited.
  </Step>

  <Step title="Find your account address">
    The console shows you an address. That is your account.

    It is the **same address on every network**, so you only have to save one. It is
    also your deposit address. There is no separate deposit step, and money that
    lands there is yours before we do anything with it.
  </Step>

  <Step title="Add money">
    Send tokens to that address on Ethereum, Base or Arbitrum, from anywhere.

    You do not need to send network fees. A separate key of ours pays those, and it
    has authority over nothing else.
  </Step>

  <Step title="Say what you want, in ordinary words">
    Type the outcome, not the steps.

    > Move my USDC to Base and supply it to a lending market.

    > Buy this property, then every month split the rent between paying down the
    > debt and buying more collateral.

    > Buy cbBTC, but only at 80,000 or better, and let it fill in pieces.

    The agent works out which network, which market, which pool, what to approve, and
    what order things have to happen in so money is not stranded halfway.

    <Tip>
      If you are not sure something is possible, ask before you plan. The agent can
      check which assets, networks and operations exist first. "Can I do this?" is
      usually really "can I do this on that network?"
    </Tip>
  </Step>

  <Step title="Read the plan before you save it">
    You get back a numbered list of steps. Each one names the operation it uses, the
    network it lands on, the amount, and where the value goes next.

    Every amount appears twice: once as the raw number the machine uses, and once as
    "0.5 ETH" in plain units. **Read the plain-units column.** A plan where every
    amount is a thousand times too small is consistent with itself and passes every
    other check, so this is the one that catches it.

    Saving a plan runs nothing.
  </Step>

  <Step title="Press Run">
    Now it spends.

    You can close the tab. The record of what has happened lives in a database, not
    in the memory of a running process, so the run survives you leaving and survives
    us shipping an update mid-run. → [How a run works](/platform)
  </Step>

  <Step title="Expect it to stop and ask">
    Stopping to ask is a normal outcome, not a failure.

    It retries very little on purpose: a fee bump for a stuck transaction, and a
    couple of attempts where the cause can clear on its own. Past that it waits for
    you, because most real problems need a decision rather than another identical
    attempt.

    To carry on, tell it to continue. One instruction covers this, and it works out
    what you meant by looking at the run.

    | the run          | what happens                                      |
    | ---------------- | ------------------------------------------------- |
    | has not started  | it starts                                         |
    | stopped part way | it picks up from the steps that already completed |
    | finished         | it runs the same plan again                       |
  </Step>

  <Step title="Make it keep going">
    A plan you press Run on is the simple case. Three things can start one for you.

    <CardGroup cols={3}>
      <Card title="A schedule" icon="clock">
        Starts on a clock. *Collect the rent on the first of every month.*
      </Card>

      <Card title="A price trigger" icon="chart-line">
        Starts at a price. *Buy if cbBTC comes back to 80,500.*
      </Card>

      <Card title="A chain" icon="link">
        Starts when the plan before it finishes. *Buy the property, then start the
        monthly loop.*
      </Card>
    </CardGroup>

    None of them agrees to anything in advance. Each one rebuilds and re-prices the
    plan when it fires, so a schedule set up in March does not carry March's prices
    into June.

    Saving a schedule does not switch it on. Switching it on is its own press,
    because from that moment it spends without asking you again.
    → [Running it without you](/automation)
  </Step>
</Steps>

## What to read next

<CardGroup cols={2}>
  <Card title="Words we use" icon="compass" href="/concepts">
    Network, plan, step, wave, bite. Ten minutes, and the other pages get easier.
  </Card>

  <Card title="Your account and your keys" icon="key" href="/kernel">
    How to leave without us, what a stolen key of ours can do, and the honest
    limits.
  </Card>

  <Card title="Sizing a trade" icon="chart-line" href="/routing">
    Read this before setting a limit on a large swap.
  </Card>

  <Card title="Everything it can do" icon="list-check" href="/adapters/catalogue">
    The current list of operations and the networks each runs on.
  </Card>
</CardGroup>

<Note>
  **On the demo, no real money moves.** The networks there are copies of the real
  Ethereum, Base and Arbitrum, frozen at a moment in time. A run spends play money
  while everything it touches behaves as the real thing does. The same software
  pointed at the real networks spends real money.
</Note>


## Related topics

- [FAQ](/faq.md)
- [DeFiLoops](/index.md)