Skip to content
Docs

Getting started.

From an empty terminal to an analysis whose every step you can trace. Install it, provision it, point it at data, then ask where a result came from. Around twenty minutes, and most of that is a download.

This guide owns the order and the reasons. Every command on it is documented in full, flag by flag, in the CLI reference, which is generated from the release and stamped with the version it documents.

Contents
01

Before you start.

Inflexa is a binary that runs on your machine. It brings the analysis environment and the method knowledge. You bring the data, and you bring the model.

Three things have to be true before it can do any work.

Docker or Podman
WhyEvery analysis step runs inside an isolated container. That is what removes the dependency fight: R, Python, Node, and the bioconda toolchain are in the image, and the analysis packages are in a store on your machine that the container mounts read-only.
If it is missingA hard gate. Setup stops instead of falling back, and the chat will not open.
A model you can reach
WhyInflexa does not ship an intelligence. It drives one. That means an account you sign into with a browser, or any Anthropic-wire or OpenAI-compatible endpoint, including one on your own hardware.
If it is missingSetup provisions everything else, then tells you the sign-in is still pending.
Disk for the images and packages
WhyThe prepared environment is two container images plus a package catalog, several gigabytes in total, fetched once and cached.
If it is missingNothing downloads without your consent, and the three transfers run in the background once you give it.

In one line: Docker or Podman · macOS, Linux, or Windows · Several GB disk for the images and packages.

There is no Inflexa sign-up, no license key, and no telemetry by default. The software is Apache 2.0 and it never phones us.

One command name is misleading. inflexa auth is for Inflexa Cloud, not for your model provider. Nothing in this guide needs it.
02

Install.

The script channel downloads a prebuilt binary. Inflexa itself needs no Node, no Bun, and no Python environment.

curl -fsSL https://inflexa.ai/install.sh | bash

Recommended. Downloads a prebuilt binary.

Confirm the binary is on your path:

inflexa --version

Full channel notes, including the Windows PowerShell installer, are on the install page.

03

Run setup.

One command provisions the whole local stack. It is interactive and it walks eight steps. It is also where problems show up first, so run it before you bring real data.

inflexa setup

Here is what each step asks, in the order it asks it.

1

How should inflexa reach models?

Two answers. Managed local proxy (CLIProxyAPI) is the default. Inflexa runs a small proxy container, and you sign into a provider account through it. Direct endpoint points Inflexa at a URL you already have.

This choice decides the next step, and only the next step. Postgres, resources, embeddings, reference data, and the sandbox are the same either way.

2

Authenticate

Under the proxy: setup opens a browser sign-in for one account kind. The choices are gemini, openai, claude, qwen, and iflow. The URL is printed and copied to your clipboard in case the browser does not open. Credentials land in your own data directory and are mounted into the proxy container, never baked into an image.

For a direct endpoint: setup asks for the /v1-terminated base URL, a provider slug such as anthropic or openai, and the wire protocol, which it infers from the provider unless you say otherwise. It also spots ANTHROPIC_* and OPENAI_* variables already in your environment and offers to adopt them, and it recognises a Claude Code apiKeyHelper credential command if you have one.

No key is written to disk. Inflexa stores the name of the variable, or the command that mints the token, and resolves it at run time.

3

Postgres

The durable workflow engine needs a database, so setup provisions one as a local container and asks for the username, password, and port. Take the defaults unless the port is already busy.

This is why a long run survives a reboot. Runs are checkpointed here, so they pick up where they stopped instead of starting over.

4

Default chat model

Under the proxy, setup lists the models your account can actually reach and preselects Auto, which resolves a sensible default at launch. Pin an id here if you want one specific model. You can change it later without another setup run.

5

Analysis resource allowance

One question: the maximum share of this machine, as a percentage, that analyses may use in total. Setup prints the cores and memory it detected and defaults to half of them, which leaves the rest for your editor and your browser.

