> ## Documentation Index
> Fetch the complete documentation index at: https://cogno.studio/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Concepts
> The handful of parts that make up Cogno — events, the cogno-engine, the cogno-agent, workers, and integrations — and how they fit into one loop.
From the outside, Cogno is simple: the work you're already doing turns into finished tasks. Underneath,
a small set of parts hand that work down a single loop. Learn these five and the rest of the docs — and
the app itself — fall into place.
Activity from your tools, captured as the raw material Cogno works from.
The cognitive engine — makes sense of events and remembers your workspace.
The cloud agent — decides what needs doing and proposes the tasks.
The execution layer on your machine — actually does the work.
## The loop, in one line
**Events** flow in → the **cogno-engine** makes sense of them → the **cogno-agent** proposes the work →
**workers** do it → the result comes back to you as a GitHub pull request. **Integrations** are what feed
the start of that loop and where the finished work lands.
Everything below is just those five parts in more detail.
## Events
Events are the raw material Cogno works from — a single piece of activity from somewhere you already work:
a message in a **Slack** channel, a comment on a **GitHub** pull request, something said in a meeting.
You don't file events. They arrive on their own as you and your team go about your normal day, and they're
what lets Cogno work from what's already happening instead of waiting on you to write a ticket.
In the app, events show up as **Activity** — on a task and across the workspace. "Event" is the concept;
"Activity" is what you'll see on screen.
## The cogno-engine
The **cogno-engine** is Cogno's *cognitive engine*: the always-on intelligence, running in Cogno's cloud,
that turns a stream of raw events into an understanding of what's going on.
It does three things:
* **Makes sense of events** — it reads the messages, meetings, and code activity flowing in and works out
what actually matters, filtering noise from signal.
* **Builds working memory** — it maintains a durable picture of your workspace — projects, decisions,
who's doing what — that persists across events rather than reacting to each one in isolation.
* **Feeds the agent** — that memory and understanding is the context the cogno-agent draws on to decide
what to do next.
Think of the cogno-engine as the part that *understands*. It doesn't create tasks itself — it builds the
picture that lets the cogno-agent create good ones.
## The cogno-agent
The **cogno-agent** is Cogno's cloud agent. Backed by the cogno-engine's memory and your existing tasks,
it decides what needs to happen and **proposes tasks** — no one has to write the ticket.
* It runs in **Cogno's cloud**, always on, independent of your machine.
* It reads the cogno-engine's understanding of the workspace, plus the tasks already in flight.
* It creates tasks and places them in the **Suggested** lane of a status, each with a short
reason — you glance, then **accept** or **dismiss**. See [Work with Tasks](/docs/tasks) for how
the lane works.
Where the cogno-engine *understands*, the cogno-agent *decides and proposes*. It's the difference between
knowing what's going on and turning that into concrete work.
## Workers
A **worker** is Cogno's execution layer — the piece that actually *does* the work. Workers run on **your
machine** (installed with the desktop app), not in the cloud.
* A worker picks up a task and runs a coding agent — **Claude Code** or **Codex** — to implement it.
* It reports a **heartbeat** so you can see it's online in **Worker Hub**; go quiet and it shows as stale,
then offline.
* When it's done, it delivers the result as a **GitHub pull request** you review and merge.
The clean split: the **cogno-agent** thinks in the cloud and proposes the work; **workers** run on your
computer and carry it out. See [Getting started](/docs/getting-started) to set up your first worker.
## Two kinds of integrations
Integrations connect Cogno to the tools you already use. They come in two kinds, matching the two ends of
the loop:
| Kind | What it does | Examples |
| ----------- | -------------------------------------------------------------------------------------------- | --------------------------------------------- |
| **Sources** | Cogno *reads* them for context — their activity becomes events the cogno-engine learns from. | Slack, ChatWork, Discord, Messenger, meetings |
| **Actions** | Cogno *delivers through* them — where finished work lands and stays in sync. | GitHub (pull requests) |
Most integrations are **sources**: they feed the start of the loop. **GitHub** is the main **action** — it's
where the work comes back to you. Some connectors do both (GitHub syncs issues *and* receives PRs).
See every connector and how to set each one up.
## Related docs
* [What is Cogno?](/docs/introduction) — the idea behind the loop.
* [Getting started with Cogno](/docs/getting-started) — set up the loop end to end.
* [Connect integrations](/docs/integrations) — bring in your sources and actions.