openloomi-feature-guide

> **Note:** If OpenLoomi readiness is unknown, use `openloomi-setup` first. If OpenLoomi Desktop is not installed, follow [Getting Started](https://openloomi.ai/docs/getting-started).

# OpenLoomi Product Features

Use this skill when users ask about openloomi features, usage, or capabilities. Provide accurate and easy-to-understand feature introductions and operation guides. The terms used here (Loop, Signal, Decision, Card, ActionKind, Attention Agent, Connector, Memory, Audit Log, Plugin, Agent Runtime, Composio, etc.) are defined in the **Glossary** below — read it first if a user asks anything conceptual.

---

## What is OpenLoomi

OpenLoomi is an **open-source AI coworker, driven by an attention agent**. It connects your authorized work tools and screen content, builds a **holistic context** of your people, projects, and decisions, and tells you what happened, why it matters, what to do next — and surfaces daily summaries — saving your attention for what matters.

Use it standalone, or plug any Agent framework into the same resident desktop: **Claude Code, Codex, OpenCode, Hermes, and OpenClaw** all work. The desktop attention agent (a small fox named **Loomi**) lives on top of your screen and surfaces the day's decisions as gentle bubbles you can approve in one tap.

---

## Glossary

OpenLoomi is best read as a single **chain from input to action**, not as one big chat window. Connectors bring events in, Memory holds context, Loop decides what matters and turns each signal into a Decision card, the Attention Agent (Loomi) shows the card on your desktop, you tap Approve, and an Action Runner executes through a Connector — then the outcome is written back to Memory and recorded in the Audit Log.

This page exists to make that chain legible. It first walks the chain end-to-end, then defines every concept you're likely to meet in other pages, and finishes with a short table of distinctions that get confused in practice. Every cross-reference links to an existing page; nothing here duplicates their full setup or configuration.

### How the concepts fit together

OpenLoomi is one pipeline. The same pieces appear on every page, just framed differently.

Two parallel input paths feed the same context layer. The main one is real-time and runs through Loop; the side one is screen-based and lands in Memory without going through Signals.

![OpenLoomi concept map — Inputs (Connectors and Screen Capture) feed Signals into the Judgement & Store pillar (Loop and Memory), which produces Decisions; the Surface & Action pillar renders Cards in the Attention Agent, waits for user Approve, and runs Actions through Connectors; everything writes back to Memory and the Audit Log.](https://openloomi.ai/img/openloomi/glossary/concepts.svg)

A short reading guide for the figure:

- **Connectors** are the real-time input path: they pull raw events from external platforms and turn them into **Signals**, which **Loop** polls on its tick. Everything that becomes a Decision card comes in this way.
- **Screen Capture** (macOS only) is the side input path: pressing the global capture shortcut summarises the frontmost window and the result is stored directly as a **Memory** record. Screen memories show up alongside messages, summaries, and insights inside Memory; they do **not** flow through Signals and Loop won't tick on them.
- **Memory** is the long-lived context layer: people, projects, prior decisions, summaries, insights, screen memories, and Knowledge Base chunks. **Loop** reads the relevant slice before it judges; **Chat** reads Memory through retriever skills; the result of every approved action is written back into Memory.
- **Loop** is the only thing that produces **Decisions**. A Decision is the typed judgement ("this email needs a reply", "this PR needs a review"), and a **Card** is how that judgement looks in the UI.
- The **Attention Agent** (also called **Loomi**, the **pet**, or the **fox**) is the messenger. It surfaces cards on the desktop. It does no judging of its own.
- You always tap **Approve** before anything runs. After approval, an **Action Runner** calls a **Connector** to actually send mail / post the comment / update the ticket.
- The result lands back in **Memory** (so the next Loop tick has sharper context) and in the **Audit Log** (so you can see who did what and when).

#### Worked example — "An email needs a reply"

> 9:12 AM. Sarah writes: "Hi — I tweaked tomorrow's Q2 review agenda, can you take a look? Also, I'd like to move our Wednesday 1:1 to Thursday same time — works for you?"

Step by step through the chain:

| Step          | Where it happens                                               | What is produced                                                               |
| ------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| 1. Ingest     | Gmail **Connector**                                            | A raw **Signal** — a new email event                                           |
| 2. Enrich     | **Memory** + **Screen Capture** (if you had related tabs open) | A context slice: who Sarah is, the Q2 project note, last thread summary        |
| 3. Judge      | **Loop** tick                                                  | A typed **Decision** — `email_reply`, confidence `0.85`                        |
| 4. Surface    | **Attention Agent** bubble, main-window queue, pet card        | A **Card** with subject, sender, draft preview, the four-button tray           |
| 5. Approve    | You tap **Approve**                                            | The **Action Runner** for `email_reply` is invoked                             |
| 6. Execute    | Gmail **Connector** (send)                                     | The reply is sent                                                              |
| 7. Write back | **Memory** + **Audit Log**