The percentage becomes absolute cores and gigabytes on save. Per-step ceilings come from it, and the scheduler starts a step only when the budget has room for what that step declared.

6

Embeddings

Embeddings power semantic search over an analysis workspace. Four answers: the built-in bge-small-en-v1.5 model, which Inflexa downloads along with a pinned llama-server runtime; your own GGUF file; a remote OpenAI-compatible embeddings endpoint; or off.

The api-key mode talks to that endpoint directly and never through the chat proxy. Its secret travels only in INFLEXA_EMBEDDING_API_KEY.

7

Reference data

Setup offers a catalog of curated datasets: gene identifier maps, Reactome, WikiPathways, the MSigDB collections, CollecTRI, PROGENy, and others. What you pick is downloaded from the upstream publisher, verified, and mounted read-only into every sandbox at /mnt/refs.

Skip it here and add datasets later with inflexa refs download. Nothing is fetched without an explicit selection.

8

Sandbox images and packages

Three downloads, one consent. The runtime image carries R, Python, Node, and the bioconda command-line tools. The provisioner image is the builder that installs packages. The package catalog is the R and Python stack itself, which lives in a store on your machine rather than inside the image.

Together they are several gigabytes, so nothing starts until you say yes. Once you do, all three run in the background: chat and planning stay usable, and only an action that actually needs a sandbox waits.

Setup is resumable. If a step fails, setup records where it stopped. The next run offers to continue from that step and keep the answers before it, or to start again and ask everything. A completed run clears the checkpoint.

When it finishes it prints a summary: the proxy URL or the direct-connection variable, the Postgres DSN, the embedding backend, and whether the containers are already up. Confirm the picture with:

inflexa status
04

Setup without a terminal.

Every question setup asks can be answered ahead of time, so the same provisioning runs across a lab or a fleet with nobody at the keyboard.

Batch mode never prompts. Each unanswered question takes its default or fails. It is implied when there is no terminal, and forced with --yes.

inflexa setup --yes --config answers.yaml

The answers file is YAML, one key per decision point. A flag on the command line overrides the file for that one question.

connection:
  mode: direct              # cliproxy | direct
  provider: anthropic
  baseURL: https://api.anthropic.com/v1
  protocol: anthropic       # anthropic | openai-compatible
  model: <model-id>
postgres:
  user: inflexa
  password: <password>
  port: 5432
  database: inflexa
resources:
  sharePct: 60              # 1-100
embedding:
  mode: local               # local | api-key | off
refs: recommended           # recommended | all | [dataset-id, ...]
sandbox: true               # the one consent for the three transfers
runtime: docker             # docker | podman
answers.yaml. Every key is optional, and an absent key falls back to its default.

The flags a first provisioning usually needs:

--connection cliproxy|direct
How Inflexa reaches models.
--provider <name>
Under the proxy, the account kind to sign into. With a direct connection, the vendor slug recorded for the endpoint.
--base-url <url>
Direct connections only. The /v1-terminated endpoint root.
--model <id>
Pin one model for every model role. Required for a direct connection in a non-interactive run.
--auth-env <var>
Direct connections only. The name of the variable that holds the credential, not the credential itself.
--auth-command <cmd>
Direct connections only. A command whose output mints a refreshing token.
--resource-share <pct>
Share of this machine analyses may use, 1 to 100.
--embeddings local|api-key|off
Configure the embedding backend without prompting.
--refs <ids>
recommended, all, or a comma-separated list. The value is the download consent.
--sandbox
Start the two image transfers and the package-catalog transfer. The flag is the multi-gigabyte consent, and nothing downloads without it.
--runtime docker|podman
Pin the container runtime. A hard gate: if it is not ready, setup stops.
--no-auth
Skip the provider sign-in step.
--no-postgres
Skip Postgres provisioning.
--no-start
Provision without starting the containers.
--force
Re-pull images that are already cached.

The complete list, with defaults, is on inflexa setup.

