Book a demo

07 / 07 — OrbisEarly access

Give the work an agent.

The agentic engineering workspace for calibration, measurement and ECU software.

Orbis is a local-first desktop workspace where an AI agent inventories your calibration drop, queries million-line A2Ls without opening them, runs your scripts in a real terminal, and hands back every file change as a diff you approve before it lands.

Request early access See a session, end to end

In pilot with Tier-1 powertrain teams

Orbisproject · wltp_cutoff Live
You

Compare the hot WLTP run against the cold baseline. What is the cut-off strategy leaving on the table?

  1. drop_intake./drop_2026_097 files · 0 blockers
  2. a2l_search/DFCO|SA_DFC/12 labels
  3. a2l_lookupDFCO_nlow1 150 rpm · flashed
  4. mdx.extractnmot, tqi, fuel_cut3 channels
  5. terminalpython cutoff_assess.pyexit 0 · 4.2 s
Proposed change · cal/patch_07.dcm
- DFCO_nlow  1150
+ DFCO_nlow  1050
transcript · A2L tools · real PTY · diff review gate · MCP
Platform
Native desktop — macOS, Windows, Linux
Domain tools
drop_intake • a2l_search • a2l_lookup
Agent interop
MCP host and client, ACP, local JSON-RPC gateway
Models
Anthropic, OpenAI, Gemini, xAI, DeepSeek, OpenRouter — or fully local via Ollama / LM Studio

Capabilities

Eight capabilities that make an agent usable on real vehicle work.

  1. G1

    Drop intake that refuses to guess

    Point Orbis at a measurement or calibration drop and it classifies every file — measurement, cal image, cal patch, specification, bench report, prior analysis — then blocks on anything unclassified, still archived, or symlinked away. Unnoticed files have reversed whole analyses; intake is designed so they cannot.

  2. G2

    A2L queries without reading the A2L

    A production A2L runs to millions of lines and a single MF4 to two gigabytes. Orbis never hands those to the model. a2l_search finds labels by regex, a2l_lookup returns type, axes, units — and, with a HEX image, the value currently flashed, decoded to physical units.

  3. G3

    A real terminal, not a simulation

    A native PTY with full VTE behaviour runs your build scripts, HiL suites, pytest runs and conversion jobs. Output streams back into the transcript as context the agent can reason about, not as a screenshot you have to retype.

  4. G4

    Nothing lands without a review gate

    Every write, patch and command surfaces as a diff or a command preview with four honest answers: allow once, allow for this session, always allow, or deny. Approval is per-tool and per-scope, and the decision is recorded with the turn.

  5. G5

    Skills that carry your method

    A skill is a written procedure the agent loads on demand — your cut-off opportunity assessment, your WLTP comparison rules, your release checklist. Orbis shows which skill fired on which turn and where its output came from, so a conclusion is traceable to the procedure that produced it.

  6. G6

    The suite is already wired in

    Orbis speaks MCP in both directions: it hosts tools for other clients and consumes MDX, Hexx and HELIX as tool servers. Measurement channels, binary edits and release sets become things the agent can query, not files you shuttle between windows.

  7. G7

    Local by construction

    Orbis runs on your workstation, against your files, with your model — including a model served entirely inside the building by Ollama or LM Studio. Air-gapped teams get the same workspace as connected ones, with no mandatory egress.

  8. G8

    Sessions you can come back to

    Conversations, artifacts, terminal history and approvals persist per project. Resume a session a week later, search across every session you have run, or hand one to a colleague with the whole tool trail intact.

A SESSION, END TO END

What an engineer actually does with Orbis.

Two turns from a fuel cut-off study: the question in plain engineering language, the tools it fired, the point where Orbis refused to continue, the gate that held the write, and what finally landed on disk. Nothing happens off-screen.

Project EU7 coast-phase study Model local — LM Studio Workspace ~/drops/2026-09-WLTP
Calibrationengineer

Here is the September drop. Compare the hot WLTP run against the cold baseline and tell me what the injection cut-off strategy is leaving on the table.

drop_intake ~/drops/2026-09-WLTP 1.9 s — 4 blockers 43 files — 6 measurement, 2 cal image, 1 cal patch, 4 specification, 2 bench report, 1 prior analysis
Orbis stopped before analysing anything. Intake raised four blockers: rig_export_0912.zip is still archived and could contain an undisclosed sub-drop; three files under /misc could not be classified. Unclassified files are not skipped quietly here — three emission-bench runs once sat unnoticed in a subfolder and reversed the conclusion of an entire analysis, so intake blocks until every file has a class.
Calibrationengineer

