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.
Everything on the canvas.
A single surface for capture, structure, analysis, and agent collaboration. Every capability below lives as a first-class object or tool on the board.
Containers
Group related components in one place. Keep a chapter, sprint, or idea cluster together without losing the infinite canvas.
Nested Containers
Place containers inside containers. Build hierarchy - sections within projects, notes within frames - while everything stays spatial and movable.
Math Equations
Display styled math equations, no matter how advanced. KaTeX rendering keeps complex expressions clear and readable on the board.
LaTeX Support
Write fluent LaTeX in a dedicated editor or inline. Preview live, iterate, and keep mathematical documents next to the rest of your work.
Text Components
Write and style text with Markdown and LaTeX. Notes, outlines, and long-form writing sit naturally among other objects.
Graphs
Visualize functions and data. Plot, inspect, and analyze graphs directly on the canvas with an interactive calculator overlay.
Code IDE
Write and edit code with syntax awareness. Keep snippets, scripts, and experiments as first-class board objects.
External Board Linking
Link other boards as components on the canvas. Reference related work without leaving the current surface.
Metrics Components
Display key numbers, progress, and stats as polished metric cards. Track goals and deltas at a glance.
Math Calculator
Perform advanced math and get answers. When the result is transferable, port it straight to a graph.
Research Panel
Open a side panel for research. Gather sources and context while the board stays visible.
Multi-board
Convert a board into a multi-board. Hold several infinite canvases, pages, or LaTeX editors in one session and switch freely.
Open External Boards
Open another board and switch between them in the same session. Keep related work one click away.
Lodge External Boards
Pin an external board to the left or right edge. Edit and work with both boards side by side.
Draw
Draw freehand or shapes directly on the canvas. Annotate, sketch, and mark up around your components.
AI Chat
Chat with the components on the board. Ask questions, get explanations, and pull context from what’s already there.
Agent Abilities
The board’s agent can create, edit, and explain components. Let it scaffold structure or refine what’s already on the canvas.
Flashcards & Quizzes
Generate flashcards or quizzes from any components on the board. Turn notes and sources into study material in place.
Component Connections
Connect one component to another. Relationships stay visible and track as you move, preserving the flow of ideas.
Markdown Editor & Preview
Edit text components inline with a live preview. Pin a note to the side for a larger, focused markdown editor.
Flexible Customization
Custom colors, shapes, and borders. Add background images so components match the tone of the work.
Layout Modes
Force a layout on containers and other components. Stack, grid, or arrange internal objects the way the content demands.
Info, Sources & Citations
Attach additional information, sources, and citations to any component. Keep provenance next to the idea.
Name Components
Give components clear names. Labels stay visible so structure and search remain obvious as the board grows.
Import Files
Import images, PDFs, audio, and more. Any document becomes a component on the board, ready to link and annotate.
Bring the infinite canvas into your editor. The OrrinInfinity extension bridges board and code - so agents, components, and context flow both ways without leaving the IDE.
Extended features for the extension
Agent in built-in chat
Talk to the Infinity agent directly inside VS Code’s native chat panel. Context from the board is available without switching windows.
Simultaneous code & board edits
The agent can edit files in the IDE while updating linked components on the canvas in the same flow — one source of truth across surfaces.
Map components to code lines
Bind any board component to specific lines or ranges in the editor. Jump from canvas to source and keep structure visible in both places.
Highlight to Code IDE on canvas
Select code in the editor and drop it straight onto the board as a live Code IDE component — ready to link, annotate, or hand to an agent.
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.