Secrets never ride in an answers file. The schema has no key field and never will. A direct-connection key is read from INFLEXA_MODEL_API_KEY, or from ANTHROPIC_API_KEY or OPENAI_API_KEY when that one is unset. An api-key embedding secret comes from INFLEXA_EMBEDDING_API_KEY. Prefer the config file over --postgres-password, which is visible in argv.
A batch proxy sign-in stays pending. Provider OAuth needs a human in a browser, and a rotating refresh token cannot be pre-seeded across machines. So a batch run under the proxy provisions everything else, prints a notice, and exits successfully. The first interactive inflexa launch offers the sign-in.
05

Choosing a model.

Inflexa runs three model roles, and you can point each one at a different model. It is one of the few settings worth revisiting once you have watched a real run.

Chat
The conversation agent you talk to, and the sub-agents it spawns: literature review, planning, analogical reasoning.
Sandbox
The agents that write and run code inside containers, plus data profiling. Most of the tokens go here.
Utility
Bounded routing and classification work. A small, fast model is the right answer here.

Switch any of them from the command palette inside the chat. Press Ctrl+K, then pick Switch chat model, Switch sandbox model, or Switch utility model. The picker lists what your connection actually serves.

The sidebar has a MODELS section that names the model each role resolved to, so you never have to guess what reasoned about a step. Provenance records it per step as well.

Your key stays on your machine. Under the proxy it lives in your data directory. For a direct endpoint Inflexa stores a variable name, not a token.

06

How work is organised.

Five nouns. They map onto directories on your disk, which is the whole point: nothing is hidden in a service you cannot inspect.

Anchor
A folder you have used Inflexa in. Creating an analysis writes a .inflexa/id marker there, which is how Inflexa recognises the folder again after you move or rename it.
Analysis
The unit of work: a conversation, a set of input files, and zero or more runs. Its workspace lives at <folder>/.inflexa/analyses/<slug>/.
Project
An optional grouping of analyses. Nothing requires one.
Session
One conversation inside an analysis. An analysis can hold several, and a report gets its own.
Run
One execution of a plan. A run is a DAG of steps. Each step gets its own sandbox container and its own directory.

The workspace of an analysis looks like this:

your-data/
├── counts.csv                       # your files, untouched
├── metadata.csv
└── .inflexa/
    ├── id                           # the anchor marker
    └── analyses/
        └── dexamethasone-airway/    # one analysis
            ├── data/inputs/         # staged inputs
            ├── runs/
            │   └── <runId>/
            │       └── <stepId>/
            │           ├── scripts/     # the code the agent wrote
            │           ├── output/      # what that code computed
            │           ├── figures/
            │           ├── logs/
            │           └── notebooks/
            ├── reports/<reportId>/
            ├── report-sessions/
            ├── provenance.json
            └── provenance.json.sig.json

A step reads the whole analysis tree, but it can only write into its own step directory. A write outside it is refused before any I/O happens.

That boundary is what makes the run directory an honest record of which step produced which file. Reveal the tree in your file browser at any time with inflexa open.

07

Your first analysis.

Go to the data, start Inflexa, describe what you want to know. Bring a dataset you already know the answer to. It is the fastest way to find out whether you trust the tool.

Start it where the data is

Bare inflexa resolves context from the current directory. It prints a context: line naming what it resolved, and only then acts. In a folder it has never seen:

$ cd ~/data/GSE52778
$ inflexa
? Start a new analysis in /Users/you/data/GSE52778? › yes

Run it again in the same folder and the context line names the analysis instead, and it reopens that chat. With several analyses in one folder, it lists them and asks which.

To name the analysis and attach inputs in one shot:

inflexa new "dexamethasone airway" ./counts.csv ./metadata.csv

Both are documented at inflexa new. Add --project <name> to group it.

What happens next

Inflexa profiles the inputs first: shape, columns, types, and what each file appears to be. The result shows in the sidebar under DATA PROFILE, and it is what stops the agent guessing at your column names.