The zip is a duplicate of the bench export — ignore it. The three under /misc are emission-bench runs from the same week. Carry on.

drop_intake re-run with the three runs reclassified 2.1 s 0 blockers — hot and cold WLTP runs paired, comparability confirmed before any delta is quoted
a2l_search pattern: InjCutOff.* 0.2 s 17 labels returned — no label is ever guessed, only confirmed
a2l_lookup InjCutOffMngr_nEngThres_CUR + prod_eu7.hex 0.3 s CURVE — 6 axis points, rpm to threshold, flashed values decoded to physical units
read_file specs/Injection_Cut_Off_Manager.pdf, specs/Engine_Speed_Scheduling.pdf 4.4 s re-injection speed, temporal scheduling and cylinder-cut conditions read from the specification, not from the prior analysis in the drop
skill cutoff-opportunity-assessment loaded the team's own written procedure — coast-phase decomposition, lever ranking, hot-vs-cold caveat, data-gaps section
terminal python analysis/coast_phases.py --hot run_04.mf4 --cold run_01.mf4 38 s — exit 0 native PTY — the numbers in the report come from a command you can rerun
Review gate — write_file analysis/2026-09-cutoff-register.md — new file 
+ ## Ranked opportunity register (confidence-tagged)
+ 1. Re-injection speed threshold — HIGH confidence, coast fuel recovered below 1,250 rpm
+ 2. Cut-off entry debounce — MEDIUM, shortens the delay into DFCO on tip-out
+ 3. Selective cylinder cut in low-load coast — LOW, needs NVH sign-off
+ ## Caveat: hot and cold cycles are not directly comparable on catalyst-heating phases
+ ## Data gaps: no cylinder-pressure channel in either run
Allow once Allow for this session Always allow write_file Deny
One file landed, and only because you said so. The register is ranked, every claim is tagged with confidence, the hot-versus-cold caveat is stated rather than buried, and the missing cylinder-pressure channel is recorded as a gap instead of being modelled around. The session — prompts, tool arguments, terminal output, the approval you gave — stays on disk next to the drop.

Illustrative session. The tool names, their arguments, the file classes and the four permission choices are the real ones; the drop and its numbers are a worked example.

THE WORKSPACE, PANE BY PANE

Seven surfaces, and an honest note on each.

Orbis is deliberately small. Each pane exists because an agent working on vehicle data needs it; where a pane stops, we say so rather than implying it goes further.

01

Transcript

The conversation and the tool trail in one column: streaming output, structured tool summaries, per-turn latency, and which skill was loaded for the turn.

Note: it is the record of the work, not a disposable chat log — sessions persist and are searchable across the project.

02

Editor

A focused editor with syntax highlighting for the moments when the right change is a small, reviewed edit made in place.

Note: no language server, no autocomplete, no debugger. This is a spot-editing surface by design. Keep your IDE for writing software.

03

Terminal

A native PTY with real terminal emulation. Build scripts, HiL suites, conversion jobs and pytest runs execute here and stream back into the turn as context.

Note: a terminal belongs to the window that opened it, and closes with it — no orphaned shells left running behind your back.

04

Review gate

Line diffs and command previews before execution, with four decisions: allow once, allow for this session, always allow, deny. Scoped per tool.

Note: "always allow" is a real, persistent grant. It is offered because a blanket prompt on every read is how review fatigue starts — use it deliberately.

05

Artifacts

Reports, plots, extracted channel sets and generated files collect in one place, each attributed to the tool call that produced it.

Note: attribution answers "where did this number come from" — it is not a document management system, and it does not version your release data. That is HELIX's job.

06

Skills

Your procedures, written once and loaded when the work matches: an opportunity assessment, a cycle-comparison rule set, a pre-release checklist. Usage and provenance are shown per turn.

Note: a skill is instructions, not a guarantee. It makes a method repeatable and traceable; it does not make a wrong method right.

07

Tasks and routines

A board the agent can read and update, and scheduled runs for the work that should happen without you — overnight drop intake, a nightly regression sweep, a weekly release-readiness pass.

Note: scheduled runs still stop at the same review gates. Unattended does not mean unapproved.

What intake returns, and why it is JSON

