Introduction
"Apps and agents, side by side. Built for how work actually happens."
This is the 173rd article in the "One Open Source Project a Day" series. Today's project is holaOS.
Here is what using AI for real work typically looks like: you write something in Notion, switch to a Claude window, copy-paste the content, explain the context, wait for the output, then copy it back. Every switch is a context loss — you constantly have to re-narrate what you just did.
holaOS sets out to fix that root problem: agents and applications should coexist in the same workspace, not in two isolated worlds.
In holaOS, Notion, a browser, or a custom app opens as an interactive live surface alongside the agent. What you do in that interface, the agent senses automatically — you never stop to explain "what I just did."
11.1k Stars, Modified Apache 2.0, built by the holaboss team.
What You Will Learn
- The HolaApps concept: applications as bidirectional context providers for agents
- The design of the local file-based shared memory system
- How three agents (Claude Code, Codex, built-in holaOS agent) share the same tools and memory
- How IM integration (Slack, Feishu, DingTalk, WeChat) supplies real conversation context to agents
- The HolaHub community recipe platform mechanism
- Enterprise features: SSO, audit logs, private cloud deployment
Prerequisites
- Familiarity with AI agents and tool use basics
- Understanding of what MCP (Model Context Protocol) is
- Optional: basic familiarity with Electron desktop applications
Project Background
What It Is
holaOS is an agent-native workspace, built around one core proposition: applications and agents run side by side in the same interface, sharing memory, tools, and integrations.
It is not an AI chat tool and not an application launcher — it is a redesign of how knowledge work happens:
- Agents can read the actual state of the applications you are using
- Your actions inside an application automatically become agent context
- Multiple agents (Claude Code, Codex, holaOS built-in) share a single toolset and memory with no per-agent reconfiguration
The official design philosophy:
"Composable parts that fit your workflow rather than forcing you to adapt to ours. Everything runs locally by default."
Author / Team
- Team: holaboss AI (holaboss-ai)
- Website: holaboss.ai
- Product stack: holaboss has three products — holaOS (open-source agent desktop), holaProxy (cross-model API gateway), and Neo Lab (internal research lab)
- License: Modified Apache 2.0 (with additional commercial distribution and branding terms)
Project Stats
- ⭐ GitHub Stars: 11,100+
- 🍴 Forks: 720
- 📄 License: Modified Apache 2.0
- 💻 Primary Language: TypeScript (Electron desktop app)
- 🌐 Website: holaboss.ai
- 📦 Platforms: macOS (Apple Silicon / Intel), Windows, Linux
Core Features
What Problem It Solves
holaOS is organized around three core layers:
┌──────────────────────────────────────────────────────────┐
│ holaOS Workspace (local Electron desktop) │
│ │
│ ┌────────────────┐ ┌────────────────────────────┐ │
│ │ HolaApps │ │ Agent (any, or multiple) │ │
│ │ Notion │◄──►│ Claude Code │ │
│ │ Browser │ │ Codex │ │
│ │ Custom URLs │ │ holaOS built-in agent │ │
│ └────────────────┘ └────────────────────────────┘ │
│ ▼ ▼ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Shared Memory (local files, cross-session, │ │
│ │ cross-agent) │ │
│ └────────────────────────────────────────────────────┘ │
│ ▼ ▼ │
│ ┌────────────────┐ ┌────────────────────────────┐ │
│ │ 50+ integrations│ │ MCP servers │ │
│ │ Gmail / Notion │ │ one-click community MCP │ │
│ │ Slack / GitHub │ └────────────────────────────┘ │
│ └────────────────┘ │
└──────────────────────────────────────────────────────────┘
Usage Scenarios
-
Software development workspace
- Claude Code and Codex run in parallel, sharing the same codebase context. GitHub integration provides live PR status; a browser agent can test API endpoints directly.
-
Content creation workflow
- Notion opens as a HolaApp; the agent alongside generates supplementary material based on the Notion page, outputting real
.docxand.pptxfiles.
- Notion opens as a HolaApp; the agent alongside generates supplementary material based on the Notion page, outputting real
-
Team IM context access
- The agent reads real Slack threads or Feishu group chats directly instead of having the user manually summarize them. Ideal for "organize the weekly meeting notes" or "generate a task list from the decisions in the group chat."
-
Enterprise automation pipelines
- Scheduled or trigger-based tasks: generate a daily project progress digest, monitor specific metrics, automatically file reports.
-
Local privacy work
- All files, memory, embeddings, and session history live on local disk — nothing passes through any server. Suitable for sensitive documents.
Quick Start
# One-line install and launch
curl -fsSL https://raw.githubusercontent.com/holaboss-ai/holaOS/refs/heads/main/scripts/install.sh | bash -s -- --launch
Local development:
git clone https://github.com/holaboss-ai/holaOS.git
cd holaOS
bun install
# Install desktop dependencies
npm run desktop:install
# Prepare local runtime
npm run desktop:prepare-runtime:local
# Development mode
npm run desktop:dev
Core Features
1. HolaApps: applications as live surfaces
This is holaOS's central concept. In traditional AI tools, applications and agents are separate — what you did in Notion must be manually explained to the agent.
HolaApps turns applications into real-time context providers for the agent:
Traditional approach:
Write in Notion → copy-paste → switch to AI window
→ explain context → wait for output → copy back
holaOS approach:
Act in the HolaApp (Notion) → agent auto-senses change
→ directly generates / modifies
↑ The work happens in the app, the agent is alongside,
shared context, no switching, no re-explaining
Any URL can become a HolaApp: pair it with an MCP server, point it at any web application, and it runs inside the workspace.
2. Shared memory system
Memory is infrastructure in holaOS, not a bolt-on feature:
- Storage format: plain files on local disk (not a black-box database)
- Cross-session: close and reopen — memory is fully intact
- Cross-agent: project context Claude Code accumulated is accessible to Codex
- Structured + vector-embedded: supports accurate retrieval
- Fully transparent: open, edit, or delete the files directly
"A folder you can read, not a black box."
This design decision means memory is the user's asset, not the application's lock-in.
3. Multi-agent collaboration
Three agents coexist in the same workspace, sharing the same environment:
| Agent | Character |
|---|---|
| holaOS built-in | General tasks, deep workspace integration |
| Claude Code | Complex coding tasks, official Anthropic CLI |
| Codex | OpenAI code generation, supports BYOK |
Switching agents requires no reconfiguration — same integrations, same memory, same skills, different agent executing.
4. IM context reading
Supported platforms: Slack, Feishu, DingTalk, WeChat.
Agents can read your IM channels and group chats directly, using real conversations as context instead of user-written summaries. Each tool connection is authorized separately, with explicit scope.
5. Skills, integrations, and MCP
- 50+ OAuth integrations: Gmail, Notion, Slack, GitHub, Linear, and more — one-click connect, all agents inherit automatically with no per-agent reconfiguration
- MCP servers: plug in any MCP server in one click to extend the agent toolset
- Skills: package a workflow once; any agent can invoke it on demand
- Combos: bundle skills + integrations into a single installable unit — one-click to replicate an entire workflow
6. Document and media generation
Agent output is not just text:
- Real files:
.xlsx,.pptx,.docx - Image, video, and audio generation (built into all agents)
- Ideal for "generate a progress deck for this week" or "create a product poster"
7. Browser control
Agents can operate signed-in browsers to complete web tasks requiring authentication. All actions happen under user control — not unsupervised automation.
8. Enterprise features
| Feature | Description |
|---|---|
| SSO | Role-based permissions, granular to agent / skill / app level |
| Audit logs | Complete record of every action |
| Internal system connections | Without external network exposure |
| Private cloud / on-prem | Full self-hosting options |
Deep Dive
Local-First Privacy Architecture
holaOS's privacy guarantee is an architectural decision, not a policy promise:
Local disk (always here):
├── workspace files/ ← Working files
├── memory/ ← Agent memory (plain files, directly readable)
├── embeddings/ ← Vector index
└── session_history/ ← Session records
External network (only with your explicit authorization):
├── Model API calls (your API keys, your billing)
├── Integration OAuth (Gmail, GitHub, etc., authorized per-service)
└── MCP servers (each connection individually authorized)
"It isn't a policy we promise; it's a place your data never goes."
Technical Architecture: Electron Monorepo
holaOS/
apps/
desktop/ ← Electron main application
web/ ← Web interface layer
packages/ ← Shared packages
runtime/ ← Runtime environment
shared/ ← Cross-package shared logic
docs/ ← Documentation
scripts/ ← Build / install scripts
Build tooling: Bun + Turborepo
Node version: pinned in .nvmrc (nvm recommended)
HolaHub: Recipe Sharing Platform
HolaHub is the community recipe platform built into the workspace. A recipe contains:
Recipe = model selection + prompt + skill set + MCP servers + integrations
Publish a recipe; others install it in one click and get an identically configured agent — not just a shared prompt, but a shared entire workflow.
HolaHub publications also expose the "process": the session behind a skill, the prompt behind an image or video. This transforms sharing from "showing results" into "transparent process."
Positioning vs. Other Agent Tools
| Tool | Positioning | Key difference |
|---|---|---|
| Claude.ai / ChatGPT | AI chat interface | Apps and AI are separate |
| Cursor / Claude Code | Code-specialized agent | Single domain, no general workspace |
| n8n / Make | Automation platform | Workflow-focused, not real-time collaboration |
| holaOS | Agent-native workspace | Apps + agents share screen, share memory |
holaOS's differentiator is the "side by side" — not "you check results after the agent finishes," but "the agent senses and assists in real time while you work."
Memory as Infrastructure, Not Feature
Most agent tools treat memory as an add-on — a way to remember your name or a few preferences. holaOS treats it as foundational infrastructure.
The difference shows up in three ways:
- Cross-agent: memory is shared across all agents in the workspace, so switching from Claude Code to Codex doesn't lose project context
- Cross-session: memory persists permanently, not just within a conversation
- User-controlled: since memory is plain files, the user can read, edit, export, or delete any part of it at any time
This last point — plain files — is harder to build than a proprietary database. It's also what makes the privacy guarantee credible: "a folder you can read" is verifiable; "we don't store your data" is not.
Project Links & Resources
Official Resources
- 🌟 GitHub: https://github.com/holaboss-ai/holaOS
- 🌐 Website: holaboss.ai
- 📦 Install:
curl -fsSL https://raw.githubusercontent.com/holaboss-ai/holaOS/refs/heads/main/scripts/install.sh | bash -s -- --launch
Related Projects
- Claude Code — one of the agents holaOS integrates deeply
- Model Context Protocol — the protocol behind holaOS's MCP support
- Electron — the runtime for holaOS's desktop application
Summary
Key Takeaways
- HolaApps is the core innovation: apps as live, bidirectional context providers for agents — eliminating the cost of switching and re-explaining
- Memory is infrastructure: local files, cross-session, cross-agent, fully visible and user-controlled — not a black box
- Multi-agent without lock-in: Claude Code, Codex, and the holaOS built-in agent share the same environment; switch based on the task at hand
- IM context is where decisions actually live: reading real Slack or Feishu threads is far more accurate than user-written summaries
- Local-first is an architectural guarantee: data not leaving the device is a physical property, not a compliance statement
Who This Is For
- Developers and knowledge workers who need AI deeply integrated into daily workflows: not just "chatting," but genuine integration with working applications
- Chinese teams using Feishu or DingTalk: native support — agents can directly access company IM context
- Privacy-sensitive enterprise users: local-first architecture + SSO + audit logs + private cloud deployment
- Teams that want to share and reuse workflows: HolaHub recipe platform makes successful workflows one-click deployable across the team
One-Line Verdict
holaOS asks a question worth asking: if AI and applications genuinely worked side by side, what would that feel like?
Check out PrimeSkills — a curated marketplace of AI agents and skills that have been validated in real-world, enterprise-grade workflows. No fluff, just what actually works.
Find more useful knowledge and interesting products on my Homepage
Top comments (0)