Then you describe the question in plain language. From there:

  1. It reads the relevant literature and queries the biological databases live: PubMed, Ensembl, Open Targets, ChEMBL, PubChem, GEO, ClinVar, the GWAS Catalog, ClinicalTrials.gov, STRING, FAERS, and EPA CompTox. It looks biology up instead of recalling it from training data.
  2. It proposes a plan: a DAG of steps, each with its method, its inputs, and the resources it needs. The plan arrives as a card you can open and read.
  3. It asks before it executes. y approves this run, a approves this class of action from now on, and n rejects it and lets you say why.
  4. Steps run in parallel where the DAG allows and the budget has room. The first step that fails, or that honestly reports it is blocked, cancels its siblings and stops the schedule.
  5. Results come back as files on your disk, with figures and tables drawn inline in the chat. A step that could not do its work says so instead of improvising.

Reports

Ask for a report and Inflexa spawns a report session, a second conversation whose only job is the write-up. It builds interactive pages from the artifacts the run produced. Walk between the parent conversation and the report it spawned with ← and →.

One instance per analysis. Opening the same analysis in a second terminal is refused with a plain message rather than two processes writing the same tree. Open or resume a different one.
08

The terminal interface.

A chat pane, a sidebar that tracks the state of the work, and a command palette. It is a modal, editor-style interface, so the keys are worth five minutes.

The sidebar

Six sections, each of which opens for detail:

SESSION
The open conversation and its handle. Activating the value copies the full session id.
ANALYSIS
The current analysis, its project, and its inputs.
DATA PROFILE
What Inflexa determined about your input files. Click to open the details.
RUNS
Every run on this analysis, with live progress on the active one. Click to inspect.
USAGE
Token usage for the session and its runs. Click for the breakdown.
MODELS
Which model each of the three roles resolved to.

Toggle the whole sidebar with Ctrl+B.

The command palette

Ctrl+K opens it. Everything the interface can do is in there, grouped by category, and it is fuzzy-searchable.

Analysis
Switch, create, list, rename, manage inputs, re-profile data, set project, open the output folder, delete.
Session
Switch session, switch to a report session, start a new conversation, rename, copy the session id, remove, restore, permanently delete.
Project
Create, list with analysis counts, and delete. Delete a project and its analyses become ungrouped, not deleted.
View
Status, theme, settings, the activity panel, browse artifacts, explore plan steps, show runs.
Provider
Switch the chat, sandbox, or utility model.
App
Show identity, quit.

Provenance lives under Analysis too: export PROV-JSON, export PROV-N, verify the database record, and verify the exported files on disk.

Keys

Ctrl+K
Command palette
Ctrl+B
Toggle the sidebar
Ctrl+G
Explore the steps of the latest plan
Ctrl+R
Toggle the live activity panel
Ctrl+N
Next item in the activity panel
Ctrl+U
Clear the input line
Ctrl+X
Leader key, for chorded bindings
Esc
Press twice while a turn is running to interrupt it
Ctrl+C
Abort
o
Open the most recent chart, figure, file, or report (chat pane focused)
←
Go to the conversation that spawned this report
→
Go to the report this conversation spawned
y a n
On an approval prompt: approve once, approve always, or reject
/quit
Leave. /exit, /q, and /bye also work.

Every key in that table is remappable. Put a keybinds object in config.json, keyed by command id, like "app.command-palette": "ctrl+p". Keybindings load once, so restart to apply an edit.

09

Inputs and datasets.

Inputs are attached by reference and staged into the analysis workspace. Your original files are never modified.

inflexa inputs ls
List the analysis's current inputs.
inflexa inputs add <paths...>
Attach files or folders. They can live anywhere on disk.
inflexa inputs remove <paths...>
Detach inputs.

Each takes --analysis <id|name> when the folder holds more than one. Inside the chat, Manage inputs in the command palette does the same job and re-profiles afterwards.

Pulling a GEO series