The agent is never handed a file path it is expected to open. Intake returns a manifest — counts, classes, run hints and blockers — so the model reasons about the shape of the drop while the two-gigabyte measurement and the two-million-line A2L stay on disk.

  • 6measurements
  • 2calibration images
  • 1cal patches
  • 4specifications
  • 2bench reports
  • 1analyses
  • 3references
  • 21supporting
  • 1archives
  • 3unclassified

What the agent gets back is this summary — not the files. The two-gigabyte measurement and the two-million-line A2L stay on disk, and it reasons about the shape of the drop first.

  • run_01_wltp_cold.mf4guess from the filename
    Run type
    baseline
    Cycle
    WLTP
    Confidence
    medium
  • run_04_wltp_hot.mf4guess from the filename
    Run type
    hot
    Cycle
    WLTP
    Confidence
    medium
  • rig_export_0912.zipblocked

    An archive is opaque: it can hide a second drop inside, so it is never opened unattended.

  • 3 unclassified filesblocked · under misc/

    Unclassified files have reversed conclusions before. They are raised, not guessed at.

A hint is a starting point, not a pairing. Filenames in this domain are typo-prone, and a delta between two runs that are not comparable is a fabricated result, not a small error.

Show the JSON the agent receives
drop_intake — ~/drops/2026-09-WLTP
{
  "root": "~/drops/2026-09-WLTP",
  "counts": {
    "measurement": 6, "cal_image": 2, "cal_patch": 1,
    "specification": 4, "bench_report": 2, "analysis": 1,
    "reference": 3, "supporting": 21, "archive": 1, "unknown": 3
  },
  "measurements": [
    { "file": "run_01_wltp_cold.mf4", "run_hint": {
        "run_type": "baseline", "test_cycle": "WLTP",
        "confidence": "medium", "evidence": "filename" } },
    { "file": "run_04_wltp_hot.mf4",  "run_hint": {
        "run_type": "hot", "test_cycle": "WLTP",
        "confidence": "medium", "evidence": "filename" } }
  ],
  "blockers": [
    { "kind": "archive", "file": "rig_export_0912.zip",
      "why": "an archive is opaque; it can contain an undisclosed sub-drop" },
    { "kind": "unknown", "count": 3, "under": "misc/",
      "why": "unclassified files have reversed conclusions before" }
  ]
}

// run_hint is a starting point, NOT an established pairing.
// Filenames in this domain are typo-prone, and a delta between runs
// that are not comparable is a fabricated result, not a small error.

FOUR WAYS IN

The same workspace, opened from four different desks.

Orbis does not assume one job. What changes between these engineers is the drop they point it at and the skill they load — not the workspace.

DESK 01 / CALIBRATION

Powertrain calibration engineer

Asks what a strategy is costing across a cycle. Searches the A2L for the labels that govern it, reads the values currently flashed, checks them against the function specification, and gets a ranked, confidence-tagged opportunity register instead of a hunch.

DESK 02 / MEASUREMENT

Measurement and validation engineer

Drops a week of dyno and road logs and asks what changed. Intake pairs the runs and flags what is not comparable; MDX is reached over MCP to extract and plot the channels; the comparison script runs in the terminal and its output, not a guess, goes into the summary.

DESK 03 / DIAGNOSTICS

Diagnostics and after-sales engineer

Walks a fault from symptom to cause with the service documentation, the fault memory and the measurement in the same transcript. DiagAI reasons locally over the telemetry; XHandbook resolves the function documentation; nothing about a warranty case leaves the building.

DESK 04 / RELEASE

Calibration data manager

Runs the pre-release pass as a routine: intake every incoming package overnight, check patches against the rules the team wrote down as a skill, and arrive in the morning to a readiness summary with the blockers named. The release itself still happens in HELIX, under its own gates.

Workflow

From input to decision.

  1. 01

    Hand over the drop

    Open a project, point Orbis at the folder, and state the question in engineering terms — "compare the hot WLTP run against the cold baseline and tell me what the cut-off strategy is leaving on the table." Intake classifies the drop and raises blockers before any analysis starts.

  2. 02

    Watch the tool trail

    The agent searches the A2L, reads the flashed values, extracts the channels it needs from the measurement, runs your script in the terminal, and drafts the result. Every step is a labelled row with its arguments, duration and output — nothing happens off-screen.

  3. 03

    Approve, then keep it

    Read the diff, approve or deny each write, and the change lands in your working tree. The session, its artifacts, and the skills that produced them stay on disk as evidence you can reopen or hand on.

Why it exists

A chat window does not know what an A2L is.

