Wyrd verifies that your service behaves as declared.

Wyrd is the infrastructure behind Bohmian. Define the service and the behavior you expect, then verify real runs before and after deployment.

See how Wyrd works Explore Wyrd on GitHub

Open sourcePre- and post-deployment

Wyrdcontinuous assurance

Declare the serviceDefine the service and its expected behavior.

ObserveCapture evidence from real runs.

VerifyCheck the evidence against the declaration.

Declare the service and how it should be verified.

Whether you run a conventional API, a traditional ML service, or a single- or multi-agent system, Wyrd gives you one way to define expected behavior and the checks that should apply.

Declare the service

The example uses an Agent, Prompt, and eval Verifier. The same Service format works for any workload. It also defines when verification runs and what happens if it fails.

Service standardvalid declaration

apiVersion: wyrd/v1
kind: Service
metadata:
  space: support
  name: support-service
  version: "1.0.0"
spec:
  description: Resolve support requests.
  service_type: api
  components:
    - alias: support_agent
      ref: ./agent.yaml
      verified_by:
        - verifier: ./verifier.yaml
          runs_on:
            kind: observations_ready
          on_failure:
            - kind: notify
              channel:
                kind: slack
                text: Support quality failed

apiVersion: wyrd/v1
kind: Agent
metadata:
  space: support
  name: support-agent
  version: "1.0.0"
spec:
  prompt: ./prompt.yaml
  tool_names:
    - ticket_search
    - reply_send
  run_config:
    max_iterations: 5
    timeout_ms: 45000

apiVersion: wyrd/v1
kind: Prompt
metadata:
  space: support
  name: support-prompt
  version: "1.0.0"
spec:
  provider: openai
  model: gpt-5.5
  system: |
    Resolve the customer request using
    only supported account information.
    Escalate when confidence is low.
  messages:
    - ${customer_request}

apiVersion: wyrd/v1
kind: Verifier
metadata:
  space: support
  name: support-quality
  version: "1.0.0"
spec:
  implementation:
    kind: eval
    spec:
      pass_gate:
        kind: all_pass
      tasks:
        grounded_answer:
          kind: llm_judge
          id: grounded_answer
          context_path: $.answer
          operator: equals
          expected: { passed: true }

Each referenced definition has an exact version, so you can inspect what ran.

Observe

Wyrd ships first-class SDKs for Python, Rust, and TypeScript. Other languages can use the server API directly. Every observation stays tied to the Service version and run.

Observe an evalPython · Rust · TypeScript

from wyrd import WyrdState
from wyrd.eval import MediaRef

state = WyrdState.from_path("./service-bundle")
state.start_bifrost()

with state.run() as run:
    agent = run.for_card("support_agent")
    agent.observe.eval(
        SupportExchange(question=question, answer=answer),
        session_id=session_id,
        media=[MediaRef(
            id="screenshot", kind="image",
            uri=media_uri, media_type="image/png",
        )],
    )

state.shutdown()

let mut state = WyrdState::from_path(
    "./service-bundle".as_ref()
)?;
state.start_bifrost().await?;

let run = state.run();
let agent = run.for_card("support_agent")?;

agent.observe().eval(
    &SupportExchange { question, answer: &answer },
    EvalObservationOptions {
        session_id: Some(session_id),
        media,
        ..Default::default()
    },
)?;

state.shutdown().await?;

const state = WyrdState.fromPath("./service-bundle");
await state.startBifrost();

const run = state.run();
const agent = run.forCard("support_agent");
const context = { question, answer };

agent.observe.eval(context, {
  sessionId,
  media: [{
    id: "screenshot",
    kind: "image",
    uri: mediaUri,
    mediaType: "image/png",
  }],
});

await state.shutdown();

The observation stays tied to the Service, Agent, and run that produced it.

Verification plane

Wyrd sends each observation to the Verifier named in the Service. It records the verdict with its evidence and runs the configured failure action when a check fails.

Illustrative result

Observation receivedsupport_agent · eval

Verification planesupport-quality@1.0.0

VerifiedBehavior matches intent

Verifiersupport-quality@1.0.0

Evidencecontext + media attached

DecisionPASS · recorded

Every verdict records what was checked, which standard applied, and the evidence behind the result.

Start by declaring one service.

Use the observations you already have. Wyrd checks them against the declaration and records the result.

Explore Wyrd on GitHub