Igris Inertial
Hero

Run AI that survives failure
and proves what it did.

Deterministic runtime. Cloud + local fallback. OS-level containment with signed violation logs. Deploy anywhere.

curl -fsSL https://igrisinertial.com/install | bash

The execution layer beneath intelligence.

Explore Platform

Hybrid behavior trees meet LLM reasoning.

Where AI models meet real-world execution. Your systems need more than raw intelligence. They need execution that survives failure and proves every decision.

The Nervous System governs how language model reasoning becomes action. Structured paths keep behavior bounded. Hard limits prevent runaway processes. Cryptographic signatures prove what happened.

One system, everywhere

One binary runs on servers, robots, and edge devices. Same guarantees anywhere.

Observe decisions in real time. Inspect actions. Verify outcomes. Trust what happened.

One System.
Two Environments.

The same nervous system governs AI execution—whether your system thinks in code or moves in space.

For AI Agents

Run on servers or edge. Every execution is isolated and time-bounded. Exceed limits and the task terminates — not retried silently.

Signed envelopes provide verifiable audit trails. Survive outages with local fallback. No runaway loops. No undefined state.

Saturn
AI Agents

For Robots

Behavior Trees govern motion. Safety logic is deterministic and LLM-independent — violations trigger immediate halt regardless of network state.

ROS 2 integration bridges reasoning to actuation. Signed violations include execution context. Offline by default. Sync when available.

Robotics
Robotics

Connect your stack

, , , , .

One API. Drop the SDK into your existing codebase. Your app becomes deterministic, provable, survivable—without rewrite.

Local runtime with automatic cloud fallback. Test on your laptop. Deploy to servers, robots, or edge devices.

import { IgrisClient } from '@igris-inertial/sdk';
 
const client = new IgrisClient({
baseUrl: 'https://overture.igrisinertial.com',
apiKey: process.env.IGRIS_API_KEY,
});
 
const response = await client.infer({
model: 'gpt-4',
messages: [{ role: 'user', content: 'Plan a route.' }],
max_tokens: 100,
});
 
console.log(response.choices[0].message.content);
 
// Local runtime with cloud fallback
import { Runtime } from '@igris-inertial/sdk';
 
const runtime = new Runtime({
localUrl: 'http://localhost:8080',
cloudUrl: 'https://overture.igrisinertial.com',
autoFallback: true,
});
 
const local = await runtime.chat({
model: 'llama-3-8b',
messages: [{ role: 'user', content: 'Hello' }],
});

Behavior Trees

Define, validate, and execute behavior trees programmatically. Compose sequences, selectors, and actions into autonomous workflows that run locally on the runtime.

Deploy trees to devices. Validate client-side and server-side. Get signed execution traces for every run.

import { Runtime, BehaviorTree,
SequenceNode, ActionNode } from '@igris-inertial/sdk';
 
const runtime = new Runtime({
localUrl: 'http://localhost:8080',
});
 
const tree = BehaviorTree.fromJson(
new SequenceNode('patrol', [
new ActionNode('scan_area', 'lidar_scan', { mode: 'full' }),
new ActionNode('navigate', 'move_to', { waypoint: 'alpha' }),
new ActionNode('report_status', 'log_status'),
]).toJSON(),
runtime,
);
 
const result = await tree.validate();
// { valid: true, root_type: 'sequence' }
 
const execution = await tree.run();
// { status: 'success', tick_count: 3 }

The Guarantees

Learn More
Execute with Bounds

Execute with Bounds

Every execution runs in an isolated worker. Memory, CPU, and time are enforced at the OS level. Exceed a limit and the worker is killed. Every violation is signed and hash-chained.

Decide with Structure

Decide with Structure

Language models generate reasoning. The runtime governs execution through bounded control paths. Isolated, time-limited, and supervised. Intelligence remains flexible.

Remember with Proof

Remember with Proof

Every execution produces a signed envelope. Violations are hash-chained and tamper-evident. Verify independently — without our control plane. You verify the system.

Proof is built in

Learn More

Signed execution

Every decision cryptographically signed. Verify independently—without our control plane.

Fail-Safe Execution

An independent supervisor enforces hard limits. No in-process corruption. No silent fallback. If execution breaks its contract, it stops. The system survives.

Air-gapped operation

Runs indefinitely without network. Survives outages. Syncs when possible.

Verified updates

Cryptographic signatures required. Unsigned artifacts rejected. Compromised devices excluded automatically.

Complete control from edge to cloud.