Inflexa can fetch an NCBI GEO series straight into the analysis folder, so you do not have to hunt down the right supplementary file yourself:

inflexa geo download GSE52778

There is a per-series size ceiling. Raise it for a large series with --max-size 64GB. See inflexa geo download.

10

Runs, sessions, and what they cost.

Runs are checkpointed in Postgres. If the process dies, the machine reboots, or you close the laptop, the run picks up where it stopped instead of starting over.

inflexa ls
List recent analyses. --project <name> narrows it.
inflexa resume <id|name>
Reopen an analysis's chat.
inflexa open <id|name>
Reveal its workspace in your file browser.
inflexa status
Print what bare `inflexa` resolves to right now, plus the model connection.
inflexa project new <name>
Create a project. --description and --tags are optional.
inflexa analysis set-project <analysis> [project]
Move an analysis between projects, or omit the project to ungroup it.

Token usage

Usage is recorded per call and attributed to the model that served it and the agent that made it. Four views, from coarse to fine:

$ inflexa usage                        # totals, by served model and by agent
$ inflexa usage sessions               # what each conversation consumed
$ inflexa usage runs                   # what each run consumed
$ inflexa usage steps --run <id>       # what each step of one run consumed

--run accepts a trailing abbreviation of a run id, so you rarely need to paste a whole UUID. All four take --analysis <id|name>.

11

Provenance.

This is the part that matters. Every file Inflexa produces carries a record of the commands and inputs that produced it, and of which model reasoned about each step.

Ask where a result came from

Lineage walks the recorded graph. It takes the analysis, then what to trace: a file path, a content hash or a prefix of one, a search string over paths and commands and tools, or a record identifier. A bare filename is enough.

inflexa prov lineage my-analysis volcano.png

By default it walks backwards, towards the inputs. --forward asks the opposite question: what was derived from this file. --depth <n> bounds the walk, and --format switches between tree, json, dot, and mermaid, so you can drop the graph straight into a figure.

Export and verify

Export writes into the analysis workspace by default, as PROV-JSON or PROV-N. A JSON export is signed, and an attestation is written alongside it with a content digest and an Ed25519 signature.

$ inflexa prov export my-analysis
Wrote json provenance for "my-analysis" to …/.inflexa/analyses/my-analysis/provenance.json
Wrote verification attestation to …/provenance.json.sig.json
 
$ inflexa prov verify my-analysis          # the chain and signature in the database
$ inflexa prov verify-file provenance.json # the exported file, no database needed

verify-file is the one to hand to somebody who does not trust you. It checks an exported document against its .sig.json offline, with no account and no access to your machine.

--format provn emits PROV-N instead. --output <file> writes somewhere other than the workspace. PROV-N is a lossy re-serialisation, so it is not signed.

What the signature does and does not claim. It certifies the document. A verifier can prove the exported record was not altered after signing, and its artifact hashes are recomputed from the bytes on disk. It says nothing about whether the sandbox reported its own file operations faithfully. Those edges are self-reported by code running inside the container. We would rather say so than let you over-claim it in a paper.
How the provenance model works
12

Reference data.

Curated datasets downloaded from their upstream publishers, verified, and mounted read-only into every sandbox at /mnt/refs. Analyses use them without touching the network.

inflexa refs list
Catalog options, links, sizes, and what is installed locally. --urls prints every upstream URL. --json emits machine-readable output.
inflexa refs download [ids...]
Download and verify. Omit the ids for an interactive picker. --force re-fetches an installed dataset.
inflexa refs verify [ids...]
Check installed datasets without changing them.
inflexa refs path
Print the host path of the reference store.

The catalog covers gene identifier maps for human, mouse, and rat, plus UniProt mappings, Reactome, WikiPathways, the MSigDB collections, CollecTRI, and PROGENy. A subset is flagged as recommended, which is what --refs recommended installs.

Absence is a normal condition. A skill that wants a dataset you have not installed reports that and continues with what it has. It does not quietly substitute a different resource, and it does not invent a path.
13