General AI assistants fail on vehicle work for structural reasons, not stylistic ones: they cannot open a 2 GB measurement, they invent calibration labels that do not exist, they have no terminal to prove a claim with, and they ask you to paste your proprietary data into someone else’s cloud. Orbis was built against those four failures.

It shows in the details. Labels come from the A2L or the tool returns near-misses instead of a plausible guess. Large files are queried, never streamed into the context window. Claims are backed by a command you can rerun. And the whole workspace, model included, can run with the network switched off.

Positioning

Orbis vs the two things engineers try first.

Most teams reach for a browser chat window or an IDE copilot. Both are useful, and both break at the point where automotive data begins.

On real calibration workChat window / IDE copilotOrbis
A 2 GB MF4 measurementCannot be opened or pastedQueried through domain tools; headers read on request, channels extracted on demand
A 2-million-line A2LExceeds any context windowRegex label search and single-parameter lookup — the file is never read into the model
Calibration label accuracyInvents plausible-looking labelsReturns confirmed labels, or near-miss candidates and an explicit miss
Flashed ECU valuesNot availableDecoded from the HEX image to physical units next to the A2L structure
Running the checkSuggests a command for you to runRuns it in a native PTY and reads the output back into the turn
File changesCopy-paste, or applied silentlyDiff with allow-once / session / always / deny, recorded against the turn
Your proprietary dataUploaded to a vendor cloudStays on the workstation; the model itself can be local
Your team’s methodRe-explained in every promptWritten once as a skill, loaded on demand, attributed in the transcript

Questions

Asked by engineers, answered plainly.

Is Orbis an IDE?

No, and it does not pretend to be. Orbis has a focused editor for spot edits with syntax highlighting, a real terminal, and a diff review surface — deliberately narrow. There is no language server, no autocomplete and no debugger. Keep your IDE for writing software; use Orbis for work an agent should do alongside you and for the moments where a small, reviewed edit is the whole change.

Does my calibration data leave the machine?

Only if you choose a hosted model and let it. Orbis runs locally, reads local files, and its domain tools return structured summaries rather than raw file contents. Point it at a model served by Ollama or LM Studio on your own hardware and the workspace runs with no external network calls at all — which is how air-gapped OEM environments use it.

Which files does it actually understand?

Intake classifies .mf4, .mdf and .dat measurements; .a2l, .hex, .s19 and .exp64 calibration images; .dcm patches; PDF specifications; spreadsheet references; bench reports; and prior analyses. Anything it cannot classify is reported as a blocker rather than quietly skipped, and it distinguishes a specification from a bench report from your own earlier conclusion — so an analysis is never cited back to you as a requirement.

How do I stop it doing something I did not ask for?

Every tool call that writes a file or runs a command goes through a permission decision: allow once, allow for this session, always allow, or deny. Nothing is applied first and shown afterwards. Approvals are scoped per tool, and the decision is recorded alongside the turn that requested it.

Can it drive the rest of the VehicleLab suite?

Yes. Orbis is an MCP host and an MCP client. MDX exposes measurement channels, plotting and event detection as MCP tools; Orbis consumes them in the same transcript where it is reading your A2L and running your scripts. It also exposes its own tools to other MCP clients, so an agent running elsewhere can reach the same workspace.

What is a "skill", and why does it matter here?

A skill is a procedure written down once — how your team assesses fuel cut-off opportunity, how you compare a hot cycle against a cold baseline, what has to be true before a dataset is released. The agent loads it when the work matches, and the transcript records which skill fired and what it produced. It is how a team’s method survives being handed between engineers, instead of living in one person’s prompt.

Which models can I use?

Anthropic, OpenAI, Gemini, xAI, DeepSeek and OpenRouter are supported directly, as are local servers via Ollama and LM Studio. Orbis reports a provider as Configured once credentials are accepted and only calls it Ready after a real generation — credential acceptance is not treated as proof that inference works.

Is it available now?

Orbis is the newest member of the VehicleLab suite and is in a controlled early-access programme with OEM and Tier-1 teams. Builds exist for macOS, Windows and Linux. Get in touch and we will walk you through it against your own drop.

Next step

Put the agent where the engineering actually happens.

One workspace for the drop, the A2L, the terminal and the diff — with every change reviewed before it lands, and every conclusion traceable to the tool that produced it.

Request early access Talk to an engineer

By task

Where Orbis is used.

Go deeper

Guides and comparisons for Orbis.

Works with