AIMO Docs

Getting started ​

From an empty account to monitored tables and the first episodes. Each section links to deeper pages where needed.

Onboarding: five steps you run once, then the chain AIMO runs for every table you start monitoring Top row: five setup steps you run once, sign in to the web UI, register an agent, add database credentials in the agent CLI, run the agent, then analyze the connection and start monitoring tables. A rule marked 'on start monitoring' leads to a lower row of eight stages AIMO runs on its own for each table, from the agent's aggregates only: schema, time binding, column profile, monitor definitions, monitor values, the detector, episodes, and the table's health. Under each stage a label says whether it runs on the agent beside your database or on AIMO. YOU RUN ONCE IN THE WEB UI AND THE AGENT CLI 01 Sign in to the web UI 02 Register an agent 03 Add credentials in the agent CLI 04 Run the agent 05 Analyze, then start monitoring ON START MONITORING AIMO RUNS, FROM AGGREGATES ONLY Schema AGENT Time binding AIMO Column profile AGENT Monitor definitions AIMO Monitor values AGENT Detector AIMO Episodes AIMO Health AIMO
Two halves of onboarding: the five steps in the top row are yours to run once; everything in the lower row happens on its own for each table you start monitoring, on AIMO workers and the agent, from the agent's aggregates rather than raw rows.

The diagram maps the whole page. The top row is the one-time setup you drive from the web UI and the agent CLI. The moment you start monitoring a table, AIMO takes over the lower row: a fixed chain that builds the table's monitors and prices its whole history, entirely from aggregates the agent produced. You never hand raw data to the cloud to make this happen.

1. Sign up and sign in ​

Create an account and sign in to the web UI. Sign-in is by passkey; there are no passwords. You need an active session before you can register agents and work with connections.

2. Register an agent ​

Under Connections, press Add agent, give the agent a name and press Create agent (Register via agent is the default). The dialog then shows the docker run command, with its one-time registration token filled in, that runs the agent CLI in your environment so the agent can authenticate to AIMO. Copy the command from the UI: the image it names is the one built for the AIMO environment you are signed in to.

For keys, tokens, and what is written on disk, see Registration.

3. Add database credentials with the agent CLI ​

Credentials are added through the agent, not in the browser. During registration the register command generates an Ed25519 keypair, sends the public key to AIMO, and writes a helper script aimo_agent.sh next to your agent data (the directory you mount as /app/data in Docker, or the current directory otherwise). If it cannot write the file it prints the contents for you to save by hand. The script exports AIMO_AGENT_UUID, AIMO_AGENT_PRIVATE_KEY_B64, AIMO_AGENT_PASSPHRASE, AIMO_AGENT_HOST and AIMO_AGENT_USE_TLS, runs the agent image, and forwards CLI arguments, so you do not need to set those variables by hand for routine use.

Inspect the passphrase

register writes a random AIMO_AGENT_PASSPHRASE into the script. Connection credentials are encrypted with it, so review the script and replace the passphrase with your own before adding credentials. See Registration.

From the same directory as aimo_agent.sh:

bash
chmod +x aimo_agent.sh   # once
./aimo_agent.sh add      # interactive: name, database type, secrets; encrypts, tests, then stores via the API

add encrypts the credentials locally, tests the connection by decrypting that same blob, and stores the ciphertext only if the test passes. Use the same wrapper for list, show, test, edit and delete.

If you install the agent package directly (not Docker), use python -m aimo.agent.cli with the same subcommands and environment; see Agent CLI.

Supported databases

The agent connects through SQLAlchemy and ships first-class support for PostgreSQL (including Databricks Lakebase), MySQL, Microsoft SQL Server, Snowflake, BigQuery, Databricks, Amazon Redshift, DuckDB and SQLite. Each accepts either individual fields (host, user, …) or a complete SQLAlchemy URL. Use a read-only role; see Security.

Keep the agent process running when jobs should run against your data (./aimo_agent.sh start). See Operations and Registration.

4. Analyze the connection in the web UI ​

Open Connections, find the connection you added from the CLI and press Analyze connection. The agent reflects the schema and returns the table list with its columns and types, without reading rows, so you can choose tables before anything is profiled.

5. Choose tables and start monitoring ​

Open Tables. Each table in the catalog has a switch, Start monitoring. Switch on the tables you want, then confirm the pending changes with Start monitoring. AIMO assigns the monitors for those tables; you do not pick monitor types in the UI, and every generated monitor starts active, so what you decide afterwards is which to switch off. See Monitors.

After you start monitoring ​

AIMO dispatches one workflow that runs the same chain for each table you switched on (tables are processed in parallel). Where each step runs is marked in the diagram above.

  1. Schema analysis (agent): columns, types, keys and a small time-aware sample, so the steps below know the table's shape and how it advances over time.
  2. Time binding (AIMO, confirmed on the agent): the time column and cadence used to group rows into time blocks, or whole-table mode when there is no time signal, plus a description and any dimensions. The agent then proves the binding over the whole table: its range, that the table has rows, and that the column can be filtered efficiently.
  3. Column profile (agent): per-column value statistics from a sample of recent rows, over the same window the detector will later read.
  4. Monitor definitions (AIMO, validated on the agent): the platform floor (a row count and a missing-values check per column, pruned by the model for applicability), then the table-specific monitors in two independent samples and a final pass that looks for uncovered failure modes. Each batch is compiled and run on the agent against your schema and a sample of your data before it is stored.
  5. Monitor values (agent): every monitor computed for every time block in the table's history, block by block.
  6. Detector (AIMO): the expected value rolled forward through that history, and every block priced against it. Nothing is trained; see Outlier detection.
  7. Episodes (AIMO): suspicion accumulated block by block; where it crosses the account's alert level an episode opens, over past blocks as well as the latest.
  8. Health (AIMO): a per-table health snapshot, so Today's estate shows the table as soon as onboarding completes. The account briefing follows with the next run over the whole account: the daily run, or Recompute on Today.

Progress is visible in the sidebar, one bar per step; timing depends on deployment and data size.

From then on each table runs on its schedule: the agent reflects the schema and AIMO compares it with the previous block (a changed column becomes a schema episode), the agent computes the new blocks' monitor values, the detector and the episode check run again, the health snapshot and the briefing are rewritten, and the alerts are sent to your destinations. See Operations for what runs where.

See the product site for pricing and positioning.