holaOS: Open-Source Agentic Workspace for Teams

holaOS: An Open Agent Computer for Any Digital Work

holaOS reimagines the computer as a shared, collaborative environment where humans and AI agents operate side by side. It surfaces a single, coherent workspace—the same browser, the same files, and the same apps—so work persists, memory stays durable, and goals remain aligned across time. Agents live inside this environment, continuously learning to work better with you, while remaining fully inspectable and controllable. Through roles and templates, you shape how these agents operate, ensuring consistent, repeatable methods of getting things done.

Animated glimpse of the holaOS experience

Quick Start
What you need
One-Line Install
Documentation
Manual Install
One-Line Agent Setup
Contributing
OSS Release Notes

A Glimpse of holaOS in Action

holaOS is an open agent computer designed for any digital task. The core idea is to collapse the friction between disparate tools and contexts by providing a unified, persistent environment. You log in, pick a workspace, and the system brings forward your browser sessions, files, and apps with memory and intent. Agents—software companions you can shape with roles and templates—operate within this shared space, taking on routine tasks, automating repetitive steps, and offering proactive suggestions. By keeping memory, execution, and goals in a single place, holaOS preserves continuity across sessions so work doesn’t reset or lose state.

In the desktop workspace, you can see a holistic environment where code editors, documentation, chat, and file explorers coexist within the same shell. When an agent completes a task, its output—notes, artifacts, or code—stays attached to the workspace, ready to be resumed later. This continuity is not just a convenience; it’s a design principle that reduces cognitive overhead and accelerates long-horizon projects.

What makes holaOS special is the convergence of multiple design ideas:

Shared environment: Humans and agents share the same browser, files, and apps, which reduces context-switch costs.
Coherent state: Memory, execution, and goals stay aligned across time, so progress compounds rather than resets.
Inspectable intelligence: Agents are designed to be observable and auditable, enabling trust and safety in complex workflows.
Role-based customization: Templates and roles let you tailor agent behavior for consistent, repeatable outcomes.

Quick Start

One-Line Install

For a fresh machine bootstrap on macOS, Linux, or WSL, use the repository installer. The simplest path to a usable local desktop is:

curl -fsSL https://raw.githubusercontent.com/holaboss-ai/holaOS/main/scripts/install.sh | bash -s -- --launch

This single command fetches the installer, validates prerequisites, and spins up the desktop environment with a local runtime. It’s designed to get you from zero to a functioning holaOS desktop quickly, while still allowing you to intervene at each step if you want finer control.

If you prefer to inspect or customize the setup, you can follow the manual path outlined in the documentation. The one-line installer prioritizes speed and a smooth developer story, but manual steps are available when you want to understand or tune every detail.

Star the Repository

Stars help holaOS reach more developers and grow the community. If you find the project compelling, consider tipping the project’s momentum with a GitHub star. Your star is a signal that others can leverage to discover this effort and join the conversation.

Inspiration and outreach are also visible in the community visuals:

Animated preview: A quick, engaging glimpse into how holaOS looks and feels as it evolves.
The star button is a reminder that open source thrives on collaboration, feedback, and shared curiosity.

What You Need

Before you install, ensure you have a few prerequisites in place so the One-Line Install can run smoothly:

A supported operating system: macOS is fully supported; Windows and Linux are in progress, with Electron as the desktop environment.
Node.js version: 24.14.1 (the runtime and tooling are aligned to this version).
An execution environment for Electron: The desktop app is Electron-based, leveraging TypeScript runtime for robust development and maintenance.
An MIT-licensed codebase with CI pipelines in place to validate changes as you contribute.

In addition, having a basic familiarity with shell commands, Git, and a package manager will help you get productive quickly.

A Glimpse of holaOS Desktop

Below is a representative screenshot of the holaOS desktop workspace, illustrating how apps, documents, and tools can sit side by side in a single coherent surface. The image captures the sense of a shared, persistent workspace where memory of prior steps remains available and accessible as you work.

holaOS desktop workspace screenshot

Documentation

All deeper technical and product documentation lives at holaos.ai/docs. The documentation is organized to provide a fast path to a working local desktop, followed by the underlying concepts that give holaOS its distinctive behavior.

Key sections:

Overview: The merged entry page for the environment-engineering thesis and system model.
Quick Start: The fastest path to a working local desktop environment.
Workspaces: How workspaces are created, switched, managed, and represented on disk.
Environment Engineering: The core rationale behind holaOS and why the environment defines the system.
Concepts: Core system vocabulary for workspaces, runtime, memory, and outputs.
Workspace Model: The workspace contract, authored surfaces, and runtime-owned state.
Memory and Continuity: Durable memory, continuity artifacts, and long-horizon resume behavior.
Agent Harness: The stable harness boundary inside the runtime and how executors fit into it.
Independent Deploy: Running the portable runtime without the desktop app.
Build on holaOS: The code-true developer map for desktop, runtime, apps, templates, and validation paths.
Start Developing: The local developer path for desktop and runtime validation.
Runtime APIs: The runtime operational surface for workspaces, runs, streaming, and app lifecycle.
Build Your First App: Building workspace apps on top of holaOS.
Reference: Environment variables and supporting reference material.

Manual Install

Manual Install is the path you take when you want to inspect or control each setup step in detail. If you’re exploring or teaching, this approach can be valuable because it makes each prerequisite explicit and observable.

Checklist before manual steps:

Verify git, Node, and npm versions on your machine.
Prepare your environment for cloning and building the repository.
Ensure you understand the flow from local development to runtime packaging.

One-Line Agent Setup

If you’re using Codex, Claude Code, Cursor, Windsurf, or another coding agent, you can hand your agent setup instructions in a compact form. The one-sentence instruction sets the stage for a smooth onboarding for the agent, guiding it through the install, clone, and initial setup procedures.

