BridaJournal
← Journal

Product

Introducing Brida Reflex: fast typed decisions for agents and software

Brida Reflex turns recurring events into small, bounded decisions. Today we are releasing the public product surface together with ReflexBench, open schemas, the SDK and a growing library of use cases.

Brida September 23, 2026
Brida ReflexSystem Oneagentsbenchmarks

Most AI systems have one default move: call a large model.

A message arrives. Call a model.

A task changes. Call a model.

A document lands. Call a model.

An agent is deciding whether it should keep working. Call another model.

That works, but it is a very expensive way to answer small questions.

Brida Reflex is a different primitive: small state in, typed decision out.

event
  -> bounded state
  -> Reflex
  -> Binary / Choice / Score
  -> your policy
  -> your action

The application keeps authority. Reflex does not send the email, approve the payment, click the button or deploy the change. It produces a bounded recommendation that software can consume immediately.

Today we are making that system public as a coherent developer surface: the hosted Brida Reflex Free Preview, the open registry and schemas, the official TypeScript SDK, Agent Skills, reproducible evaluation with ReflexBench, and a public library of real-world patterns.

Why a reflex?

Large reasoning models are exceptional when a task actually needs reasoning.

Many software decisions do not.

They need a fast semantic judgment:

  • Is this event worth waking an expensive agent for?
  • Which route fits this request?
  • Is this piece of context still relevant?
  • Does this proposed action conflict with policy?
  • Does this output need human review?
  • How risky is this tool call?
  • Is this lead worth attention?

A human nervous system does not route every stimulus through deliberate thought. Software should not have to either.

That is the design intuition behind Reflex.

A decision, not a chatbot

Reflex exposes three bounded shapes.

Binary for a yes/no semantic judgment.

Choice for selecting among a known set of alternatives.

Score for returning a bounded semantic value.

This matters because probabilistic decision infrastructure has different requirements from open-ended text generation. Calibration matters. Option order matters. Cardinality matters. Failure handling matters. The shape of the probability response matters.

That is why we built ReflexBench.

We benchmark the decision layer

ReflexBench v1 is open, provider-neutral and reproducible. It evaluates System One and typed decision engines on the same frozen protocols instead of relying on marketing examples.

On the frozen 111-case public-hard cohort, the tested TypeSafe Jev route achieved the highest semantic accuracy among the engines in that cohort: 73.0%, compared with 41.4% for the next tested engine. That is a same-corpus Brida measurement, not a claim about every model or every deployment.

The multilingual Choice lanes show the same pattern. On the common 20-way EN/ES lane, the tested Jev route reached 79.5% raw accuracy and 91.0% EN↔ES prediction consistency. On the 60-way lane it reached 75.4% accuracy and 94.9% language-pair consistency.

But the part we care about most is what happens when a decision engine becomes part of a system.

Reflex Core is a deliberately small deterministic policy layer applied to the same model response. On 110 public product fixtures, Jev’s raw semantic accuracy was 96.4% (106/110) and the same-response Core policy reached 100.0% (110/110) with four rescues and zero harms.

We then ran a separate blind workflow gate. The second frozen gate completed all 150 cases and measured 76.7% raw → 82.0% Core, a +5.3 percentage-point paired improvement with ten rescues and two harms.

Those results do not prove universal safety. They prove something narrower and useful: system design around a probabilistic decision can measurably improve operational behavior without adding another model call.

The full receipts and caveats are public in ReflexBench RESULTS.md.

Open contracts, hosted execution

The public Reflex registry lives at brida-ai/reflex.

It contains:

  • declarative recipe schemas;
  • immutable recipe versions and synthetic fixtures;
  • Custom Reflex examples;
  • Binary, Choice and Score templates;
  • integration patterns;
  • focused Agent Skills generated from public use cases.

The official TypeScript SDK is published as @brida/sdk, with its source at brida-ai/sdk.

import { Brida } from '@brida/sdk'

const brida = new Brida({
  apiKey: process.env.BRIDA_API_KEY,
})

const result = await brida.reflex.run('agent-wakeup', {
  state: {
    source: 'github',
    event: 'check_run',
    conclusion: 'failure',
  },
})

console.log(result.decision.branch)

The open-source contracts are intentionally separate from Brida’s hosted control plane. Public examples never grant side-effect authority and a repository merge never activates a hosted recipe.

Start from the event you already have

The most useful way to understand Reflex is not as a generic model endpoint. It is to find the repeated semantic decision hiding inside an existing workflow.

The public catalog already covers patterns across:

  • agent orchestration and wake-up decisions;
  • routing and effort selection;
  • context and memory relevance;
  • tool and message risk;
  • software issue and code-change classification;
  • document and dataset quality gates;
  • sales and CRM decisions;
  • semantic content filtering;
  • evidence and completion gates.

You can explore the product catalog at brida.ai/reflex/use-cases or the canonical source examples on GitHub.

Reflex Alignment

One use case deserves its own treatment.

When agents can call tools and create side effects, the important question is no longer only what the model says. It is whether the action it is about to perform is consistent with the explicit rules and authority of the system operating it.

That leads to a simple pattern:

model
  -> proposed action
  -> Reflex Alignment
  -> deterministic host policy
  -> execution / review / block

We have published that pattern as Reflex Alignment.

And because a safety pattern should be measurable rather than rhetorical, we also built AlignmentBench, an open behavioral benchmark for operational alignment under explicit policies.

ReflexBench measures the decision engine.

AlignmentBench measures target-system behavior.

Reflex Alignment supervises a proposed action at execution time.

They are separate layers on purpose.

What we are launching

Brida Reflex is currently a Free Preview, not a claim that every public recipe is already a hosted production endpoint.

The Preview is designed to let builders reach first value with no card, bounded free Decision Capacity and no silent paid overage. The public registry and SDK define the developer surface; hosted availability remains explicit.

You can start at brida.ai/reflex.

Or give your AI agent the public guide:

Read https://brida.ai/reflex/agent.md and apply it to my context.

The goal is simple:

stop spending deliberate intelligence on decisions that should be reflexes.