Sign in

Early accessInOrbit is opening to software teams, one at a time.

The real-time, programmable engineering coordination platform

Engineering doesn't stop at code.

One workspace for people, AI agents, and the systems they build and operate.

Give agents context and memory. Coordinate their work. Control execution. Verify outcomes with evidence.

Explore the platform
  • Platform live
  • Local agent
  • Mac app (invite only)
  • Mobile app (invite only)
  • Open source

Diagnostics & health

Systems & health

The platform's own components, read from the public status feed every 15 seconds: what runs, how fast it answers, and what needs attention.

Connecting to the status feed

5 of 6 measured · all operational

All systems operational

View
Public status feed, /v1/status

Sample data · drawn as an illustration

Loading systems and healthConnecting to the status feed

Remember · Keep decisions, results and lessons

Foundations
inorbit / foundationsAs it runs today

Programmable coordination

One state machine for every job, AI or human; each stage has a gate in Rust that reads evidence.

  • No API sets a job's state; a job moves only by passing its gates.
  • A failed check holds the job and names the missing fact; on release it resumes at the same stage.
  • Every wait (approval, runner, plan window, monitors) has a deadline and an escalation.

intake → linked → planned → approved → leased → running → checked → merged → rolled → verified → recorded → done

The layer under every step of the loop: what is decided (policy), checked before an action (guardrails), kept (memory), proved (evidence), who does the work (agents) and how a job moves (coordination).

0%

The platform

Everything in one coordinated workspace.

A set of connected capabilities that turn work, data and decisions into measurable results.

  • Explore

    Turn your work, code and knowledge into a living map.

    Work
    Code
    Living map
    Docs
    Decisions
  • Memory

    A durable memory of what was said, decided and proven.

    • Cache rule recorded
    • Hypothesis tested
    • Approval recorded
    • Fix verified and kept
  • Planner

    Turn goals into plans, steps, and accountable execution.

    Our own case study: InOrbit builds InOrbit

    Reading our plans…

    • Running—
    • Waiting on a person—
    • Done—

    Connecting to the status feed

  • Canvas

    Design, map and reason together with your agents.

    Input
    Agent
    Check
    Action
  • Reliability

    Monitors, incidents and system health in one place.

    • Services

      —

    • Incidents

      —

    • Check runs today

      —

    • Uptime

      —

    Connecting to the status feed

Planner and Reliability show InOrbit's own production, live. The other cards are sample data.

From intent to verified reality

From intent to verified reality.

Every change in InOrbit goes round one loop. The context is gathered, the decision is written down, the work is routed to people and agents, executed under policy, checked against evidence, and what was learned stays linked to the record. Open a step to see what goes in, who acts and what comes out.

Our own commits, live

Understand

Explore maps the code, the documents and the decisions around the question; Memory adds what the team said, decided and proved before. Nothing changes yet. This step makes sure the next one starts from facts.

Goes in

A question, an incident or a goal

Who acts

Explore and Memory

Comes out

The context: code, documents, decisions, what was proven before

Then

Prove, don't just assume

Proof, impact and evidence in the loop.

Every change InOrbit ships passes three checks: a test that could fail it, a number that moved, and records anyone can open. Here are four of ours.

  • Proof

    Tested

    What the change must do, and a test that could prove it wrong.

    Claim
    Our status page answers in under a second, every time.
    Test
    20 timed polls in production, then a test against a slow store.
    Result
    Held: a saved copy answers while one background read refreshes it.
  • Impact

    Measured 2026-11-01

    The number that moved, counted on the real system, with the date.

    up to 4.0 s

    Before the fix, in production. A test now keeps it fixed.

    first poll after the window2.8 to 4.0 s
    every other poll0.18 s

    The public status now: Connecting to the status feed

  • Evidence

    On record

    Where each proof is kept, so anyone can check it later.

    • Measurement

      20 timed polls of /v1/status, 2026-11-01

    • Pull request

      core #1551 · merged 2026-11-02

    • Test that guards it

      status_swr::after_the_window_a_reader_gets_the_kept_copy_and_a_background_read_renews_it

    • Decision

      RFC 0076 · PRD 0012 · ADR 0170 · Study 0106

Controls & audit

Controls, approvals and a full audit trail.

Typed controls, access and approvals with a trace from decision to code and deployment.

Where we stand

Recent commits (main)

Live from GitHub · inorbithr/sdk

Engineering first

Built for engineers. Open where it matters.

What runs underneath: five parts that do the work, then the ways to build on them.

On the Mac and the phone

The Mac holds the Planner, the Canvas, every approval and the terminal. The phone holds asks, incidents and monitors, and approvals you answer with Face ID. Partners test both before the stores.

Also the iohr command line on macOS and Linux, and the Console in any browser.