The sandbox and packages.

Every step runs in a container that cannot reach the network and cannot write outside its own directory. The R and Python packages come from a store on your machine, not from the image, so adding one takes a command instead of a rebuild.

inflexa sandbox status
The two images, their registry references, whether each is present locally, and the state of any live transfer.
inflexa sandbox pull
Start the two image transfers, the runtime image and the provisioner image, and return at once.
inflexa store download
Start the transfer of the published package catalog, or say why none is needed.
inflexa store add <package>
Resolve and install one package from PyPI, CRAN, or Bioconductor, then link it into the analysis. Add --analysis to name a different one, or --lang to pick the ecosystem.
inflexa store link <packages...>
Link packages the store already holds into one analysis. No download and no container, so it is immediate.
inflexa store ls
The packages, the per-analysis package sets, any install in flight, and the disk use.
inflexa store reclaim
Delete store content that no analysis references any more. It previews before it removes anything.

What each container gets, and what it does not:

User
Non-root. The workload runs as an unprivileged uid.
Capabilities
All Linux capabilities dropped, plus no-new-privileges, so none can be regained.
Network
Egress denied by default with an in-container firewall rule. The exec port is published to loopback only.
Filesystem
The analysis tree is mounted read-only. Only the step's own directory is writable. The package store, the analysis's own package set, and reference data are all read-only.
Resources
CPU and memory ceilings derived from the machine allowance you set during setup.

The image itself carries R, Python, Node, and the bioconda command-line tools, and no analysis package at all. Those live in the store, and each analysis gets its own package set out of it, so two analyses on one machine can hold different versions of the same package without either one moving. The agent reads that set before it writes code, and when the plan needs something the store does not have, it asks you for it one package at a time. A run links what it was given. A run never installs.

More on the sandbox
14

Settings and where things live.

An interactive settings screen for the handful of things worth changing, and a documented path for everything Inflexa writes.

inflexa config

It edits five things:

Telemetry
Off by default. On, it exports structured log records (event types, ids, lengths, error types) to your own OTLP endpoint. Message, prompt, and code content is redacted before anything leaves the machine. There is no Inflexa endpoint to send it to.
Theme
The colour theme of the terminal interface.
Container runtime
Docker or Podman.
Postgres connection
Host, port, database, user, password.
Embedding backend
Built-in model, your own GGUF, an api-key endpoint, or off.

Paths

Everything sits under two XDG bases, which default to ~/.local/share and ~/.config:

$XDG_DATA_HOME/inflexa/agent.db
Anchors, analyses, projects, and input references (SQLite).
$XDG_DATA_HOME/inflexa/logs
Log files, rotated daily, kept for seven days.
$XDG_DATA_HOME/inflexa/refs
Reference data, mounted at /mnt/refs.
$XDG_DATA_HOME/inflexa/models
Local embedding GGUF models.
$XDG_DATA_HOME/inflexa/cliproxy/
Proxy config and provider credentials.
$XDG_DATA_HOME/inflexa/postgres
The Postgres data directory.
$XDG_CONFIG_HOME/inflexa/config.json
Settings.
$XDG_CONFIG_HOME/inflexa/auth.json
Inflexa Cloud session tokens, if you ever log in.
$XDG_CONFIG_HOME/inflexa/prov_key.json
The Ed25519 keypair that signs provenance.

Analysis artifacts are not here. They live beside your data, under .inflexa/analyses/ in the folder you started the analysis in.

The full path table is at Environment.

Environment variables

