✳YOUR WORLD, WITH A LITTLE MORE SENSE

Your intent,understoodWithout a word

An agent shell that understands your intent and brings it to life in the apps you already know. A more natural way to be with AI.

See it in actionMeet OctoSense

An open exploration of what comes after the chat box

A GLIMPSE OF YOUR EVERYDAY
octosense9:41
MONDAY, SEPTEMBER 14

Good morning, Alex

A fresh start, a little less to think about

A LITTLE HEADS-UP

Rain is on its way tomorrow. Today looks perfect for that walk.

CONCEPT PREVIEW

Interactive concept · Sample data
ONE VISION · EVERY PLATFORM

Support varies by platform. Desktop, Home and ROM have different build requirements; iOS has no integrated agent kernel. Current build guides are linked in the architecture section.

WindowsmacOSLinuxAndroidiOSOpenHarmony
A DIFFERENT STARTING POINT

AI should meet you where you are

We spent decades making computers more intuitive. The desktop. The mouse. Multi-touch. That progress belongs in the next chapter, too.

OctoSense brings agent intelligence into familiar interfaces. Open an app. Tap a card. Move things around. Your intent becomes something you can see, touch, and shape.

Read our thinking
ONE CONVERSATION
What can I help you with?↑
A WORLD OF POSSIBILITIES
System agent
Your plans
Your world
Your ideas
Your day
BUILT AROUND BEING HUMAN

Less prompting More living

The best interface is the one that makes sense to you.

/01

Feels like second nature

A launcher, a workspace, your favorite apps. Keep the gestures and habits you know. Let the intelligence behind them evolve.

/02

Takes the shape of your intent

Planning a trip should feel like planning a trip. The agent brings the right tools into view, in an interface you can act on.

/03

A little more you

Your apps can be as individual as your day. A quieter layout, a different rhythm, just the information that matters in the moment.

TRY IT YOURSELF / APP CARDS

Everyday moments, thoughtfully connected

A school email, a checkup, a reunion, a new home. Choose a story and follow the service cards through your day.

Try the interactive flow
04 / EVERY APP IS A WAY IN

Familiar doors Connected possibilities

Explore concept guides for how familiar apps could work together. These simulated workflows go beyond the current implementation; the architecture below explains what runs today.

  1. 01

    An event arrives

    A message, a changed forecast, or a scheduled time.

  2. 02

    Context connects

    The agent relates it to your plans and preferences.

  3. 03

    An App Card appears

    A reply, a calendar change, or a delivery to follow.

  4. 04

    Your decision carries through

    Approve, refine, or delegate a defined action.

01 / Open the guide

Mail

Read a message, shape the next action02 / Open the guide

Messages

Keep the conversation, let the arrangements come together03 / Open the guide

Calendar

An appointment is the beginning of a connected plan04 / Open the guide

Weather

The forecast, in the context of your plans05 / Open the guide

News

A personal newspaper, ready before the day begins06 / Open the guide

Music

A playlist that learns your rhythm07 / Open the guide

Video

The right watchlist for a question you care about08 / Open the guide

Markets

A watchlist with the reasons, sources, and open questions09 / Open the guide

Navigation

Getting there becomes part of the plan10 / Open the guide

Orders & shopping

A receipt becomes a useful little tracking app11 / Open the guide

Writing & creation

An editable proposal, beside the work it belongs to12 / Open the guide

System & devices

Understand a maintenance task before it runs

The action follows you

An App Card is a small, interactive application. It can stand on the desktop or live inside the email you are reading. The same action, with the same state, wherever you need it.

05 / A SENSE OF TIMING

Working ahead Showing up at the right time

These are proposed background workflows. Automatic app-agent triggers and schedules are not implemented in the current shell.

ON CHANGE

Keep the important things current

A delivery update, a school message, or a changed forecast can wake the relevant task and refresh its card.

BEFORE 06:00

Prepare before you arrive

Schedule a morning edition or a playlist in advance. You arrive to something ready to read, hear, or use.

WHEN IT FITS

Balance freshness, time, and cost

Prioritize urgent events. Batch less urgent research or use a lower-cost processing window when available, within the budget you choose.

