MIDVA HUMAN + AI / MEASURED AS ONE SYSTEM

How Midva works

Midva coordinates human actions, AI reasoning, and deterministic execution as one adaptable process. It measures each actor’s work and every handoff so its owner can change the process around the current constraint.

Delegate to Runner what limits Human or AI.

In the basic Human → AI process, without agentic loops, human attention limits throughput and AI reasoning drives cost. Runner is the process harness that takes repeatable work from either actor. It orchestrates AI calls and executes deterministic steps without human attention or AI reasoning.

Human

Judgment

Decisions · review · approval

Limited capacity sets throughput.

AI

Reasoning

Analysis · open-ended changes

Every reasoning turn adds cost.

Runner

Execution

Orchestration · AI calls · handoffs · setup · scripts · checks

Limited to deterministic work.

THROUGHPUT More useful work through the system.

AI COST Less reasoning spent per useful result.

Your workspace. Your plugins.

Each user has a separate workspace with its own set of plugins. Connect, update, or replace them interactively as the way you work changes.

Choose the behavior

Plugins provide the screens, tools, and task behavior in your workspace. Choose the set you need and replace a plugin when you want it to work differently.

Build with Elixir and the SDK

A plugin is regular Elixir code built against the Midva SDK. You or AI can write or modify one to add the behavior you need. Plugins work together through declared capabilities.

Change the development process

Development processes are plugins too. Choose or change the steps for implementation, review, checks, and delivery to fit your own workflow.

Record each action as evidence.

A shared event history makes active work, queues, handoffs, and cost comparable across cycles. The record exposes anomalies that intuition can miss.

Steps and ownership

Which actor held the work, what it attempted, and what state followed.

WHO / WHAT

Time and handoffs

Active duration, ready-but-waiting time, queues, and control transfers.

WHEN

Tokens and execution

Token usage, run status, checks, and the evidence returned for review.

COST / RESULT

The process coordinates the actors.

A process describes who acts, what can run concurrently, when a handoff is ready, and which evidence must return. Change the process when you see a way to decrease the responsibilities of the constraint or its idle time.

The delivery loop kept its shape while ownership changed.

Before · Starting process

The human carried the delivery loop.

AI changed code and ran mix test. The human prepared the workspace, reviewed the result, synchronized with dev, deployed, and cleaned up.

Scroll horizontally to follow the Human, Runner, and AI lines.

HUMAN RUNNER / PROCESS
NOT YET USED AI
1 / PREPARE
  1. Prepare the workspace
    HUMAN / WORKSPACE

    Update dev, create the task branch and worktree, install dependencies, and compile.

    Later delegated to Runner
  2. Write the implementation request
    HUMAN → AI

    Describe the change and wait until the workspace is ready before starting AI work.

2 / IMPLEMENT AND CHECK
  1. Change the code
    AI / WORKSPACE

    Implement the request and inspect the affected paths.

  2. Format and run the test suite
    AI / CHECKS

    Use AI time to execute repeatable checks and interpret their output.

    Later delegated to Runner
3 / REVIEW AND REPAIR
  1. Review the result
    HUMAN / REVIEW

    Read the diff and check results, apply coding rules, then describe any repair.

  2. Repair review findings
    AI / REPAIR

    Apply the feedback, rerun affected tests, and return the result for another review.

4 / SYNC AND RELEASE
  1. Synchronize with dev
    HUMAN / GIT

    Merge the latest dev revision, resolve conflicts, and repeat verification.

    Later delegated to Runner
  2. Publish and deploy
    HUMAN / RELEASE

    Commit, push, deploy the verified revision, and remove the task workspace.

    Later delegated to Runner

After · Current process · version 9

Runner carries the repeatable work.

The human decides what to do. AI handles open-ended implementation and repair. Runner owns preparation, deterministic gates, Git synchronization, and release mechanics.

Scroll horizontally to follow the Human, Runner, and AI lines.

HUMAN RUNNER / PROCESS AI
1 / START AND PREPARE ASYNC
  1. Start the task and send the request
    HUMAN → PROCESS

    Midva queues the implementation message while workspace preparation continues.

  2. Prepare an isolated workspace
    RUNNER / WORKSPACE

    Resolve the exact origin/dev revision, create or reuse the task branch, install dependencies, and compile when needed.

2 / AI IMPLEMENTATION
  1. Implement in the prepared workspace
    PROCESS → AI

    Change the code, inspect the diff, and request focused checks from Runner.

  2. Return the primary response
    AI → PROCESS

    The human can send another message or start another process while later stages continue.

3 / QUALITY PIPELINE ASYNC
  1. Run deterministic gates
    RUNNER / CHECKS

    Capture changes, format, preflight, audit dependencies, run Credo, Dialyzer, mix test, and Playwright.

  2. Review coding rules in parallel
    PROCESS → AI

    Reviewers inspect explicit checklists in batches of up to eight files, with four batches running at once.

  3. Repair concrete findings once
    AI → RUNNER

    If reviewers find a problem, AI applies the findings in one turn and Runner repeats the affected checks.

  4. Publish the verified task revision
    RUNNER / GIT

    Commit the captured change set and push that exact revision to the task branch only.

4 / SYNC WITH DEV ASYNC
  1. Check the durable sync point
    RUNNER / GIT

    If origin/dev moved, merge it into the task tree, run the full suite, and update only the task branch.

  2. Preserve recoverable failures
    RUNNER / STATE

    Use one bounded repair or retry. If work stops, keep the task and worktree intact.

  3. Return the reviewed revision
    RUNNER → HUMAN

    Midva hands control back after queued messages and processes have stayed in order.

5 / HUMAN DECISION
  1. Choose the next action
    HUMAN → PROCESS

    Continue implementation, ask a read-only question, run another process, or complete the task.

  2. Execute the selected process
    RUNNER / PROCESS

    Run review, verification, merge, staging, audit, production, or final integration under its versioned contract.

  3. Complete and clean up
    RUNNER / GIT

    For completion, merge current dev, verify, publish the exact revision to the task branch and dev, then remove local task state.

Read each diagram from top to bottom. Each step sits on its owner’s line. Read each diagram from top to bottom. Each step sits on its owner’s line. Steps labelled Later delegated to Runner in the starting process mark work that Runner owns now.

Midva coordinates. The local runner executes.

Midva aggregates the selected processes and plugins into one measured flow. A local open-source runner executes that flow beside the workspace, so AI activity and detailed execution logs stay local.

Midva coordinates

Aggregates processes and plugins, tracks state, and routes explicit handoffs.

Local runner executes

Runs AI actors, deterministic tools, and nested subprocesses while retaining local logs.

Workspace keeps work close

Source, execution artifacts, and detailed AI traces remain beside the user’s work.

Stable capability boundaries let actors, providers, tools, checks, and handoff rules change without turning the measured development system into a different product.