Skip to content
xxxbrianPublic

About

Ochi is a personal agent that lives in the cloud, with its own computing environment. Start a task from the web, iOS, or Android, and let it research, work with files, run tools, and operate a computer in the cloud. No local development setup. No computer to keep running.

Resources

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

Ochi

Ochi

A self-hosted AI workspace, across Web, iOS, and Android.
Research, write, run code, and work with a computer. Keep the work in one place.

English · 简体中文
Get started · How it works · Self-hosting · Architecture

Ochi on Web and iOS: a conversation, a report preview, and the same work on a phone

Ochi brings model choice, tools, files, memory, and a persistent Linux desktop into a conversation. Connect your own providers, open the same workspace from a browser or a native app, and follow a task from the first question to its deliverables.

From a question to something useful

Give Ochi a dataset and ask for a report. Follow the work as it checks the source, runs the analysis, and prepares files. Open the chart, inspect the HTML report beside the conversation, or read the PDF on your phone.

Ochi's expanded process view showing reasoning and tool calls appear in order before the report arrives

See the compact process view

The same task with the process folded into a compact status line

Built for the whole task

Capability What you can do
Models, on your terms Connect providers, select models and supported thinking levels, and retain your preferred model across new conversations. Administrators control availability, order, and defaults.
Research and execution Search the Web, read sources, run commands, work with files, and inspect an ordered record of reasoning, progress, and tool results. Configure an external search provider when needed.
Cloud execution The agent, tools, and working environment run on your server. Tasks continue after you close the app or browser; users need no local development setup or always-on personal computer.
Files and deliverables Drop files into the Web composer or paste an image. Preview images, PDFs, and HTML; generate images with supported models; explicitly publish useful output as downloadable files. Transfers default to a configurable 1 GiB per file, independently of model input limits.
Projects and scheduled tasks Keep related conversations under shared project instructions, or schedule work for later.
Memory, with a clear boundary Keep useful preferences and facts across conversations, or start a conversation with memory off. Its choice is fixed for the whole conversation; saved chats and Computer behavior stay intact.
Skills and MCP, as plugins Administrators bundle instructions and integrations into plugins. Users enable optional plugins; required defaults stay enabled. Capability discovery and execution enforce the same policy and Computer permission.
A real Linux computer Open a persistent desktop, use its browser and applications, watch the agent work, and take over manually. Ordinary computation has its own environment; shared desktop access is scheduled explicitly.
Your installation Manage providers, users, workspaces, diagnostics, application updates, and mobile download links from the administrator UI. Web, iOS, and Android support English, Simplified Chinese, and Traditional Chinese.

Web, iOS, and Android

Actual Ochi native apps: iOS conversation, Android dark-mode reading, and a full-screen PDF preview

The iOS and Android apps use React Native for the conversation, composer, Markdown, math, and native file previews. Both connect to the same backend as the Web client, with synchronized history and live run state. Computer, isolated HTML, and administration use dedicated Web surfaces where appropriate.

Watch the iOS image preview

Open an image from the conversation, then drag it down to return.

Actual iOS interaction: open a chart, then drag the full-screen preview back into the conversation

Choose a light or dark appearance, keep a draft while changing models, and move between the conversation and its output. Native clients can connect to your own HTTP or HTTPS backend. Administrators can publish an Android APK for in-app update discovery and download; installation uses Android's system installer. The iOS download entry opens a configured TestFlight or App Store link.

An inspectable tool chain

Open a process group to inspect its commands, inputs, outputs, and file delivery steps. Related calls stay grouped, with the details available a level deeper. The final answer and its deliverables remain easy to read.

Ochi's Mono theme with an expanded tool chain: source file, analysis, report generation, and three published files

Watch the tool chain unfold

Expand the process, inspect two command results, then open the HTML report.

Actual Web interaction: expand grouped tools, inspect command output, and open the delivered report

How Ochi works

Ochi keeps execution, context, memory, and resource scheduling explicit. The diagrams below describe the current implementation; the architecture document covers the contracts in detail.

A server-owned execution loop

Detailed execution loop: durable inputs, context assembly, model rounds, tool dispatch, execution evidence, and ordered public items shared by all clients

  • A conversation owns its input queue. Accepted turns are persisted and run in order. Different conversations can work concurrently.
  • The next model round receives observed results. Tool outcomes, unfinished work, and verification evidence feed task continuity. Commands have owned Jobs with real process state and logs.
  • What the model receives and what the user sees have distinct records. Canonical provider/tool history supports future requests. Ordered public items preserve text, reasoning, and tool activity; snapshots and sequenced deltas drive a shared Web/native reducer. Stopping a run keeps already-visible replies visible.

