A local-first, open-source AI ecosystem that connects your devices, applications, models, tools, memory and autonomous agents into one personal runtime.
One ecosystem · Multiple agents · Any model · Any device
Note
Orbit is in active early development. Features listed below reflect the current build plan — check the Roadmap for what's shipped vs. planned.
Warning
📑 Table of Contents
- What is Orbit?
- Why I Built This
- The Orbit Vision
- Demo
- Features
- AI Ecosystem
- Multiple AI Agents
- AI Runtime
- Models
- Personal Intelligence
- Productivity & Focus
- Voice & Natural Interaction
- Computer & App Control
- Memory & Context
- Files & Knowledge
- Web & Research
- Connectors & Tools
- Automation
- Cross-Device AI
- How Orbit Looks
- Orbit vs. Alternatives
- Supported Platforms
- Architecture
- Security & Privacy
- Getting Started
- Roadmap
- What Orbit Is Not
- FAQ
- Repository Activity
- Star History
- Contributing
- Support the Project
- Built With
- License
Orbit 1.0 is being built phase by phase. What exists in this repo today:
- Desktop agent: pairing, pinned TLS, scoped sessions, an activity log, kill switch, and commands for agent tasks, clipboard, files, launcher, dictation, memory and (opt-in) remote input.
- Phone side: a typed client core and an Expo app with Tasks, Activity, Apps (launcher + scenes with time and place triggers), Clipboard (sync + history), Files (transfer + photo backup + share-in), Memory, Remote (trackpad, gyro, full keyboard, macros), Present, Control (media transport, volume, per-app mixer, power, panic lock), Automations, Terminal, Tabs (browser tab control via the companion extension), Computers (multi-PC), Devices (permissions + revocation) and Settings screens.
- Memory: a local graph memory store.
- Router: sends a request to a fast local model (Laya) or the Hermes agent.
- Tests: automated tests for desktop, phone core and end-to-end (phone core against the real desktop over real TLS). CI runs all of them on every push. The suites are adversarial: security and integrity guards are verified by mutating the product code and requiring a test to fail, and the fixtures include misbehaving peers, fake TLS servers holding real keys, flooded processes and stalled approvals - not just the happy path.
What is proven on real devices so far: QR pairing and the encrypted session between a Windows 11 PC and an iPhone (October 14, over a Windows hotspot). Everything else has passed automated tests (657 desktop, 265 phone core, 142 end-to-end) but is waiting on one structured real-device pass. Platform-honest limits are documented per feature: clipboard sync, photo backup and place triggers run while the phone app is open, and true iOS share-sheet extensions need a separate native target. There has been no independent security review. To run it yourself: docs/BUILD-CHECKLIST.md, then the 30-step pass in docs/TESTING.md; per-feature status lives in docs/ACCEPTANCE.md.
Apple's Continuity — Handoff, Universal Clipboard, AirDrop — only works between Apple devices. Mix an iPhone with a Windows or Linux PC, or an Android phone with any desktop, and that seamlessness disappears.
Orbit brings it back, for any combination of devices.
A companion app for your phone and a lightweight service for your PC, connected over a fast local channel, giving you instant clipboard sync, direct file transfer, and full remote control — no cloud round-trips, no vendor lock-in.
But Orbit is designed to become much more than device continuity.
It connects:
- your devices
- your applications
- your files
- your AI models
- your AI agents
- your memory
- your tasks
- your automations
- your tools
- your workflows
through one persistent runtime.
Instead of opening a different application for every task, Orbit gives you one environment where AI can understand your context, plan work, delegate tasks, operate applications, use tools, and continue working across your devices.
Orbit is not an AI model. Orbit is the harness and ecosystem around AI.
The model can change.
The device can change.
The agent can change.
The tools can change.
Your Orbit stays the same.
I got tired of emailing files to myself and losing clipboard content every time I switched between my phone and my PC — especially since my devices don't all live in the same ecosystem.
Existing tools either lock you into one vendor or solve only one part of the problem.
Orbit started as an attempt to build the tool I actually wanted:
One seamless layer connecting all my devices, regardless of what operating system they run.
The vision has now expanded.
Computers are becoming capable of running powerful local AI, and AI systems are becoming capable of operating software rather than simply answering questions.
Orbit brings those ideas together.
Instead of having:
AI app
+ productivity app
+ automation app
+ remote-control app
+ file-sharing app
+ task manager
+ local AI runtime
+ agent framework
+ separate tools
Orbit aims to provide:
ORBIT
│
┌───────────────────┼───────────────────┐
│ │ │
Devices AI Tools
│ │ │
Phone/Laptop Agents/Models Apps/Browser/APIs
│ │ │
└───────────────────┼───────────────────┘
│
One ecosystem
Orbit is designed to become a personal AI operating layer.
You should not have to think:
Which AI should I use?
Which application should I open?
Which model should I select?
Which device has enough compute?
Which agent should handle this?
Where is that file?
How do I automate this?
You should be able to say:
"Orbit, handle this."
Orbit can then understand the goal, determine what needs to happen, select the appropriate model and agents, use the required tools, execute the work, verify the result, and return the outcome.
User
↓
Understand
↓
Plan
↓
Delegate
↓
Execute
↓
Verify
↓
Remember
↓
Continue
The long-term goal is not a single assistant window.
It is an ecosystem of intelligence that works with the user across their entire computing environment.
A live demo will be linked here once Orbit reaches a public beta.
The planned experience includes:
- persistent AI presence
- natural voice/text interaction
- multiple active agents
- live task progress
- cross-device continuity
- local AI
- computer control
- files and applications
- proactive assistance
- background work
| Feature | Mobile | Desktop |
|---|---|---|
| Bidirectional clipboard sync | Yes | Yes |
| Clipboard history across devices | Yes | Yes |
| App-marked private copies never synced or stored | Yes | Yes |
| Direct file transfer (no cloud) | Yes | Yes |
| Native share-sheet integration | Yes | N/A |
| Drag-and-drop file drop zone | N/A | Yes |
| Auto-organize transferred files | N/A | Yes |
| Photo auto-backup to PC | Yes | Yes |
| Customizable app launcher grid | Yes | N/A |
| Context-aware launcher ("scenes") | Yes | N/A |
| Full mouse/touchpad control | Yes | N/A |
| Gyroscope mouse mode | Yes | N/A |
| Full keyboard input + custom macros | Yes | N/A |
| System volume & per-app audio mixer | Yes | Yes |
| Media transport (play/pause/skip) | Yes | Yes |
| Power control (shutdown/sleep/restart/lock) | Yes | Yes |
| Wake-on-LAN | Yes | N/A |
| Display brightness & mode control | Yes | Yes |
| Presentation mode (slides + laser pointer) | Yes | N/A |
| Browser tab control | Yes | Yes |
| QR pairing + biometric confirmation | Yes | Yes |
| Per-device permission scoping | N/A | Yes |
| Activity log & panic lock | Yes | Yes |
| Automation / scheduled actions | Yes | Yes |
| Multi-PC support | Yes | N/A |
| Developer/terminal remote access | Yes | Yes |
| AI-driven natural-language PC control (first slice: volume, brightness, media, dark/light, app and scene launch - typed or dictated) | Yes | Yes |
Brightness is get/set level end-to-end and returns null on desktops without a controllable backlight (most desktops). Mode control switches the dark/light app theme (Windows registry, apps + taskbar; GNOME color-scheme on Linux); night light is deliberately not toggled programmatically - its state is an undocumented binary blob and writing it could corrupt Windows Settings. Per-feature status: docs/ACCEPTANCE.md.
See and control your computer's browser tabs from your phone: every open tab listed, tap to bring one to the front, close tabs, and send links to open on the PC. Works with Chrome, Edge, and Brave.
One-time setup:
- Update and start Orbit on your computer, then open Orbit's Settings - the Browser extension card shows a port and token.
- In Chrome or Edge, open
chrome://extensions, turn on Developer mode, choose Load unpacked, and pick theextension/folder from this repo. - The extension's setup page asks for the port and token - copy them from Orbit's Settings. The extension badge turns green when connected.
The extension talks only to the Orbit app on the same computer (loopback-only, token-authenticated). Nothing leaves your machine.
| Capability | Status |
|---|---|
| Local AI | Planned |
| Cloud AI as optional backend | Planned |
| Automatic model selection | Planned |
| Fast AI routing | Done (Laya triage + per-request answer-only tasks) |
| Deep reasoning | Planned |
| Multi-agent execution | Planned |
| Parallel agents | Planned |
| Persistent agents | Planned |
| Agent-to-agent communication | Planned |
| Background AI workers | Planned |
| Personal memory | Planned |
| Context-aware assistance | Planned |
| Natural-language computer control | First slice done (deterministic en/Hindi patterns onto the real command surface; wider coverage planned) |
| Voice assistant | Planned |
| Streaming voice interaction | Planned |
| Task management | Planned |
| Notes | Planned |
| Reminders | Planned |
| Habits | Planned |
| Calendar intelligence | Planned |
| Focus mode | Planned |
| Productivity analytics | Planned |
| Proactive suggestions | Planned |
| Browser automation | Planned |
| Web research | Planned |
| Document understanding | Planned |
| OCR | Planned |
| Image understanding | Planned |
| Image generation/editing | Planned |
| Code generation | Planned |
| Code execution | Planned |
| App automation | Planned |
| Connector ecosystem | Planned |
| Long-running tasks | Planned |
| Scheduled agents | Planned |
| Cross-device AI state | Planned |
| Device-aware AI execution | Planned |
| Local knowledge / RAG | Planned |
| Agent permissions | Planned |
| AI activity timeline | Planned |
Orbit is not built around one AI model or one agent.
It provides a runtime in which different models and agents can work together.
ORBIT
│
Personal Context
│
┌────────────┴────────────┐
│ │
FAST LAYER DEEP LAYER
│ │
Fast decisions Deep reasoning
Routing Research
Actions Coding
Reflexes Planning
│ │
└────────────┬────────────┘
│
ORCHESTRATOR
│
┌────────────┼────────────┐
│ │ │
Agents Memory Tools
│ │ │
└────────────┼────────────┘
│
DEVICE MESH
│
┌────────┬───────┼───────┬────────┐
│ │ │ │ │
Phone Laptop Desktop Tablet Server
Orbit can combine:
- small fast local models
- larger local models
- vision models
- speech models
- coding models
- reasoning models
- optional cloud models
The user should not need to manually manage every model for every task.
Orbit is not a single-agent assistant.
Multiple AI workers can operate simultaneously.
Each agent can have:
- a role
- a task
- memory
- tools
- permissions
- model preferences
- context
- workspace
- status
- execution history
Example:
ORBIT
│
ORCHESTRATOR
│
┌──────────────┼──────────────┐
│ │ │
Researcher Coder Planner
│ │ │
Browser Terminal Calendar
│ │ │
└──────────────┼──────────────┘
│
Verifier
│
Result
User:
"Research this topic, compare the options, create a spreadsheet and prepare a summary."
Orbit can run:
Research Agent
↓
collects information
Analysis Agent
↓
compares information
Spreadsheet Agent
↓
creates structured data
Writing Agent
↓
creates summary
Verification Agent
↓
checks output
These workers can operate in parallel whenever their work is independent.
Orbit can maintain persistent workers that can be activated whenever needed.
Examples:
Handles:
- tasks
- reminders
- planning
- calendar
- personal context
Handles:
- web research
- source collection
- information extraction
- comparisons
- reports
Handles:
- code
- repositories
- terminal
- debugging
- testing
- development workflows
Handles:
- websites
- browser navigation
- forms
- repetitive web tasks
- research
Handles:
- local files
- folders
- PDFs
- documents
- organization
- extraction
Handles:
- focus
- activity patterns
- distractions
- productivity analysis
Handles:
- scheduled tasks
- triggers
- recurring workflows
- background jobs
Handles:
- writing
- presentations
- images
- documents
- creative workflows
Handles:
- connected devices
- system actions
- synchronization
- device state
These are logical workers, not necessarily separate models.
Multiple workers can share the same local model runtime or use different models depending on their requirements.
Orbit uses two complementary AI execution layers.
Simple tasks should not wait for a large reasoning model.
A lightweight local model can handle:
- intent detection
- routing
- tool selection
- simple decisions
- repetitive actions
- agent activation
- context prefetching
- low-latency commands
- UI actions
Input
↓
Fast understanding
↓
Simple?
┌──┴──┐
YES NO
│ │
Action Deep reasoning
This layer is designed to make Orbit feel extremely responsive.
Complex work can be routed to stronger models.
Examples:
- difficult reasoning
- coding
- research
- planning
- long documents
- complex workflows
- analysis
- architecture
- multi-step tasks
Orbit chooses the appropriate execution path based on the task.
Orbit is model agnostic.
The AI model is replaceable.
Possible backends include:
- local models
- quantized models
- vision models
- speech models
- coding models
- reasoning models
- optional cloud models
- user-provided models
- custom runtimes
Orbit can inspect available hardware:
CPU
GPU
VRAM
RAM
NPU
Battery
Thermals
Network
↓
Hardware Profile
↓
Model Selection
↓
Runtime
A powerful desktop may run a larger model.
A laptop may run a medium model.
A phone may use a lightweight model.
A server can run background workers.
The ecosystem remains the same.
The model changes. Orbit does not.
Orbit can become aware of the user's workflow without requiring the user to manually maintain everything.
With permission, Orbit can understand:
- tasks
- notes
- calendar
- habits
- activity
- frequently used applications
- projects
- files
- devices
- recurring workflows
- deadlines
- working patterns
This allows Orbit to answer questions such as:
"What should I work on next?"
"When am I usually most productive?"
"What did I work on yesterday?"
"Find the notes related to this project."
"Plan my day."
"I have three hours. What should I finish?"
Orbit can optionally become a personal productivity layer.
- natural-language task creation
- deadlines
- priorities
- subtasks
- task search
- task completion
- project grouping
- one-time reminders
- recurring reminders
- contextual reminders
- scheduled notifications
- device-aware notifications
- habit creation
- habit tracking
- streaks
- progress
- recurring schedules
- habit reminders
- calendar integration
- schedule awareness
- free-time detection
- task scheduling
- deadline planning
Orbit can optionally:
- start focus sessions
- close distracting applications
- block selected websites
- track focus duration
- restore blocked applications after the session
- provide productivity summaries
With explicit permission, Orbit can understand patterns such as:
- time spent in applications
- productive vs. distracting activity
- focus periods
- work patterns
- recurring distractions
All such monitoring should remain opt-in and privacy-controlled.
Orbit should feel conversational.
Users can:
- speak
- type
- dictate
- interrupt
- continue previous tasks
- ask follow-up questions
- change instructions
- switch devices
Examples:
"Plan my day."
"Remind me to finish this at 6."
"Open the project I was working on."
"Find the PDF about the project."
"Research this while I work."
"Tell the coding agent to fix this."
"Ask another agent to verify it."
"I'm leaving. Continue this on my desktop."
"Keep working and notify me when it's done."
Orbit is designed around streaming interaction.
It should not always wait for the user to finish an entire sentence before preparing the task.
User starts speaking
↓
Streaming speech recognition
↓
Fast intent detection
↓
Context retrieval
↓
Agent/model preparation
↓
User finishes
↓
Execution
While the user is speaking, Orbit can safely prepare:
- relevant context
- files
- applications
- agents
- tools
- models
- browser state
High-impact actions still require complete intent and appropriate permissions.
Orbit can maintain a local personal memory layer.
Possible memory includes:
- preferences
- projects
- tasks
- notes
- devices
- workflows
- decisions
- previous conversations
- agent history
- relevant files
- recurring patterns
Instead of treating every piece of information as isolated text:
Person
│
Project
├── Files
├── Tasks
├── Notes
├── Conversations
├── Agents
├── Decisions
└── Deadlines
This allows agents to retrieve related information more intelligently.
Memory should be:
- inspectable
- searchable
- editable
- deletable
- permission-controlled
- optionally disabled
Orbit can work directly with local information.
Capabilities can include:
- file search
- semantic file search
- PDF reading
- document understanding
- OCR
- scanned document processing
- image understanding
- folder analysis
- document summarization
- extraction
- comparison
- local knowledge bases
- retrieval-augmented generation
Example:
"Read this project folder and prepare a summary."
Find files
↓
Classify
↓
Read / OCR
↓
Extract
↓
Retrieve relevant context
↓
Reason
↓
Generate
↓
Verify
When internet access is enabled, Orbit can perform research workflows.
Possible capabilities:
- search
- browse
- read pages
- compare sources
- collect information
- extract data
- summarize findings
- monitor information
- create reports
- save sources
Internet access can be disabled completely for offline/private environments.
LOCAL
No internet required
HYBRID
Local by default
Web when allowed
ONLINE
Web + cloud tools available
Orbit can turn AI into a computer-control layer.
Agents can interact with:
- applications
- browser
- windows
- tabs
- keyboard
- mouse
- clipboard
- terminal
- files
- folders
- system controls
Possible actions:
Open application
Close application
Create file
Move file
Rename file
Search folder
Read document
Run command
Open terminal
Type
Click
Navigate
Open URL
Switch window
Control media
Change volume
Change display
Lock computer
Start focus mode
The goal is not:
"Here are instructions for doing it."
The goal is:
"I did it."
Orbit will provide an extensible tool and connector layer.
Connectors can expose controlled capabilities from:
- applications
- browsers
- APIs
- databases
- cloud services
- local services
- developer tools
- project management systems
- communication systems
- storage systems
- custom applications
Capabilities can include:
Read
Write
Create
Update
Search
Execute
Observe
Each connector should have its own permissions.
Orbit should support compatible tool protocols and local tool servers without making the core runtime dependent on one provider.
Orbit can convert repeated actions into workflows.
Examples:
"Every morning, prepare my work plan."
"When I connect my laptop, open my workspace."
"When this file appears, organize it."
"Every Friday, summarize my project activity."
"When my focus session starts, block distractions."
"When the research agent finishes, send the result to the writing agent."
Automations can be:
- scheduled
- event-driven
- conditional
- application-based
- device-based
- file-based
- agent-driven
Orbit is designed to continue working even when the user is doing something else.
Example:
User
│
└── "Research this topic."
│
↓
Orbit starts task
│
┌────┼────┐
↓ ↓ ↓
Search Read Analyze
│ │ │
└────┼────┘
↓
Verify
↓
Save result
↓
Notify user
Long-running tasks can continue in the background where the device and permissions allow.
Orbit is not just a collection of apps.
The goal is one persistent ecosystem.
ORBIT
│
┌──────────┼──────────┐
│ │ │
Phone Laptop Desktop
│ │ │
└──────────┼──────────┘
│
Tablet
│
Server
A task can start on one device and continue on another.
Example:
Phone
↓
Voice request
↓
Orbit
↓
Laptop
└── reasoning
Desktop
└── heavy model
Server
└── background workers
Phone
↓
Completion notification
Orbit can select the best device for a task based on:
- compute
- model availability
- battery
- network
- latency
- permissions
- task requirements
Orbit should not feel like a giant dashboard.
It should feel like a quiet persistent presence.
The default state can be minimal.
─────────────
Orbit
─────────────
When activated, it expands into a lightweight command surface.
┌───────────────────────────────────────────────────┐
│ Orbit ● Ready│
│ │
│ What are we working on? │
│ │
│ ┌─────────────────────────────────────────────┐ │
│ │ Ask Orbit anything... 🎙│ │
│ └─────────────────────────────────────────────┘ │
│ │
│ Active work │
│ │
│ ● Research Agent Working │
│ ● Coding Agent Working │
│ ✓ File Agent Completed │
│ │
└───────────────────────────────────────────────────┘
The interface should be:
- minimal
- fluid
- fast
- premium
- distraction-free
- voice-friendly
- keyboard-friendly
- responsive
- consistent across devices
Orbit can expose different views depending on what the user is doing.
For:
- questions
- commands
- voice
- quick actions
Shows:
- active agents
- progress
- current actions
- waiting tasks
- completed work
- failures
Shows:
Personal Manager Active
Research Agent Working
Coding Agent Working
Browser Agent Waiting
Automation Agent Scheduled
Shows:
Laptop Online
Phone Online
Desktop Online
Tablet Offline
Home Server Online
Search:
- conversations
- notes
- projects
- tasks
- files
- decisions
- activity
Shows:
- agent actions
- device events
- completed tasks
- automations
- approvals
- notifications
| Orbit | Apple Continuity | KDE Connect | Remote Mouse | |
|---|---|---|---|---|
| Cross-ecosystem (any OS combo) | ✅ | ❌ Apple-only | ✅ | |
| Clipboard sync | ✅ | ✅ | ✅ | ❌ |
| Direct file transfer | ✅ | ✅ | ✅ | ❌ |
| App launcher / widget grid | ✅ | ❌ | ❌ | |
| Full mouse/keyboard control | ✅ | ❌ | ✅ | |
| No cloud round-trip | ✅ | ✅ | ✅ | ✅ |
| Screen mirroring | ❌ (by design) | ❌ | ❌ | |
| Local AI | ✅ | ❌ | ❌ | ❌ |
| Multiple AI agents | ✅ | ❌ | ❌ | ❌ |
| Background AI work | ✅ | ❌ | ❌ | ❌ |
| Model choice | ✅ | ❌ | ❌ | ❌ |
| Personal AI memory | ✅ | ❌ | ❌ | ❌ |
| AI computer control | ✅ | ❌ | ❌ | ❌ |
| AI automation | ✅ | ❌ | ❌ | |
| Cross-device AI state | ✅ | ❌ | ❌ | ❌ |
| Local-first architecture | ✅ | ✅ |
| iOS | Android | Windows | Linux | |
|---|---|---|---|---|
| Orbit Mobile | ✅ | ✅ | — | — |
| Orbit Desktop | — | — | ✅ | ✅ |
| AI Runtime | Planned | Planned | Planned | Planned |
| Local Models | Hardware dependent | Hardware dependent | Planned | Planned |
| Cross-device AI | Planned | Planned | Planned | Planned |
flowchart TB
User["👤 USER<br/>Voice · Text · Context"]
subgraph Experience["ORBIT EXPERIENCE"]
Quick["Quick Command Surface"]
Voice["Voice Interface"]
Work["Live Work Surface"]
AgentsUI["Agent Workspace"]
DeviceUI["Device Mesh"]
MemoryUI["Memory & Activity"]
Focus["Focus Mode"]
end
subgraph AI["🧠 ORBIT AI RUNTIME"]
Perception["Perception & Context"]
Fast["Fast Intelligence<br/>System 1"]
Deep["Deep Intelligence<br/>System 2"]
Router["Model Router"]
Orchestrator["Agent Orchestrator"]
Planner["Task Planner"]
Verify["Verification & Recovery"]
end
subgraph Agents["🤖 MULTI-AGENT WORKFORCE"]
Personal["Personal Manager"]
Research["Research Agent"]
Coding["Coding Agent"]
Browser["Browser Agent"]
Files["File Agent"]
Automation["Automation Agent"]
Creative["Creative Agent"]
Device["Device Agent"]
Productivity["Productivity Agent"]
end
subgraph Memory["🧠 MEMORY & CONTEXT"]
Short["Short-term Context"]
Long["Long-term Memory"]
Graph["Context Graph"]
RAG["Local Knowledge / RAG"]
Activity["Activity Context"]
end
subgraph Models["MODEL LAYER"]
Light["Light Local Models"]
Medium["Medium Local Models"]
Large["Large Local Models"]
Vision["Vision Models"]
Speech["Speech Models"]
Cloud["Optional Cloud Models"]
end
subgraph Tools["🔌 TOOL & CONNECTOR BUS"]
Apps["Applications"]
BrowserTool["Browser"]
Terminal["Terminal"]
FilesTool["Files"]
APIs["APIs"]
Connectors["Connectors"]
end
subgraph Devices["🌐 ORBIT DEVICE MESH"]
Phone["Phone"]
Laptop["Laptop"]
Desktop["Desktop"]
Tablet["Tablet"]
Server["Local Server"]
end
Security["🔐 SECURITY & PERMISSIONS"]
User --> Experience
Experience --> AI
AI --> Agents
AI --> Memory
AI --> Models
Agents --> Tools
Agents --> Memory
Agents --> Verify
Models --> Router
Tools --> Devices
Devices --> Tools
Security --> AI
Security --> Agents
Security --> Tools
Security --> Devices
Orbit is made up of two primary components talking over one encrypted, low-latency channel:
- Orbit Mobile — React Native app (iOS/Android). Sends commands, receives clipboard/file events.
- Orbit Desktop — Node.js background service (Windows/Linux). Simulates input, handles file transfer, executes commands.
Discovery is handled via mDNS/Bonjour on the local network.
QR-code pairing creates a durable device credential; short-lived session tokens renew automatically without rescanning.
Background wake via APNs/FCM is deferred entirely for v1 — no third-party push infrastructure is used.
The AI layer will sit above the device layer rather than replacing it.
Orbit is designed around local-first computing.
Orbit should prefer local execution whenever practical.
Local features can continue working without internet access.
Potential offline capabilities include:
- local AI
- local memory
- tasks
- notes
- reminders
- device control
- file operations
- local automation
- local agents
Cloud models are optional.
Users can choose:
LOCAL ONLY
HYBRID
CLOUD ENABLED
Orbit should never silently send private information to a cloud provider.
All communication between Orbit devices should use encrypted channels.
Users should be able to change:
- models
- model providers
- connectors
- agents
- runtimes
without rebuilding the Orbit ecosystem.
The long-term architecture supports running Orbit infrastructure on:
- personal computers
- home servers
- NAS systems
- private servers
- local networks
An AI capable of controlling a computer needs strict boundaries.
Agents should use capability-based permissions.
Example:
Research Agent
✓ Search web
✓ Read public files
✓ Read browser
✗ Delete files
✗ Send messages
✗ Spend money
Coding Agent
✓ Read project
✓ Edit project
✓ Run tests
✓ Use terminal
✗ Access unrelated folders
✗ Publish without approval
Permissions can be scoped by:
- agent
- device
- application
- connector
- folder
- tool
- action
- session
LOW RISK
Automatic
MEDIUM RISK
Configurable
HIGH RISK
Require approval
CRITICAL
Always require explicit confirmation
Orbit should also provide:
- audit logs
- action history
- emergency stop
- agent pause
- connector revocation
- device session revocation
- sandboxed execution
- prompt-injection defenses
git clone https://github.com/mananbharti/orbit.git
cd orbit
# Desktop agent (Node 24)
cd desktop
npm ci
npm test # should be all green first
npm start # prints a pairing QR
# Phone app (Expo)
cd ../mobile/app
npm install
npx expo startThen scan the pairing QR from the app, with the phone on the same network as the computer. Settings, scopes and optional features (agent tasks, dictation, remote input) are covered in docs/getting-started.md. Before trusting it, go through docs/device-test-checklist.md.
- Core architecture design
- Clipboard sync
- File sharing
- App launcher
- Mouse / keyboard control
- Power control
- QR pairing
- Device discovery
- Security hardening
- Clipboard history
- Continue-on-device workflows
- Context-aware launcher
- Multi-device support
- Device presence
- Cross-device state
- Cross-device notifications
- Device-aware execution
- Local server support
- Local model runtime
- Model abstraction layer
- Hardware detection
- Automatic model selection
- Fast intelligence layer
- Deep reasoning layer
- Vision support
- Speech-to-text
- Text-to-speech
- Model profiles
- Natural-language PC control
- Voice assistant
- Streaming voice interaction
- Personal memory
- Local knowledge retrieval
- Tasks
- Notes
- Reminders
- Calendar intelligence
- Habit tracking
- Focus mode
- Productivity analytics
- Proactive assistance
- Agent runtime
- Persistent agents
- Parallel execution
- Agent-to-agent communication
- Agent memory
- Shared task state
- Agent permissions
- Agent monitoring
- Agent scheduling
- Background workers
- Verification and recovery
- Connector framework
- Browser control
- Terminal control
- File tools
- Application tools
- API connectors
- Compatible tool protocols
- Connector permissions
- Tool sandboxing
- Long-running tasks
- Scheduled agents
- Conditional automations
- Research workflows
- Coding workflows
- Document workflows
- Background execution
- Cross-device task migration
- Proactive workflows
- Distributed local inference
- Optional cloud workers
- Shared personal context
- Custom agents
- Custom model runtimes
- Community connectors
- Developer SDK
- Self-hosted server
- Advanced automation
- Agent extensions
Orbit deliberately does not aim to be:
- only a chatbot
- only a local LLM launcher
- only a remote mouse
- only a file-sharing application
- only an automation tool
- only an agent framework
- only a productivity tracker
- only a cloud AI service
- a mandatory cloud platform
- a screen-mirroring application
Orbit connects these capabilities into one ecosystem.
Orbit is the harness around AI, not the AI model itself.
Is Orbit an AI model?
No.
Orbit is the runtime and ecosystem around AI. Different local and cloud models can be connected while keeping the same agents, tools, memory and device ecosystem.
Can multiple AI agents work at the same time?
Yes.
Orbit is designed around parallel multi-agent execution. Independent tasks can be delegated to different workers and executed concurrently.
Does every agent need its own AI model?
No.
Agents are logical workers. Multiple agents can share the same model runtime or use different models depending on their tasks.
Can agents work in the background?
Yes.
Orbit is designed to support persistent and scheduled workers that can continue approved tasks while the user is doing something else.
Can Orbit use local AI?
Yes.
Local AI is a core part of the architecture. Orbit can select models according to available hardware and task requirements.
Can Orbit use cloud AI?
Yes, optionally.
Users can choose local-only, hybrid or cloud-enabled execution.
Can Orbit control my computer?
Yes.
With appropriate permissions, Orbit can interact with applications, browser windows, files, keyboard, mouse, terminal and system controls.
Can Orbit work offline?
Yes for local capabilities.
Local AI, local memory, device control, files, tasks and other offline-capable features can continue without internet access.
Can Orbit work across multiple devices?
Yes.
Cross-device continuity is one of Orbit's core foundations. The long-term goal is for tasks, agents, memory and workflows to move seamlessly between supported devices.
Can Orbit automatically select models?
Yes.
The planned model router can consider hardware, task complexity, latency, privacy requirements and model capabilities.
Does Orbit send everything to the cloud?
No.
Orbit is designed local-first. Cloud access is optional and permission-based.
Can I use Orbit without the AI layer?
Yes.
The original device-continuity functionality is designed to work independently from the AI runtime.
Will Orbit support screen mirroring?
Not as a core feature.
Orbit is intentionally focused on commands, events, files, application control and AI actions rather than continuous screen streaming.
Can I run Orbit on my own server?
That is part of the long-term architecture.
The goal is to support private self-hosted infrastructure for persistent workers and additional compute.
Orbit is early-stage and designed to become a community-built AI and device ecosystem.
Contributions are welcome across:
- device integrations
- platform support
- AI runtimes
- model adapters
- agent runtimes
- connectors
- automation
- security
- UI/UX
- accessibility
- documentation
- testing
- performance
- developer tooling
Open an issue before submitting a large architectural change.
See CONTRIBUTING.md for guidelines.
If Orbit saved you a few "email it to myself" moments, consider fueling the next build:
- React Native — cross-platform mobile app
- Node.js — desktop background service
- nut-js — cross-platform input simulation
- TypeScript — type safety
- WebSocket — low-latency communication
- mDNS / Bonjour — local discovery
- Native OS APIs — system integration
- Local AI runtimes — private model execution
- Model adapters — interchangeable AI backends
- Agent runtime — parallel task execution
- Connector layer — application and tool integration
- Local storage — memory and task state
Your computer should be capable of being your AI's home.
Your workflow should not depend on one AI model or provider.
Your ecosystem should work regardless of which operating systems your devices use.
AI should be able to complete work, not just explain how to do it.
Independent work should happen simultaneously.
With permission, Orbit should anticipate useful actions instead of waiting for every instruction.
Sensitive information should remain local whenever practical.
Developers should be able to extend Orbit with models, agents, tools and connectors.
Autonomy should always remain bounded by permissions and user control.
Simple actions should feel instant. Heavy reasoning should only be used when necessary.
The long-term goal of Orbit is simple:
Build a personal AI ecosystem that lives with you instead of living inside one application.
Your devices become connected.
Your AI becomes persistent.
Your agents become a workforce.
Your applications become tools.
Your files become searchable.
Your workflows become automations.
Your models become replaceable.
Your intelligence follows you across devices.
And everything stays connected through one personal runtime.
YOU
│
▼
ORBIT
│
┌─────────────────┼─────────────────┐
│ │ │
MEMORY AGENTS TOOLS
│ │ │
│ ┌──────┼──────┐ │
│ │ │ │ │
│ Code Research Personal Apps
│ │ │ │ │
└──────────┴──────┼──────┴──────────┘
│
AI RUNTIME
│
┌───────────┴───────────┐
│ │
LOCAL MODELS OPTIONAL CLOUD
│ │
└───────────┬───────────┘
│
ORBIT DEVICE MESH
│
┌──────────┬───────┼───────┬──────────┐
│ │ │ │ │
Phone Laptop Desktop Tablet Server
Built by Manan Bharti
Orbit is licensed under the Apache License 2.0.
