What Are the Main Features of holaOS? A Complete Guide to the Local-First Multi-Agent Workspace

holaOS is a local-first, multi-agent workspace developed by holaboss-ai that combines an Electron-based desktop UI, a TypeScript runtime, and a marketplace of HolaApps to create a fully operable workstation where any LLM agent can share persistent memory, tools, and applications.

Unlike traditional cloud-dependent AI tools, holaOS stores all context and preferences locally as plaintext files, giving developers and agents durable recall across sessions without sacrificing privacy. The repository architecture separates concerns into discrete layers, making it straightforward to extend the platform with custom skills, Model Context Protocol (MCP) servers, or third-party applications.

Local-First Architecture and Modular Design

The codebase in holaboss-ai/holaOS organizes functionality into four distinct architectural layers that together deliver the main features of holaOS.

Desktop Layer

The Desktop Layer resides in apps/desktop and provides an Electron-based client that renders the workspace UI. This layer hosts the in-workspace marketplace and manages the visual surface where agents and HolaApps operate side-by-side. According to the repository structure, this is the entry point for the user interface and marketplace functionality.

Runtime and API Layers

Beneath the desktop sits the Runtime Layer (packages/runtime-client), a pure-TypeScript execution environment responsible for running agents, executing skills, and handling MCP calls. Complementing this is the API Layer (packages/remote-api), which exposes HTTP and WebSocket endpoints for external chat-platform integrations and remote runtime connections.

Modular Package System

holaOS distributes functionality across NPM workspaces to ensure extensibility. Key packages include:

• packages/ui – Reusable React component library (including the HolaAppFrame component required for rendering apps)
• packages/app-builder-sdk – SDK for creating custom HolaApps
• packages/editor – In-workspace editing capabilities

All layers persist state in plain files under .holaOS, ensuring complete transparency and editability of agent memory and configuration.

Universal Agent Support and Persistent Memory

Two foundational features of holaOS eliminate the fragmentation typically found in AI toolchains: universal agent compatibility and shared durable memory.

Run Any Agent in One Workspace

As documented in lines 47-51 of the README.md, holaOS allows you to run any agent—including Claude Code, Codex, the built-in holaOS agent, or any other LLM—within a single workspace without reinstalling tools. All agents share the same memory, tools, and HolaApps, creating a unified operational environment rather than isolated chat sessions.

One Shared, Durable Memory

Lines 55-62 of the README.md describe holaOS's shared memory system. Context, preferences, and project history are stored locally as plaintext files, giving agents persistent recall across sessions and across different agents. This means switching from Claude to GPT-5.6 does not reset your project context; the new agent immediately inherits the previous state from the .holaOS memory store.

Flexible Model Selection and HolaApps Marketplace

holaOS decouples the frontend experience from backend model providers while introducing a new category of interactive applications.

Models-Your-Way

Lines 67-74 of the README.md detail the Models-your-way feature. The platform includes built-in frontier models—Kimi K3, GLM 5.2, GPT 5.6, Claude Opus 5, and Fable 5—available out-of-the-box. Simultaneously, you can bring your own OpenAI or Anthropic API keys to connect any compatible endpoint, ensuring you are never locked into a single provider.

HolaApps: Apps and Agent Side by Side

The HolaApps marketplace (lines 75-83) allows installation of interactive applications—such as Notion, browsers, or custom UIs—that appear side-by-side with the agent. Unlike traditional chat plugins, HolaApps are real UI surfaces that can be driven programmatically by the agent or manipulated manually by the user. The HolaAppFrame component in packages/ui renders these surfaces within the desktop environment.

Extensibility Through Skills and MCP

holaOS functions as a workstation rather than a chatbot through its robust integration framework.

Skills, Integrations, and OAuth

Lines 88-94 of the README.md describe one-click OAuth connections to over 50 services including Gmail, Notion, Slack, GitHub, and Linear. Skills are reusable workflow packages that agents can invoke to perform complex multi-step operations across these services without manual API configuration.

