AI data analysis you can follow

Every analysis starts with an idea. Put it into words, then test it.

Upload your data and ask a question in plain words. BambooAI helps you set out what you think is going on, tests it step by step in Python, and then checks its own work. Every stage stays visible, so you can follow how the answer was reached.

Open source, MIT licenceAny model, hosted or on your own machineEvery analysis kept as a notebook

  1. Analysis of the idea

    The question

    Before any code runs, the Architect helps you put what you think into words: a brief with what the answer is for, what you expect to see and what else might explain it.

  2. Analysis of the data

    The analysis

    The analyst writes and runs Python one step at a time and reads each result before deciding what to do next. Every step is kept, including the ones that failed.

  3. Analysis of the work

    The checks

    Every number in the report is checked against the code that produced it, the work is run again from scratch, and the code map shows how each result was made.

After the analysis: next questions, memory and routines

Analysis of the idea

Work out the question first

Before any analysis begins, the Architect works with you to find the right framing of the question, or the right representation of the problem. Without it, an AI model makes that choice on its own, usually without saying so.

The Architect, an optional first step, framing a question about a cyclist’s best average power at each duration. On the right is the brief the analysis will be held to.
  • What your view rests on

    The reasons you give are checked against the loaded data and marked holds, does not hold or cannot be checked.

  • Saved analyses

    Earlier work you saved on the same subject is found and shown as exact quotes, each with its date.

  • Figure drafts

    A draft of each figure appears in the brief before anything runs, drawn on made-up numbers when only your data can give the real ones.

Analysis of the data

Work out the answer step by step

Each step of the analysis is visible as it happens, in full: the instructions the model received, its reasoning and working notes, the code it wrote, what that code printed and any attempt that failed.

The app after an analysis, with each step on the left and the report’s charts on the right.
  • Held to the brief

    What you expected and each other explanation are tested. If the data can’t give what the brief fixes, the analyst asks you instead of putting something else in its place.

  • Quick, Deep or Adaptive

    Pick how much effort a question deserves. Each mode has a budget of turns and cost, and the analyst knows it.

  • The context around the numbers

    It also reads the notes written alongside your data and the documents you attach, and cites each passage by its place in the source.

Analysis of the work

Check the work

An AI model can write a long analysis in minutes, much faster than anyone can read it closely. So BambooAI keeps a full record of the work, and when the analysis ends, it checks the report against it.

The code map traces each number back to your data. It is built by fixed rules, with no AI involved, and shows how a number was made, not whether it’s right.
  • The result and the brief

    The brief shows whether you saw what you expected, and what came of each other explanation.

  • Number checks

    Every number in the report is compared with what the code printed. One that doesn’t match is flagged, not silently corrected.

  • Replay

    The code behind the cited results runs again in a fresh Python session, and the numbers are compared with the first run.

  • The reach report

    It lists anything the code touched outside your data, and whether your question asked for it.

  • The reviewer

    In Adaptive mode, a second model with its own instructions reviews the evidence every eight turns.

  • Usage and logs

    Every model call is logged with its prompt, tokens, time and cost.

After the analysis

Next questions, memory and routines

An answer is rarely the end. What it found or left open leads to the next question, the analyses you save become the Architect’s memory, and a method that worked can be saved as a routine and run again on new data.

A routine made from one analysis and run month by month on new rides, without a model. Before its first run it reproduced the original analysis, and each run’s numbers are compared with the run before.
  • Next questions

    When a run ends, BambooAI suggests where to go next, based on what the analysis found or left open. A follow-up carries on where the run ended, and the workflow map shows every branch.

  • Memory

    The analyses you save become the Architect’s memory. Where they disagree, it says so and asks which way to go.

  • Routines

    Save a finished analysis as a routine and run it on new data without a model.

Branch from any point

An investigation can branch at several levels. You can return to an earlier question, explore a different hypothesis with the Architect, or try another analytical approach from a previous turn. Each new branch retains the context and work established up to that point, while the original path stays intact. This allows you to explore alternatives without starting over or losing what you’ve already learned.

