Think in space,
on top of the Orrin stack.
OrrinInfinity is the infinite board for notes, equations, graphs, checklists, code, media, and live agent cards - one continuous surface where structure stays visible and nothing is trapped in a tab.
It is not a standalone whiteboard product. It is a spatial expansion of Orrin: the same marketplace of apps, custom AI tools, and agents can land on the canvas as first-class objects. Realtime collaboration, handlers, and agent traffic ride the Exegesis WebSocket protocol - Terminal Sessions, senders, and centralized execution included.
Downstream, OrrinInfinity will expose a UI-based SDK so developers can ship canvas-native apps, tools, and extensions explicitly for the board - not only backends and actions for the broader Orrin ecosystem.
// Boundless
Pan and zoom without edges. Ideas grow outward - the board never runs out of room.
// Connected
Link notes, formulas, marketplace tools, and agent outputs so structure stays visible - not buried in folders.
// Extensible
Community add-ons from the Orrin Marketplace - and soon canvas-native UI extensions - plug into the same surface language.
Built on Exegesis. Extended from Orrin.
Exegesis WebSocket Protocol
OrrinInfinity sits on Stellr’s high-performance WebSocket layer - the same infrastructure that powers Terminal Sessions, custom handlers & senders, and bidirectional streams into Exegesis Centralized Execution.
That means agents on the board are not simulated chrome: they can receive structured payloads, stream results onto cards, and coordinate with tools without round-tripping through brittle REST-only loops. Low-latency streaming, session persistence, and token-secured access are protocol-level - not app hacks.
Explore ExegesisOrrin Marketplace on the canvas
Infinity expands the surface area of the Orrin Marketplace. Apps, custom AI tools, and agents built with OrrinSDK do not stay locked in document or chat flows - they can mount as spatial objects, run against board context, and write back into linked notes.
- APP Full applications that open workspaces or panels anchored to regions of the board.
- TOOL Discrete AI actions (extract, plot, summarize, transform) invoked from selection or container scope.
- AGENT Long-running plugins that watch context, propose edits, and collaborate over Exegesis streams.
how a card talks
to the rest of Stellr
Board object
Note, graph, checklist, agent card, or marketplace app instance on the infinite plane.
WebSocket channel
Exegesis WS session - handlers, senders, and Terminal Sessions for persistent realtime I/O.
Centralized execution
Exegesis CE turns OrrinSDK tools & plugins into context-driven agentic runs.
Write-back
Results land as native Infinity objects - linked, searchable, and ready for the next hop.
Every object is a first-class citizen.
Drop native blocks onto the board - each styled for its job, linkable, and readable/writable by agents and marketplace tools.
Built for depth, not clutter.
Agents on the board
Invite Orrin agents - marketplace plugins or Stellr-built - to extract equations from PDFs, sketch graphs, summarize clusters, or draft linked notes. Traffic moves over Exegesis; outputs stay on the canvas.
Spatial search
Find by content or jump to regions. The board stays searchable at any zoom.
Containers & frames
Group study units, sprints, or chapters. Nest structure without burying it.
Live connections
Dashed links that track as you move cards - relationships stay honest.
Marketplace surface
Apps, tools, and agents from Orrin Marketplace install onto the same plane your notes already occupy.
No install friction
Open a blank infinity in the browser. Your board is ready in seconds.
From OrrinSDK today - to a UI SDK for Infinity.
Today, developers build for the broader Orrin ecosystem with OrrinSDK - apps backends (OrrinAppsSDK), tools (OrrinToolsSDK), and plugins/agents - then publish through the marketplace and wire execution through Exegesis CE and the WebSocket / Terminal Session layer.
OrrinInfinity is the spatial host for that work: marketplace packages become board-native citizens. The next step is explicit: a UI-based SDK aimed at Infinity itself - so you can author custom block types, inspectors, importers, tool UIs, and full canvas extensions that speak the board’s object model, layout, and realtime channels directly.
In short: backend intelligence and agent logic via OrrinSDK + Exegesis now; canvas-native presentation and interaction via the Infinity UI SDK as the surface matures.
OrrinSDK + Marketplace
Ship tools, app backends, and agents. Activate them on Infinity as spatial add-ons.
Exegesis WS & handlers
Realtime streams, Terminal Sessions, handlers/senders for agentic board traffic.
Infinity UI SDK
First-class APIs to build custom blocks, extensions, and tool UIs that only exist on the infinite canvas.
From capture to clarity.
Drop anything
Notes, PDFs, snippets, equations - plus marketplace tools and agents. Place them in space the way you think.
Link, stream & refine
Draw connections, nest containers, run agents over Exegesis to fill gaps. Structure emerges as you work.
Share the surface
Hand off a living board - not a stale export. Collaborators, tools, and agents meet you on the same plane.
Open a blank infinity.
Start a board in seconds. Marketplace add-ons and Exegesis-backed agents meet you on the same surface - no install required.