Exegesis is the shared infrastructure under every Stellr product.

Its job is narrow and deliberate: reduce how much explicit context users must feed a model, and increase how much context the model already holds - through structured specs, real-time protocols, and persistent memory layers.

Open ecosystem map Read the outline
01

Less prompting

Cut the volume of manual context users ship into every request.

02

More inherent context

Specs, sessions, and memory give models dense structure without scraping.

03

Shared substrate

One stack for Orrin, Yabble, OrrinSDK, and Web Specifications.

01 // Outline

What Exegesis actually is

Not a product surface. A substrate: protocols, specs, and runtime paths that every Stellr system plugs into.

+
+
The Problem

Problem it targets

Models are only as useful as the context they receive. Today that context is mostly hand-authored prompts, brittle scrapes, and repeated API round-trips - expensive, incomplete, and hard to keep consistent across products.

Exegesis flips the default: structure the environment so context is inherent. Endpoints declare meaning. Sessions stream state. Memory retains intent over time.

What it provides

  • A Web Specifications - machine-readable endpoint semantics (.espec) so models understand surfaces without heavy scraping.
  • B Realtime transport - WebSocket-first execution for bidirectional streams, agent coordination, and low-latency structured payloads.
  • C Contextual memory - episodic / vector state so intent and history persist across sessions instead of resetting every call.
  • D Interactivity specs - declarations that let pages and tools react to user behavior in real time, feeding agents live situational context.
+
+
+
+
The Benefits
COST

Fewer tokens, fewer loops

Dense specs and session state replace multi-hop REST scraping and oversized system prompts. Inference spends budget on reasoning, not reconstruction.

CONSISTENCY

One context model

Orrin, Yabble, and SDK agents share the same notions of session, payload shape, and memory - so products compose instead of reinventing context plumbing.

VELOCITY

Build product, not transport

Handlers, senders, and specs sit on a packaged connection layer. Teams spend time on domain behavior rather than websocket auth, framing, and session bookkeeping.

+
+
02 // Map

Ecosystem graph

Exegesis at the center. Products and layers around it - fully connected. Click any node · pan and zoom the surface.

Core
Product
Layer
Click a node · drag canvas · scroll zoom
03 // Products

What sits on Exegesis

Open space - products sit as independent surfaces, all wired into the same substrate.

Orrin

Orrin

An app built around advanced notes (OrrinInfinity), agentic tasks, planning, and the building of AI tools and agents - on an infinite spatial canvas.

Explore Orrin →

Yabble

Agentic tasks on a host machine via Terminal Sessions, surfing the web with Exegesis Specifications for minimal token usage, and performing tasks on a user’s behalf.

Explore Yabble →
Orrin

OrrinSDK

The SDK for Orrin - letting developers create custom AI-powered apps, custom AI tools, and custom AI agents on the same realtime Exegesis paths.

SDK Docs →
Orrin

Web Specifications

Specifications from Stellr, delivered through Exegesis, that cut token usage with structured endpoint and interactivity contracts.

espec → ESPECI →
04 // Efficiency

Why Stellr centralizes on Exegesis

+
+
SYS.FLOW // CONTEXT WITHOUT REPETITION
STEP 01

Declare

Specs describe endpoints and interactive surfaces once.

STEP 02

Connect

Sessions + handlers open realtime channels for agents and tools.

STEP 03

Accumulate

Actions and intents land in episodic memory, not disposable prompts.

STEP 04

Reuse

Orrin, Yabble, and SDK agents consume the same structured context.

+
+

Without Exegesis

  • — Each product invents its own context format
  • — Agents re-scrape or re-ask for the same facts
  • — REST loops hide mid-flight tool status
  • — Pages stay static; models stay under-informed

With Exegesis

  • + Shared specs, sessions, and memory contracts
  • + Inherent context from environment structure
  • + Live streams for collaboration and inference
  • + Interactive web that feeds agents as users act

Exegesis is early in places - external connectivity stays constrained by design - but the architecture is the bet: context awareness is infrastructure, not a feature bolted onto each app.