Architecture

R-Think is built on a layered architecture that separates protocol definition, rule validation, runtime execution, and artifact persistence.

Overview

The architecture consists of four primary layers:

Protocol Layer

Defines reasoning flows as sequences of steps with explicit transitions.

Rule Layer

Validates inputs, outputs, and state transitions using declarative contracts.

Runtime Layer

Executes protocols, enforces rules, and manages state.

Artifact Layer

Persists reasoning traces, evidence, and validation results.

Core Components

Each component has a single responsibility. They compose together to form complete reasoning systems.

architecture.ts typescript

// Protocol definition
const protocol = Protocol.define({
  id: 'data-processing',
  steps: [
    { name: 'ingest', action: ingestData },
    { name: 'transform', action: transformData },
    { name: 'validate', action: validateOutput },
    { name: 'emit', action: emitResult }
  ],
  retry: { maxAttempts: 3, backoff: 'exponential' }
});

// Rule definition
const rules = [
  Rule.required('data'),
  Rule.type('data', 'object'),
  Rule.minLength('data.records', 1)
];

// Runtime execution
const runtime = Runtime.create({ protocol, rules });
const result = await runtime.execute(input);

Execution Flow

When a protocol executes, the runtime follows a deterministic flow:

Validate input against rules
Execute protocol steps sequentially or in parallel
Apply transition rules between steps
Capture artifacts at each step
Return result with complete trace