A typical agent handoff includes:

Cloning or updating the holaOS repository into your home directory (for example, ~/holaboss-ai).
Running desktop:install to fetch desktop dependencies.
Creating a local environment file from desktop/.env.example, and tailoring values as needed.
Running desktop:prepare-runtime:local to assemble a local runtime bundle.
Running desktop:typecheck to validate type correctness before launch.
Running desktop:dev to start the app in development mode, if you requested --launch.

If Electron cannot open, pause at the checkpoint, verify prerequisites, and decide on the next manual step. The idea is to keep the bootstrap flow self-contained while storing the more detailed bootstrap steps in a repo-local runbook (INSTALL.md) for deeper inspection.

Concrete steps (summary): 1) Install the desktop dependencies: npm run desktop:install 2) Create your local environment file: cp desktop/.env.example desktop/.env 3) Prepare the local runtime bundle: npm run desktop:prepare-runtime:local 4) Quick validation pass before launching Electron: npm run desktop:typecheck 5) Start the desktop app in development mode: npm run desktop:dev

The predev hook is designed to validate the environment, rebuild native modules, and ensure a staged runtime bundle exists. If you want to stage the runtime before opening the desktop app, you have two common paths:

Build from local runtime: npm run desktop:prepare-runtime:local
Fetch the latest published runtime: npm run desktop:prepare-runtime

Use the local path when you are actively changing runtime code, and the published bundle when you want to verify the desktop against a known release artifact.

Contributing

Open source thrives on collaborative effort. If you want to contribute, begin with Start Developing to get the local desktop and runtime loop working, then consult Contributing for validation, commit, and review expectations. The process is designed to be approachable for newcomers while robust enough for experienced contributors who want to shape the project’s direction.

OSS Release Notes

License: MIT. See LICENSE.
Security issues: report privately to [email protected]. See SECURITY.md.

Community and Growth

HolaOS invites developers to engage, experiment, and share feedback. The project’s ongoing evolution benefits from a vibrant community where ideas are tested and refined in a transparent, collaborative fashion. The repository’s CI pipeline ensures that changes are continuously validated, helping maintain a stable, trustworthy development experience for everyone.

Images and visuals play a key role in communicating the user experience and the community’s vitality. The banner at the top signals the project’s mission, while the desktop workspace image gives a tangible sense of the holistic environment holaOS offers. The animated “star the repo” graphic serves as a friendly nudge toward community participation and open-source collaboration.

Accessibility and cross-platform goals

holaOS emphasizes accessibility and broad platform coverage. While macOS is fully supported today, Windows and Linux are in progress. The Electron-based desktop environment ensures a familiar, responsive interface across platforms as work continues. The underlying runtime is designed to be platform-agnostic, with a focus on consistent semantics for workspaces, memory, and agent behavior.

Key architectural notes

Shared environment: Humans and agents operate within the same workspace, with shared access to memory, files, and browser state.
Continuity: Durable memory and long-horizon resume capability ensure that progress persists across sessions and interruptions.
Agent harness: A stable boundary within the runtime aligns executors and orchestrates their interaction with the workspace.
Workspace model: Workspaces provide an authored surface and runtime-owned state, enabling durable, portable configurations.
Environment engineering: The architecture emphasizes how the environment itself defines and constrains the system, not just the tools in isolation.

What you can do with holaOS

Build and run workspace apps that sit on top of holaOS, leveraging the shared memory and runtime services.
Prototyping and testing with continuous change, while maintaining a stable external interface.
Create templates and roles for agents so that their behavior remains consistent and predictable across tasks.
Explore long-term projects with persistence, so you can pick up where you left off with the same context and artifacts.

Practical tips for new users

Start small: Create a simple workspace and an agent to automate a repetitive task, such as organizing receipts or collecting notes from multiple sources.
Leverage memory: Use continuity features to keep track of goals and outputs across sessions, rather than recreating workflow states.
Inspect and customize: Use the inspector and runtime APIs to understand how agents operate and to tailor their behavior to your needs.
Share and collaborate: Invite teammates into your holaOS environment so you can collaborate with the same set of tools and memory space.

A Short Roadmap for Enthusiasts

Improve cross-platform support: Continue working toward full Windows and Linux support, while keeping the macOS experience polished.
Expand agent libraries: Add templates and roles to enable more sophisticated workflows with fewer configuration steps.
Strengthen security and governance: Enhance auditing, traceability, and control surfaces to maintain trust in AI-assisted workflows.
Broaden integration points: Connect holaOS with popular developer tools and cloud services to widen the spectrum of tasks you can accomplish within the unified environment.

Conclusion

holaOS offers a bold rethinking of the computer as a shared, persistent, and inspectable space where humans and AI agents collaborate in real time. By unifying memory, execution, and goals in a single environment, holaOS reduces context-switching, preserves work state across sessions, and empowers users to shape agent behavior through roles and templates. The One-Line Install provides a quick path to a working desktop, while Manual Install and One-Line Agent Setup give power users the ability to inspect and customize every step of the bootstrap. The project’s open nature invites developers to contribute, build, and extend the system to fit a growing variety of digital work.

Images

Banner/logo: Holaboss logo
Desktop workspace: holaOS desktop workspace screenshot
Community animation: Star the repo animation

If holaOS resonates with your approach to building and collaborating with AI agents, consider joining the community, exploring the docs, and trying the Quick Start. The open design aims to invite experimentation, learning, and shared progress. Your participation—whether through usage, feedback, or code—helps shape a future where software development, problem solving, and creative work happen more smoothly, transparently, and effectively in a single, coherent environment.