A run lives on the server, independently of its page or stream connection.

Context assembled for the task

Context assembly: stable prefix, scoped task and environment state, selective Skill and MCP details, and usage-calibrated compaction

  • Stable instructions come first. The prompt separates reusable policy and tool definitions from changing task state, environment, permissions, and relevant recall. This gives providers a reusable prefix where their caching supports it.
  • Capabilities are discovered before their details are loaded. The agent can find a Skill or MCP tool, then load selected instructions or schemas. The private control runtime supplies MCP credentials at the transport boundary.
  • Usage calibrates the context budget. Provider prompt usage calibrates the prefix already observed by the provider; newly appended content is still estimated. Compaction summarizes older evidence while preserving the canonical transcript; task constraints and outstanding work have their own state.

Useful memory, scoped to its source

Memory pipeline: accepted user sources, task-local continuity, separate durable-memory admission, bounded recall, and the fixed memory-off policy

  • Task directions stay with the task. A one-off request such as "in English" is assessed separately from a lasting language preference.
  • Automatic and agent-generated memory has an admission step. Source attribution and semantic assessment decide whether a candidate is useful beyond the current task. Records retain scope and provenance for correction and supersession.
  • Memory off closes both directions. Choose it before the first message: the conversation receives no personal recall or past-chat retrieval, and cannot become a source for future memories or learned Skills. Ordinary saved chat history remains available to its owner.

Memory off keeps saved conversations, Computer behavior, and administrator plugin policies intact. Users can view and manage their saved memories.

Independent compute. Coordinated desktop.

Computer scheduling: independent per-conversation compute, atomic FIFO admission for shared desktop and project resources, foreground waits, parked checkpoints, and owned Jobs

Ochi's actual Computer viewer connected to a Linux desktop with the example report open

The agent can request Computer access for one turn or the conversation. When a task needs you to sign in, it can pause and ask you to take control. Complete the sign-in on the desktop, hand control back, and confirm that it can continue.

Ochi requesting Computer permission, then pausing for the user to take control and sign in

  • Ordinary commands use isolated compute. Each conversation can run code without taking the shared desktop. Persistent desktop files require explicit scope; selected files can be copied between environments.
  • Conflicting shared work enters a ready FIFO queue. Desktop and project resources are claimed together. Expanding the resource set releases the old segment before waiting for the new set, avoiding partial ownership.
  • Waiting is a foreground tool call. Checkpoints report elapsed time and queue state. A parked request keeps its priority, holds no lease, and does not block ready work. Continuing starts another blocking wait; the system does not grant it in the background or replay a stale desktop action.
  • Real Jobs determine occupancy. A live desktop process retains its claims until it drains. Desktop admission provides a fresh observation before the agent chooses its next GUI action.

The computer runs in Linux containers on the server.

Get started

Requirements: Docker Engine with Compose. Docker Desktop and OrbStack can provide the engine on macOS.

cp .env.example .env

Set POSTGRES_PASSWORD and the initial administrator's password in OCHI_USERS. You can configure a model provider in .env or in the administrator UI after login.

docker compose build
docker compose up -d db server

Open localhost:8090. The default port binding is loopback-only. Provider keys stay on the server. RUNNER=demo explicitly enables a development runner; missing provider configuration does not silently select it.

For a published installation, use the matching image references from a CI build and follow the deployment guide. The runtime is PostgreSQL with pgvector, one Go service with the Web client embedded, and Docker-managed compute/desktop environments.

Explore the project

Path Responsibility
server/ Go API, agent execution, storage, and embedded production Web app
web/ React, TypeScript, and Vite Web client
mobile/ Expo/React Native clients and versioned native projects
shared/ Conversation contracts, projections, and client state machinery
workspace/ Linux tool bridge, plugin control, browser, and XFCE desktop
db/ PostgreSQL image with pgvector
docs/ Current architecture, design, development, and operations
  • Architecture — execution ownership, context, memory, plugins, and resource boundaries.
  • Design — rendering, visual language, and platform interactions.
  • Development — setup, verification, and repository conventions.
  • Deployment — configuration, persistence, and updates.
  • Releasing — iOS/Android packaging and signing.
  • AGENTS.md — entry point for coding agents.

GitHub Actions builds multi-platform images and the combined Web/server binary. An administrator explicitly requests application updates inside Ochi; a code push does not deploy an installation. The rolling edge prerelease provides an update channel without requiring a product version bump for every change.

About

Ochi is a personal agent that lives in the cloud, with its own computing environment. Start a task from the web, iOS, or Android, and let it research, work with files, run tools, and operate a computer in the cloud. No local development setup. No computer to keep running.

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Used by

Contributors

Languages