Examples

import { claude } from '@obversa/engine-claude-cli';
import { codex } from '@obversa/engine-codex-cli';
import { run } from '@obversa/runtime';
import { briefFromFile, stage, workflow, type TeamSeat } from '@obversa/runtime';

interface WriterReviewerEngines {
  readonly claude: (model: string) => TeamSeat;
  readonly codex: (model: string) => TeamSeat;
}

const realEngines: WriterReviewerEngines = { claude, codex };

function createWriterReviewerPair(engines: WriterReviewerEngines = realEngines) {
  return workflow('writer-reviewer-pair', {
    brief: briefFromFile('briefs/add.md'),
    options: { timeout: '10m' },

    roles: {
      write: engines.claude('claude-sonnet-4-5'),
      review: [engines.codex('gpt-5.6-luna')],
    },

    stages: [
      stage('write', {
        agent: 'write',
        writes: ['src/add.mjs', 'test/add.test.mjs'],
        desc: 'Write the function and its test from the brief.',
        gate: 'The files named in the brief exist in the workspace.',
        retry: 1,
      }),
      stage('test', {
        run: ['node', '--test', 'test/add.test.mjs'],
        desc: 'Run the test command against the written files.',
        gate: 'The test command exits 0.',
        sendsBackTo: 'write',
      }),
      stage('review', {
        panel: 'review',
        agree: 1,
        desc: 'Read the code, the test and its result.',
        gate: 'The change meets the brief.',
        sendsBackTo: 'write',
      }),
    ],
  });
}

const result = await run(createWriterReviewerPair());
console.log(JSON.stringify(result.outcome, null, 2));

​

Teams you run on your own work

• A writer and a reviewer. One model writes the files your brief names and a model from a different family reads them. Your test command runs in between. A rejection sends the work back once.
• A review panel with a threshold. One model implements, several review at the same time, and the change passes when enough of them accept. Every seat is a different model family.
• Feature delivery. Nine stages: research and a plan, each reviewed; tests before code; an implementation that runs again with the reviewers’ findings; a person’s decision; evidence. Work goes back to the stage that owns it.

​

Teams outside a software change

• Backlog grooming, then a person ranks. Raw tickets become stories with acceptance checks and the questions to settle first, each read by a second model; the product owner ranks.

• A contract against a playbook. Every clause mapped to accept, push back or never, the redlines written from the playbook’s own wording, a negotiating note saying what to hold and what to concede; the lawyer decides what goes back.

• Translate, then reflect on the translation. An article rendered into French against a glossary, then a terms table saying where the glossary and natural French pulled apart; a person publishes.

​

Mechanisms shown one at a time

• Three candidates, one winner. Three isolated attempts at one task, a deterministic judge, the winner lands and the losers leave nothing behind.
• A command decides the path. The tests run as a node with no inference; a red run goes straight back to the writer with the output attached, and a second command’s exit code chooses which review runs next.
• A person decides. A question to a person as a step: a no goes back to the writer with the note as the finding, a yes passes, and with nobody answering the run pauses and carries on from the answer.
• A review that sends work back. A reviewer rejects the first draft with a reason and the second draft passes.
• A file change approved byte for byte. Source records are captured, every mapping checked, exact output bytes approved, each target backed up before a merge, and a mismatch pauses the run.
• A feature from written issue to approval. One issue through analysis, implementation, a real test run, a review panel, a bounded repair, and an approval bound to the exact bytes.
• Shipping a reviewed change through GitHub. Push the branch, open one pull request, pass a strict gate on the exact head revision, squash the merge, delete the branch.