Outline Layers Products Why Stellr
Exegesis - shared infrastructure
Shared infrastructure

Exegesis is the substrate
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.

Read the outline See products espec
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.

What Exegesis actually is

01 · Outline

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

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 is not

Not a consumer chat UI. Not a single app. Not a prompt library.

It is the shared execution and context layer: web specifications, realtime Terminal Sessions, handlers and senders, episodic memory, and interactivity contracts.

Efficiency

Spend tokens on reasoning

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.

One substrate, four layers

02 · Architecture
A

Web Specifications

Machine-readable endpoint semantics (.espec) so models understand surfaces without heavy scraping or oversized prompts.

B

Realtime transport

WebSocket-first execution for bidirectional streams, Terminal Sessions, handlers, senders, 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.

Explore espec ESPECI

What plugs into Exegesis

03 · Products
Orrin Product · iOS & web

Orrin

The agentic workspace for advanced notes, planning, and running AI tools and agents without constant prompting. Marketplace apps and plugins live here - and on the infinite canvas.

Explore Orrin OrrinInfinity
Yabble Product · desktop

Yabble

Desktop intelligence that works from what is already on your machine and screen. Agentic tasks via Terminal Sessions, spec-backed browsing, multi-step loops held by shared memory.

Explore Yabble
OrrinSDK Developer

OrrinSDK

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

SDK Docs
Web Specifications Contracts

Web Specifications

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

espec ESPECI

Why Stellr centralizes on Exegesis

04 · Efficiency
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

Fragmented context

  • 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 infrastructure

  • 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.