INFLEXA_MODEL_API_KEY
The credential for a direct model connection. Tried first. Unused under the managed proxy.
ANTHROPIC_API_KEY
Fallback for a direct connection with provider anthropic, when INFLEXA_MODEL_API_KEY is unset. Read from the environment only, never persisted.
OPENAI_API_KEY
The same fallback for every other provider.
INFLEXA_EMBEDDING_API_KEY
The credential for api-key embeddings. The only channel that secret travels on.
INFLEXA_LOG_LEVEL
trace, debug, info, warn, error, or fatal. Defaults to info.
OTEL_EXPORTER_OTLP_ENDPOINT
Where log records go. Requires telemetry to be enabled in inflexa config.
INFLEXA_NO_UPDATE_NOTIFIER
Set to anything to silence the new-release notice.
XDG_DATA_HOME
Moves the database, logs, references, models, proxy state, and Postgres data.
XDG_CONFIG_HOME
Moves the config, the auth file, and the provenance key.
15

Maintenance.

The containers, the anchors on disk, and upgrades.

inflexa up
Start the infrastructure containers: the proxy and Postgres. Launching the chat does this for you.
inflexa down
Stop them. --delete-data also deletes the Postgres data and proxy credentials, and asks first.
inflexa repair [path]
Reconcile the anchor marker in a folder. This is the fix when a folder was copied rather than moved.
inflexa relocate [from] [to]
Re-point a moved anchor. --from and --to rewrite every anchor under a path prefix at once.
inflexa prune
Drop anchors whose folders are confirmed gone.
inflexa upgrade
Install the newest release, or name the command that does for your install channel.
inflexa auth is not the provider sign-in. inflexa auth login, logout, and whoami manage an Inflexa Cloud account through a device flow. Local use needs none of them. The model provider sign-in is part of inflexa setup.
16

When it does not just work.

The failures people actually hit, and what each one means.

Docker or Podman is required but was not found
Inflexa cannot run without one. Install it, make sure the daemon is running, and make sure your user can talk to it. On Linux that usually means membership of the docker group. Setup stops instead of falling back, deliberately: a silent fallback would run your analysis somewhere you did not agree to.
CLIProxyAPI isn't authenticated yet
The provider sign-in has not completed. On a terminal, launching the chat offers it inline. Otherwise run inflexa setup and finish signing in, or re-run it with --provider <name> to sign in again.
Setup failed partway through
It recorded where it stopped. Run inflexa setup again and choose to continue from that step, which keeps the answers before it. Choosing to start again asks everything.
The first run is slow
It is fetching the two sandbox images and the package catalog, which is the R, Python, and bioconda stack. That happens once, it is confirmed before it starts, and it runs in the background, so it never surprises you or blocks the chat.
"…" is already open in another instance
One process per analysis, so two instances can never write the same tree. Open or resume a different analysis, or close the other window.
This folder looks like a copy of a tracked folder
The .inflexa/id marker was duplicated rather than moved, so two folders now claim one identity. Inflexa refuses to guess which is which. Run inflexa repair to re-mint the copy, or inflexa relocate if the original simply moved.
Analyses are using too much of my machine
Re-run inflexa setup --resource-share <pct> with the share you want, or edit harness.resourceLimits.budget in config.json. The percentage resolves against the detected machine and is stored as absolute cores and gigabytes.
A run stopped with a blocked step
That is an honest terminal state, not a crash. The agent declared it could not do the step and gave a reason instead of inventing one. Read the reason, fix the input or the resource it named, and ask again.
Does it phone home?
No. There is no account, no license check, and telemetry is off by default. Turned on, it exports redacted log records to your own OTLP endpoint. There is no Inflexa endpoint to send them to.
If setup fails, that is a bug worth reporting. The code is open. If the answer is not here it is in the source, and if the tool is wrong we would rather hear about it than not.
17

Where to go next.

Two places worth your time, plus the pages behind the machinery.

CLI reference

Every command, argument, and flag in v0.23.3, with usage and defaults. Generated from the release, so it cannot drift from the binary you installed.

Tutorials

Public datasets analysed end to end: the prompts exactly as they were typed, the decisions as they came up, and the full generated report.

The skill packs the agent reads, the databases it queries, and the provenance model each have their own page: Skills, Databases, and Provenance.

Read the sourceReport a bugAsk a question