One example drawn three times. On the workflow map, chain 3, “Why the dip in July?”, was asked from chain 1, beside chain 2. On its idea map the question and the idea, “I think it’s the heat”, are followed by step 3 said two ways: “Nothing else changed”, left behind, and “Fatigue from racing”, which goes on to step 4, “Less power when hot”. An arrow leads to its analysis map: turns 1 and 2, then a first way that pools all rides and reports, and a branch from turn 2 with the hint “Keep indoor rides apart” that reports in a turn of its own. In each map the way to what is on screen is lit, and the ways left are faint and kept.
  • Workflow map

    A useful finding often leads to another question. Rather than starting a new investigation, you can branch from an earlier chain and follow a different line of inquiry. The original work stays intact, while the new chain inherits the context that led to that point.

  • Idea map

    Framing a question often takes a few attempts. The Architect lets you revisit an earlier assumption, explore another hypothesis or change what you want to investigate. Once you’ve settled on a direction, the resulting brief can be passed to the Analyst.

  • Analysis map

    Sometimes an analysis takes a turn you want to reconsider. You might want to try a different method, challenge an assumption or follow an unexpected result. Return to an earlier turn and guide the Analyst in another direction. The Python state is restored to that point, so you don’t have to repeat the preceding work.

Every call accounted for

Every model call is recorded: which role made it, the model, the prompt, the tokens, the time and the cost. The usage view adds them up by analysis, role, model and day, and every figure comes from those records, not from a model.

One analysis in the usage view: what it cost, its tokens and model time, what each role spent, and every call on a timeline.
  • Each analysis, itemised

    What each question cost, how long it took and whether it reproduced, with the share each role spent.

  • Every call on record

    Each call keeps its role, model, prompt, tokens, time and cost, and the exact prompt behind any step is one click away.

  • Periods and exports

    Compare a period with the one before, break it down by role, model, mode or day, and export the records as CSV.

Framed, grounded and visible

Most of the work is in the question. It is framed with you, checked against the data and reframed, before the analysis and after it. The analysis is held to that frame and grounded in your data, and every step stays visible.

Your question

Your data

looked up

looked up

1 · Analysis of the idea

Framing, and reframing

The briefversion 1version 2version 3version 4version 5next question, version 1next question, version 2

  • What it is for
  • What you think, and why✓ holds,✕ does not hold,? cannot be checked
  • What you expect to see
  • What would change your mind
  • Other explanations to test

saved analyseshow it turned out, saved analyses

brief

brief

Your data

2 · Analysis of the data

Framed and grounded

  • Held to the brief
  • Each other explanation tested
  • Asks you if the data falls short
  • Step by step in Python, on your data
  • Failed attempts rolled back

written as it happens

written as it happens

The record, kept whole

everything the analysis did, as it happened, open to you and to the checks

  • The conversation, every brief version
  • The prompt behind every model call
  • Reasoning and working notes
  • Code, and everything it printed
  • Failed attempts, rolled back
  • Tokens, time and cost of each call

report

read by the checks

read by the checks

3 · Analysis of the work

Everything visible

  • Every number checked against the code
  • The work run again from scratch
  • Each number traced back to your data
  • What the code touched outside your data
  • How it turned out, against the brief

An answer you can check

How it turned out goes back to the question, to reframe it

  • Built for scrutiny

    AI-generated analysis should be open to the same scrutiny as any other analytical work. Reproducible calculations are part of that, and so are the question, the choice of methods, the assumptions and the interpretation, which still need a person to think them through.

  • Inspired by the notebook

    Analysts have long shown their work in notebooks: the code, what it printed and the notes, in order, in one Python session that keeps what each step built. BambooAI keeps every analysis that way, and that is what you read, what the checks test and what the replay runs.

  • Open and configurable

    BambooAI is open source, under the MIT licence. Use it hosted, or run it yourself and choose the model for each role, from the main providers or your own through Ollama or vLLM. Every part can be changed, down to the instructions each model follows.

Try it hosted, or run it yourself

It’s the same BambooAI either way. The difference is where it runs and which models it uses.

Hosted

Invitation beta

  • Nothing to install. It runs in your browser, on your own data.
  • Your code runs in a private sandbox, one per account.
  • Free to try on open models, with 20 queries a month. Stronger models and more computing power are pay as you go.

Open source

MIT licence, on GitHub and PyPI

  • The whole app runs on your computer. The code runs in a Docker container there, and your files stay with you.
  • Pick the model for each role: OpenRouter, OpenAI, Anthropic, Google, Groq, Mistral, xAI or DeepSeek, or your own models through Ollama or vLLM.
  • Prompts go to whichever providers you choose. Run every role on your own models and they stay on your network too.
pip install bambooai
bambooai serve

You’ll need Python 3.11 or newer and Docker. The README covers models, local hosting and everything else.

Invitation beta

The hosted version of BambooAI is in beta, and we’re inviting people in gradually. BambooAI is open source, bootstrapped and built in public, and the hosted app runs on limited compute, so we add people a few at a time.

If you’d like to try it, register your interest and tell us a little about your data. We review requests regularly and will get in touch if there’s a good fit.

Rather not wait? The open-source version needs no invitation.