Semantical Logic.
Enhanced Contextual Awareness.

Try OrrinInfinity Try Pragmos Read about Exegesis Read about Yabble

Explore

Select a topic

What we do

Context as the command surface.

The friction

What we remove from the interaction.

Core loop

Actions into data, data into actions.

Exegesis

Shared infrastructure under every product.

Products

Orrin, OrrinInfinity, Yabble, Pragmos.

For developers

CE, OrrinSDK, specs, and handlers.

01 · What we do

We make context the command surface.

Traditional AI waits on explicit prompts and forgets everything between sessions. We engineer the opposite: environment-aware systems that already know enough to act.

Stellr builds the infrastructure and products for agentic systems that carry context forward: compress repetitive signal, retain intent across sessions, and turn environmental cues into precise action - without forcing users to re-explain themselves every time.

Less prompting Inherent context Shared substrate

current

Inefficient interactions

Most AI still depends on hand-authored prompts, brittle scrapes, and repeated API round-trips. Users spend the majority of interaction time reconstructing context the system should already hold.

Prompt crafting dominates time that should go to outcomes
Session amnesia forces users to re-teach the same facts
REST loops hide mid-flight tool status and agent coordination

stellr

What Stellr builds instead

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

Standardize - unified protocols so context works across apps and agents
Measure - capture behavioral nuance and intent, not just raw events
Trade - exchange structured insight between systems and users in real time

03 · Core loop

Actions become data. Data becomes the next action.

SaaS surfaces produce limited, repetitive actions. True awareness is not hoarding every token of dense history - it is recognizing repetition and compressing it into durable, reusable signal. We turn streams of behavior into structured context models that agents can reason over without replaying the entire past.

Inversely, compressed contextual state can autonomously drive the next move. By linking subtle environmental cues to the exact action required, models stop waiting for perfect prompts and start participating in the workflow.

04 · Shared infrastructure

One substrate under every Stellr product

Exegesis is not a consumer surface - it is the protocols, specs, realtime paths, and memory layers every Stellr system plugs into. 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.

Web Specifications

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

Realtime transport

WebSocket-first execution for bidirectional streams, Terminal Sessions, handlers, senders, and low-latency structured payloads.

Contextual memory

Episodic / vector state so intent and history persist across sessions instead of resetting every call.

Interactivity specs

Declarations that let pages and tools react to user behavior in real time, feeding agents live situational context.

Explore Exegesis

Flagship · iOS

Orrin

The agentic workspace. Orrin is the product surface for advanced notes, planning, and running AI tools and agents without constant prompting. Marketplace apps, custom tools, and plugins live here - and the same objects can land on the infinite canvas.

Project-scale context through Exegesis sessions and memory
Marketplace of apps, tools, and agents via OrrinSDK
Agentic tasks grounded in live session context

Explore Orrin Install on iOS

Beta · Web

OrrinInfinity

The spatial layer of Orrin. An unbounded canvas for notes, math, code, graphs, documents, and live agent cards - one continuous surface where structure stays visible and nothing is trapped in a tab. Not a standalone whiteboard: a spatial expansion of Orrin, on the same marketplace and Exegesis protocol.

Drop notes, KaTeX equations, graphs, code, PDFs, and checklists as first-class objects
Nest containers, link components, and search the board at any zoom
Invite Orrin agents - extract, plot, summarize - over Exegesis; outputs stay on the canvas
Lodge external boards, multi-board sessions, and a side research panel

Explore OrrinInfinity About Orrin

Boundless

Pan and zoom without edges. The board never runs out of room.

Connected

Links track as you move cards. Relationships stay honest.

Extensible

Marketplace add-ons and, on the roadmap, a canvas-native UI SDK.

Pre-release

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.

Host-machine tasks through Terminal Session handlers
Spec-backed web understanding
Multi-step loops kept coherent by shared memory

Explore Yabble

Beta 2 · Web

Pragmos

Plan, schedule, journal, and navigate workflow in one place. Planning artifacts become contextual fuel for agents and the rest of the Stellr stack.

Unified surface for plans, schedules, and journals
Workflow state designed to feed agentic systems
Continuity with Orrin and Exegesis memory paths

Explore Pragmos

Infrastructure

Exegesis

Shared infrastructure: web specifications, realtime WebSocket execution, episodic memory, and interactivity contracts. Context awareness as infrastructure.

.espec and ESPECI for structured web and UI contracts
Terminal Sessions, handlers, and sender protocols
Central MCP-style core for unified memory across apps

Explore Exegesis espec

06 · For developers

Centralized execution & OrrinSDK

Bind tools, open Terminal Session handlers, and let Exegesis own auth, framing, and lifecycle. Autonomous workflows emerge from structured context - not from stitching another prompt chain. OrrinInfinity is the spatial host: marketplace packages become board-native citizens.

.espec → handler → session → action

CE Docs OrrinSDK Infinity SDK

FAQs

Short answers

What exactly is context awareness?

Context awareness is an AI system’s ability to understand and adapt to a user’s circumstances, needs, and intent in real time. Instead of relying only on manual, explicit prompts, it uses environmental cues, structured specs, session state, and behavioral signal - so responses and actions fit the situation without re-explaining the world on every turn.

How does “promptless” AI function?

Promptless does not mean silent magic with no controls. It means the system is not blocked waiting for a perfectly written instruction. With permissioned access to structured context - screen/workflow state, specs, memory, and live sessions - agents can suggest or execute the next action from what is already true in the environment, while users still steer outcomes.

What is Exegesis relative to Orrin or Yabble?

Orrin, Yabble, and Pragmos are product surfaces. OrrinInfinity is the spatial layer of Orrin. Exegesis is the shared infrastructure beneath them: specifications, realtime Terminal Sessions, handlers/senders, memory, and interactivity contracts. Products differ in UX and platform; they share the same context model.

How do developers build on Stellr?

Through OrrinSDK, Terminal Session handlers, Centralized Execution, and Exegesis specifications. You bind tools and implement handler logic; Exegesis owns connection lifecycle, auth handshakes, and structured streaming. Start at the OrrinSDK docs and CE documentation.

Is connectivity to external tools fully open?

Terminal Sessions and related surfaces are still early. External connectivity for tools, models, and agents is intentionally constrained while the architecture matures. All usage is subject to our Terms & Conditions and developer policies.

Where do I follow research and releases?

The Stellr newsletter carries research notes, product updates, and release dispatches. Product pages and API / SDK documentation live in the footer.

Context awareness is infrastructure, not a chat skin. That is the bet - and what every Stellr surface is built to prove.

Semantical Logic.Enhanced Contextual Awareness.

Explore

What we do

The friction

Core loop

Exegesis

Products

For developers

We make context the command surface.

Inefficient interactions

What Stellr builds instead

Actions become data. Data becomes the next action.

One substrate under every Stellr product

Web Specifications

Realtime transport

Contextual memory

Interactivity specs

Orrin

OrrinInfinity

Boundless

Connected

Extensible

Yabble

Pragmos

Exegesis

Centralized execution & OrrinSDK

FAQs

Semantical Logic.
Enhanced Contextual Awareness.