Apps are entry points. App Cards carry actions. The agent connects the context; you decide what it may do.

IN THE CODE TODAY

One shell. Agents with clear roles.

OctoSense hosts your apps and connects them to a shared octos agent kernel. An agent is a model-driven participant that handles requests and can ask to use granted tools; the shell checks and executes the app operations.

The system assistant

Talk to the system assistant to coordinate work. It can ask an allowed app agent for help and gather the result.

An app’s own agent

An app that declares agent access or tools can receive an agent after your consent. The shell prepares an identity, called a peer, for that app and account; its tools and data access stay scoped.

You can ask the app directly

On desktop, “Ask <app>” opens a conversation with the app’s agent. Your conversation and a task from the system assistant have separate histories and can run alongside each other.

Follow one Calendar question

With Calendar on desktop, a configured model and consent, “What is on my calendar today?” can take either route. The model may call Calendar’s event tool to read the host-managed calendar.

The interactive diagram loads here. The text routes below work without JavaScript.

Read the routes as text

Ask the app

On desktop, ask “What is on my calendar today?” in Ask Calendar. With a configured model and consent, the app agent may use its event tool. The answer returns to your conversation.

  1. You ask Calendar. The shell’s Ask-app panel sends your message through the app’s scoped broker. Phone touch navigation does not yet open this panel.
  2. Your app conversation. The shell opens a context—a separate conversation—on Calendar’s app/account peer. Its model turn uses the app’s granted tools. This context has its own transcript, separate from system-delegated work.
  3. Calendar reads events. If the model calls calendar.events, the shell checks the call and invokes Calendar’s Rust host service. That service reads its calendar/events.json; the model does not gain general database access.
  4. You receive the answer. The tool result returns to the app’s model turn. Reply events then return through your human context to the Ask Calendar panel. This does not automatically start a system-agent turn.

System delegation

The system assistant can delegate the same question to Calendar’s agent. It uses a separate conversation on the same app/account peer, then gathers the result to answer you.

  1. System assistant delegates. agents.list discovers app agents; agents.ask obtains consent and a ready peer when needed. peer_send_input submits the task using the kernel-issued peer identifier.
  2. Calendar’s system lane. The kernel sends peer/input to the shell broker, which starts Calendar’s turn. This system lane is the peer’s conversation for delegated work. A separate human context can run alongside it; each keeps its own transcript.
  3. Calendar reads events. The app model may request its declared calendar.events tool. The shell’s relay checks authorization and dispatches to the owning service. The JSON result returns to that app turn.
  4. System assistant answers. Calendar’s completed answer is recorded on the kernel’s peer blackboard. The system assistant gathers it with peer_gather and answers in system chat. There is no general app-to-system-agent delegation API. Tool approval has a separate host-controlled route.

Rust execution

Follow a request from the UI into octos. Arrows show the request path; replies travel back through these boundaries. A peer is a durable identity, not one process, thread or Tokio task.

  1. Apps and shell UI. Native Rust modules run in the shell; selected apps can run in child processes. Contained main.splash apps run in a restricted Splash VM. L0 page.card content follows the separate Octoscript parser/lowering path.
  2. App broker. The broker is the shell adapter that binds app/account identity and routes conversation requests after consent. Each Broker builds a one-worker Tokio runtime for request and link work. More than one broker can share a durable peer.
  3. Shared kernel service. The shell’s kernel service shares one kernel generation across consumers. Its supervisor owns transport and process lifecycle. Desktop uses a kernel child process; OpenHarmony embeds it; iOS has no integrated kernel.
  4. octos turn work. octos first spawns a parked orchestration task. After active-turn admission succeeds, a oneshot barrier releases it to start Driver processing and tool futures. Host tool calls return through the broker to the shell executor, then results resume the model. The peer survives after these tasks finish.

The same peer can serve both routes. Each conversation keeps its own transcript and can receive a bounded excerpt of the other’s recent history.

Access follows the tool and the account

On Unix, an app agent can read an exposed account workspace through bounded file tools. It can also use an implemented app tool such as calendar.events. It does not automatically see every app database or credential. Calling another app’s tool also requires an offered tool, a sharing declaration, a caller grant and an executable handler; approvals follow the shell’s policy.

