Paraharness

Pure Passive AST & Late Binding

Declare agents, policies, loops, and flows with the P.* DSL. Builders emit serializable AST nodes with zero I/O at construction time and bind to concrete executors at runtime.

Pre-Flight & Post-Flight Sandboxing

Enforce capability policies before tool invocation and verify filesystem and git effects after execution, automatically rolling back unauthorized mutations or raising typed interrupts.

Copy-on-Write Worktree Forking & Speculation

Delegate parallel subtasks across isolated Git CoW worktrees with .fork() or race competing implementation strategies in speculative tournaments judged by an arbiter with .speculate().

Durable Crash Recovery & Warm KV Prefixes

Persist every turn, continuation frame, and checkpoint to SQLite or PostgreSQL ledgers while pinning byte-identical system prefixes across roles with P.prefixGroup.

Evidence-Based Lesson Distillation

Capture contrastive recovery trajectories from act-evaluate loops and beforeStop gates, distilling reusable empirical lessons scored by recency, confidence, and partition affinity.

13 Composable Packages

Mix and match first-party model drivers (Claude, OpenAI, Gemini), execution sandboxes (Git, FS, Node, Markdown), and storage/control adapters (SQLite, Postgres, GitHub, Slack).

Quick Start

Install the core DSL and runtime along with your chosen model, scope, and ledger drivers:

bash

npm install @paraharness/core @paraharness/claude @paraharness/fs @paraharness/git @paraharness/node @paraharness/sqlite zod

Declare an agent, mount it inside an isolated Copy-on-Write Git worktree flow, and start the durable runtime:

import { P, z } from '@paraharness/core';
import { createRuntime, runFlow, runStep } from '@paraharness/core/runtime';
import { claude, claudeExecutors } from '@paraharness/claude';
import { fs, fsExecutors } from '@paraharness/fs';
import { git, gitExecutors } from '@paraharness/git';
import { local, nodeExecutors } from '@paraharness/node';
import { sqlite, sqliteExecutors } from '@paraharness/sqlite';

const TaskInput = z.object({
  taskId: z.string(),
  prompt: z.string(),
});

const runner = local.runner({ slots: 4, maxDaemons: 2 });
const sonnet = claude.model('claude-sonnet-4-6');

const verifySuite = local
  .streamCheck('verify-suite')
  .runner(runner)
  .argv(['pnpm', 'test', '--run'])
  .circuitBreakWhenStdout(/FAIL/);

const worker = P.agent('worker')
  .model(sonnet)
  .tools(fs.codingTools(), verifySuite.asTool())
  .instructions('Implement the requested change and keep all checks passing.')
  .beforeStop(verifySuite)
  .input(TaskInput)
  .output(z.object({ summary: z.string() }));

const stepOut = await runStep(
  worker,
  { taskId: 'task-1', prompt: 'Add input validation' },
  {
    registry: [claudeExecutors, fsExecutors, nodeExecutors],
    env: process.env,
  },
);

const deliveryFlow = P.flow('delivery-flow')
  .input(TaskInput)
  .scope(git.cowWorktree())
  .step('implement', worker)
  .exit('done');

const flowResult = await runFlow(
  deliveryFlow,
  { taskId: 'task-1', prompt: 'Add input validation' },
  {
    registry: [claudeExecutors, fsExecutors, gitExecutors, nodeExecutors, sqliteExecutors],
    ledger: sqlite.ledger('.harness/state.sqlite'),
    env: process.env,
  },
);

const harness = P.harness('engineering-harness')
  .ledger(sqlite.ledger('.harness/state.sqlite'))
  .pools(runner)
  .lanes(
    P.lane('main-lane')
      .input(TaskInput)
      .key((item) => item.taskId)
      .runs(deliveryFlow)
      .concurrency(2)
      .priority('normal'),
  );

const runtime = createRuntime(harness, {
  registry: [claudeExecutors, fsExecutors, gitExecutors, nodeExecutors, sqliteExecutors],
  env: process.env,
});
await runtime.start();

ParaharnessDeclarative Multi-Agent Orchestration for TypeScript