Scroll

Semantical Logic.
Enhanced Contextual Awareness.

Try OrrinInfinity Try Pragmos Read about Exegesis Read about Yabble

What we do

Context as the command surface.

The friction we remove

Prompt tax, session amnesia, REST loops.

Actions ↔ Data

Compress behavior. Drive the next move.

Exegesis

Shared substrate under every product.

Products

Orrin, Yabble, Pragmos, Exegesis.

For developers

CE, OrrinSDK, specs, 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

Shrink the manual context users must ship into every request. Context should arrive structured, not typed from scratch.

Inherent context

Specs, sessions, and memory give models dense environmental state so inference spends budget on reasoning - not reconstruction.

Shared substrate

One stack under Orrin, Yabble, Pragmos, and developer tooling - products compose instead of reinventing context plumbing.

02 // The friction we remove

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 - workflow state, prior intent, tool outcomes, and environmental cues.

Continuity breaks across sessions. Integration into real hardware and daily tools is shallow. The model is powerful; the context path is not.

- 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

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. Products and developer tools plug into the same substrate rather than inventing private context formats.

The result is agentic software that can move from observation → compression → action with far less explicit instruction - and with shared contracts across the stack.

+ 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

04 // Shared infrastructure // Exegesis Explore Exegesis

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 between agents and tools.

Contextual memory

Episodic / vector state so intent and history persist across sessions instead of resetting every call - the foundation for long-horizon autonomy.

Interactivity specs

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

Cost

Fewer tokens, fewer loops

Dense specs and session state replace multi-hop REST scraping and oversized system prompts.

Consistency

One context model

Products and SDK agents share session, payload shape, and memory - so the ecosystem composes.

Velocity

Build product, not transport

Handlers and specs sit on a packaged connection layer. Ship domain behavior, not websocket bookkeeping.

Orrin

Flagship · iOS

Spatial, agentic workspace for advanced notes (OrrinInfinity), planning, and running AI tools and agents without constant prompting. Project-scale context through Exegesis sessions and memory.

› Infinite canvas for notes, agents, and structured work
› Agentic tasks grounded in live session context
› Extensible via OrrinSDK for custom tools & agents

Explore Orrin Install on iOS

Yabble

Pre-release

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 (less scrape, more structure)
› Multi-step loops kept coherent by shared memory

Explore Yabble

Pragmos

Beta 2 · Web

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

Exegesis

Infrastructure

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

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

Explore Exegesis espec

FAQs

Short answers to the most common questions.

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

What we do

The friction we remove

Actions ↔ Data

Exegesis

Products

For developers

We make context the command surface.

Less prompting

Inherent context

Shared substrate

Inefficient interactions

What Stellr builds instead

Actions into data

Data into actions

One substrate under every Stellr product

Web Specifications

Realtime transport

Contextual memory

Interactivity specs

Fewer tokens, fewer loops

One context model

Build product, not transport

Orrin

Yabble

Pragmos

Exegesis

Centralized execution & OrrinSDK

FAQs

Semantical Logic. Enhanced Contextual Awareness.

What we do

The friction we remove

Actions ↔ Data

Exegesis

Products

For developers

We make context the command surface.

Less prompting

Inherent context

Shared substrate

Inefficient interactions

What Stellr builds instead

Actions into data

Data into actions

One substrate under every Stellr product

Web Specifications

Realtime transport

Contextual memory

Interactivity specs

Fewer tokens, fewer loops

One context model

Build product, not transport

Orrin

Yabble

Pragmos

Exegesis

Centralized execution & OrrinSDK

FAQs

Semantical Logic.
Enhanced Contextual Awareness.