What is available, and what is still a proposal

News has read and notice tools; Calendar has event tools on desktop. Mail’s agent currently publishes notices with mail.notify: its UI’s read/send APIs are not agent tools. Automatic bundle triggers, script-implemented agent tools and general app-to-system-agent delegation remain unimplemented. The website’s email and scheduled-service stories illustrate proposed workflows. Shipped notice and Calendar cards have no in-card chat; the Mail chat demo uses canned replies.

For developers: hosting and Rust execution

Native Rust apps

Compiled modules run inside the shell; selected desktop apps can run as child processes. Module and process hosting are different launch choices, not one process per agent.

Contained script apps

App Hub admits the bundle before a Splash isolate evaluates main.splash. L0 page.card bundles use the separate Octoscript parser and Makepad lowering path. Design Flow’s tools/octo CLI launches App Hub’s card-host for local UI checks; that runner has no shell host services or agents.

Peers and Tokio tasks

A peer is a durable identity; a session owns a conversation, and a turn processes one input. Tokio tasks run the asynchronous work. The shell UI, broker runtimes and shared kernel service have separate scheduling boundaries. One peer is not one thread or one task.

The desktop and Android Home app share the Rust shell. OpenHarmony embeds the kernel; iOS currently has no integrated agent kernel. The ROM packages Home with Android platform services, including a privileged bridge distinct from the system LLM agent. Phone touch navigation does not yet open the Ask-app panel.

FROM IDEA TO INTERFACE

Small pieces A shared sense of purpose

An open-source stack with a Rust kernel and shell, script apps and platform integrations. Start with each repository’s README and license. Find your place in the stack.

All repositories
THE KERNEL

Octos

An embeddable, Rust-native agent harness: turns, context and memory, tools and sandboxing, multi-agent work and approvals.

octos
THE SHELL

OctoSense

The home for the experience. Cross-platform desktop and phone shells built with Makepad.

OctoSense
THE LANGUAGE

Octoscript

A language for bounded workflows and declarative cards, with a Rust parser and checker. Contained main.splash apps use the separate Makepad Script path.

WebsiteOctoScript
THE BUILDING BLOCKS

Apps

Small contained script apps that turn an intent into something you can use. Build one with the app design flow, publish it on the App Hub, and see the first-party apps as examples.

App-Design-FlowOctoSense-App-HubOctoSense/apps
THE RENDERERS

At home on your device

Bring Octoscript interfaces to Makepad, the Rust UI framework underneath, and to Android and OpenHarmony.

MakepadAndroidOH
THE SYSTEM

OctoSense ROM

LineageOS for the OnePlus 6 with Home and a privileged Android bridge built in. The bridge provides platform operations; the shell hosts the AI conversations.

OctoSense/rom
A FEW THINGS TO KNOW

A little more clarity

Is OctoSense a new operating system?

OctoSense is an agent shell: an interaction layer above a traditional operating system. The goal is to bring apps, context, and agent capabilities into one familiar home across desktop and mobile.

How is this different from an AI chat app?

Conversation is one useful way to express intent. OctoSense explores a broader interface: interactive cards, apps, direct manipulation, and familiar gestures. The agent helps shape the workspace itself.

Can I still use apps directly?

Yes—that is central to the idea. You can launch apps and interact with them yourself. Agent assistance should build on that control and make the experience more useful.

What is it built with? Is it open source?

Rust powers the octos kernel, Makepad UI framework and OctoSense shell. Apps can use Splash scripts or Octoscript L0 cards; Android and other platform integrations also use platform-specific code. The projects are open source; see each repository for its license.

Can I try it or contribute?

Yes. Run the desktop shell with cargo, install the OctoSense Home app on an Android phone, or flash the OctoSense ROM on a OnePlus 6; all three build from the OctoSense repository, which has current build instructions. To build your own app, start with OctoScript-App-Design-Flow; the Agentic App Hackathon is a good place to start building. The preview on this website illustrates the concept using sample data; it is not a running agent.

THE NEXT INTERFACE IS OURS TO BUILD

Let’s make technology a little more human

An idea worth exploring. A future worth building together.

Build with us on GitHubJoin the Agentic App Hackathon