Most AI assistants wait for you to open a chat window.
RedPlanetHQ/core is built around a different idea: a personal AI operating system that is always watching, always connected, and able to act across the tools you already use.
CORE is open source and self-hostable. It combines persistent memory, tasks, app connectors, reusable skills, a gateway for coding and browser work, multiple interfaces, and human approval gates. The README describes it as “Your Personal AI OS”: not a chatbot you open, but an AI that notices work, gathers context, drafts plans, asks for approval where needed, and runs through the right execution surface.
That makes CORE worth studying because it sits at the intersection of three trends:
- AI agents moving from chat into background workflows
- personal memory graphs becoming the context layer for repeated work
- self-hosted automation becoming important for privacy and control
The result is ambitious: an always-on AI layer for your email, GitHub, Linear, Slack, calendar, terminal, browser, coding agents, and personal routines.
What CORE Is
CORE is an open-source personal AI operating system from RedPlanetHQ.
The basic promise is not “another chat assistant.” It is a persistent AI layer that sits across your tools, watches activity, remembers context, and can act when the right trigger appears.
The system includes:
- Memory: a temporal knowledge graph across tools and conversations.
- Tasks: one-shot or recurring work units with plans, state, and task-scoped chat.
- Connectors: more than 50 app integrations through one MCP endpoint.
- Skills: reusable instructions that fire automatically based on context.
- Gateway: execution for Claude Code, Codex, browser agents, and terminal commands.
- Interfaces: voice, scratchpad, messaging, and chat.
- Self-hosting: local Docker or server deployment so data can stay in your infrastructure.
That is why the phrase “personal AI OS” is useful. CORE is trying to be the coordination layer around your work, not just a place to type prompts.
Why Always-On Matters
Most AI tools are pull-based. You ask; they answer.
CORE is designed to be event-driven. A GitHub issue gets assigned. A Sentry alert fires. An email arrives. A meeting ends. A scratchpad task appears. CORE can notice the event, pull related memory and connected context, draft a plan, and either act or ask for approval.
That changes the shape of automation.
Instead of needing to remember every follow-up, the system can monitor the edges of your workflow. Instead of starting every agent session from scratch, the system can bring prior decisions and preferences into the next task.
The upside is obvious: less context reconstruction, fewer missed follow-ups, and more background execution.
The risk is also obvious: an always-on assistant must be governed carefully.
Four Interfaces, One Memory
CORE exposes multiple surfaces:
- Voice: speak a task without opening a dashboard.
- Scratchpad: write checklist items in a daily page and let CORE pick them up.
- Messaging: send tasks from WhatsApp, Slack, or Telegram.
- Chat: use a normal assistant interface when you want discussion first.
The interesting design decision is that these surfaces share the same memory and context. A task sent from a phone can still use project context from GitHub, Slack, prior coding sessions, and stored preferences.
That is the difference between “many chatbots” and “one assistant with many doors.”
Memory as a Temporal Knowledge Graph
The memory layer is the most important part of CORE.
The README describes memory as a temporal knowledge graph containing preferences, decisions, goals, directives, conversations, and context from connected tools. That matters because real work depends on time.
A useful assistant needs to know:
- what decision was made last week
- which project convention overrides the default
- which GitHub issue relates to a Slack thread
- which person prefers which kind of update
- which recurring task should run every morning
- which old instruction has been superseded
That is not simple retrieval. It is temporal context management.
CORE’s LoCoMo benchmark claim is also relevant here. The project reports 88.24% average accuracy across single-hop, multi-hop, open-domain, and temporal reasoning. Benchmarks are not the whole story, but the focus on temporal reasoning fits the product direction.
Connectors and MCP
CORE’s connector layer is built around a broad toolkit: GitHub, Linear, Jira, Slack, Gmail, Calendar, Sentry, Notion, Todoist, and many more.
The README describes 50+ apps through one MCP endpoint and 1000+ actions in the toolkit docs. That positioning is important. If an assistant only has memory but cannot act, it becomes a smarter notebook. If it can act but has no memory, it becomes a brittle automation script.
The useful combination is memory plus action:
- read the issue
- pull related Slack context
- inspect prior incidents
- draft a plan
- open a coding session
- post a status update
- ask before merging or sending anything sensitive
That is the agent workflow most teams actually want.
The Gateway: Coding, Browser, and Terminal Work
CORE can delegate execution through a gateway. The gateway can run Claude Code, Codex, browser agents, and terminal commands on your machine, in Docker, or in a hosted environment such as Railway.
This matters because background AI work often needs a real execution surface.
For example, “fix this issue” is not just a language task. The agent may need to read the repo, create a branch, run tests, inspect logs, open a PR, and summarize what changed. CORE’s gateway gives the personal OS a way to launch that work while keeping the task, memory, and approval state connected.
That is where the OS metaphor becomes practical. The assistant is not only a planner. It can coordinate execution.
Human-in-the-Loop by Default
The most important design choice is control.
CORE lets the user decide where it can act autonomously and where it must wait. You can let it investigate alerts automatically but require approval before merging. You can require plan approval before a coding session starts. You can require confirmation before an email is sent.
That matters because personal AI operating systems will fail if they ignore trust boundaries.
An assistant that can read everything and act everywhere must have visible controls:
- per-task autonomy settings
- per-app permissions
- approval gates
- audit trails
- self-hosting options
- encryption and data-isolation guarantees
CORE’s README leans into that model: open source, self-hostable, human-in-loop by default, and data that stays in your infrastructure.
Practical Setup Shape
The quickstart is simple for a project of this size:
npm install -g @redplanethq/corebrain
corebrain setup
The setup wizard asks for an install directory, AI provider, API key, and chat model. It generates secrets, starts the stack, and opens a local dashboard at http://localhost:3033.
The requirements are not trivial: Docker, Docker Compose, and a reasonable machine or server. The README lists Docker 20.10+, Docker Compose 2.20+, 4 vCPU, and 8GB RAM.
That is the right expectation. A personal AI OS with memory, connectors, gateway execution, and app surfaces is infrastructure, not a single npm script.
Where CORE Fits
CORE is most relevant if you want a personal or team AI layer that can:
- watch your tools for tasks and incidents
- remember prior decisions and preferences
- turn notes into work items
- run coding sessions through Codex or Claude Code
- drive browser and terminal workflows
- post updates to Slack or messaging apps
- keep a recurring daily operating rhythm
- self-host sensitive context
It is less relevant if all you need is occasional chat or a lightweight prompt helper.
The value of CORE appears when work is repeated, distributed across apps, and dependent on context.
My Take
CORE is ambitious in the right way.
The next generation of personal AI tools will not be only a better chat box. They will need memory, triggers, connectors, permissions, task state, and execution environments. They will need to meet users where work actually happens: phone, chat, voice, browser, terminal, GitHub, Slack, email, and calendar.
CORE puts those pieces into one open-source system.
The hard parts will be trust, reliability, setup complexity, connector maintenance, and deciding which actions should be autonomous. But those are exactly the right hard problems to work on.
For builders interested in self-hosted AI agents, persistent AI memory, MCP-based automation, or personal operating systems around Codex and Claude Code, RedPlanetHQ/core is worth a serious look.