Model Context Protocol (MCP) Support

The platform implements the Model Context Protocol (MCP), allowing developers to plug in custom tooling servers. The docs/plugin-sdk.md file specifies how to create these extensions, enabling agents to consume new capabilities through a standardized interface.

Full Workstation Automation

The final pillar transforms holaOS from a chat interface into a complete operational environment.

Lines 99-106 of the README.md list the workstation automation capabilities:

• Agent-operable browser – A real browser window that agents can control programmatically
• Media generation – Built-in image, video, and audio generation tools
• Native export – Direct generation of .xlsx, .pptx, and .docx files
• Chat-channel reachability – Integration with Slack, Telegram, WeChat, and other messaging platforms
• Scheduled and triggered tasks – Automated execution based on time or event triggers

Developer Implementation Guide

Developers interact with holaOS features through the TypeScript packages. Below are runnable examples from the repository demonstrating core operations.

To launch a skill from the runtime client:

import { runSkill } from '@holaOS/runtime-client';

await runSkill('web-researcher', { query: 'latest AI trends 2024' });

To register a custom MCP server at runtime:

import { registerMCP } from '@holaOS/remote-api';

await registerMCP('my-custom-search', {
  endpoint: 'http://localhost:8000/mcp',
  auth: { apiKey: 'REPLACE_WITH_KEY' },
});

To render a HolaApp inside the desktop UI:

import { HolaAppFrame } from '@/components/ui/HolaAppFrame';

export default function MyApp() {
  return <HolaAppFrame src="https://app.notable.ai" title="Notable" />;
}

These examples assume the packages have been built using npm run desktop:prepare-runtime and the desktop dev server is running (npm run desktop:dev).

Summary

• holaboss-ai/holaOS is a local-first, multi-agent workspace combining a desktop UI, TypeScript runtime, and HolaApps marketplace.
• Universal agent support allows swapping between Claude Code, Codex, GPT-5.6, and other LLMs without losing context, as documented in README.md lines 47-51.
• Shared durable memory persists context in plaintext files under .holaOS, enabling cross-agent recall (lines 55-62).
• Flexible model configuration supports built-in frontier models and custom API endpoints (lines 67-74).
• HolaApps provide real UI surfaces that operate side-by-side with agents, distinct from traditional chat plugins (lines 75-83).
• Skills and MCP offer one-click OAuth to 50+ services and standardized custom tooling via the Model Context Protocol (lines 88-94).
• Workstation automation includes agent-controlled browsers, media generation, native file export, and chat-channel integrations (lines 99-106).

Frequently Asked Questions

What makes holaOS "local-first"?

holaOS stores all agent memory, context, and preferences as plaintext files under .holaOS rather than in cloud databases. This design ensures that your data remains on your machine, providing transparency, editability, and privacy while still allowing agents to maintain persistent recall across sessions.

How does holaOS handle different AI models?

According to lines 67-74 of the README.md, holaOS provides built-in frontier models including Kimi K3, GLM 5.2, GPT 5.6, Claude Opus 5, and Fable 5. Additionally, the Models-your-way feature allows you to input your own OpenAI or Anthropic API keys to connect any compatible endpoint, preventing vendor lock-in.

What are HolaApps and how do they differ from chat plugins?

HolaApps are interactive UI surfaces described in lines 75-83 of the README.md that render side-by-side with the agent workspace. Unlike traditional chat plugins that only return text or structured data, HolaApps are real applications (such as browsers or Notion) that can be controlled programmatically by the agent or used manually by the human operator.

How can developers extend holaOS functionality?

Developers can extend the platform through three primary mechanisms: creating Skills (reusable workflow packages for 50+ integrations), registering MCP servers (custom tooling servers via the Model Context Protocol as specified in docs/plugin-sdk.md), or building custom HolaApps using the packages/app-builder-sdk.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}