---
title: "Connections"
description: "Connect a workspace once, then attach any number of agents to it, each on its own pages and schedule."
source: https://hiy.ai/docs/connectors
---

# Connections

A connection keeps your agents in step with a workspace you already use —
prose from a shared tool, not rows from a feed (that's a
[synced list](/docs/records#keeping-a-list-current-automatically) instead).
You connect a workspace **once**, for the whole account, then decide which
agents draw on it and which of its pages each one gets.

Every card in the catalog is a real plan, marked **Coming soon** until its
sync is built. Notion is first in line: the steps below are how it will work
once its card goes live — see [What's coming](#what-s-coming) below.

## The shape of it

Four things, each doing one job:

- **A connection** — One credential for one workspace, held for the whole account — not per agent. Connecting costs nothing and isn't gated by your plan.

- **The tracked pool** — The pages you've picked from that workspace, checked and cached once for everyone. Adding a page to the pool doesn't hand it to any agent yet.

- **An attachment** — One agent's link to a connection: its own schedule, its own status, and Detach without touching anyone else's.

- **An assignment** — Which pool pages a given attachment actually pulls into that agent's own Knowledge. Two agents on the same connection can hold completely different pages.

Content is fetched from the workspace once per changed page, however many
agents are attached — hiy never asks Notion for the same page twice because
two agents both want it. Once a page reaches an agent, it's an ordinary
`synced` source in that agent's own Knowledge, and behaves exactly like any
other source there: it trains, it can be cited, it can be searched. The
Connections section itself never shows page content — it's where you manage
*what's connected*, not a place to read what was synced.

## Connect a workspace

Open **Connections** in the sidebar, pick a live provider — Notion, once its
sync lands — and step through:

1. **Name the workspace** — whatever you'd recognise it by later ("Acme
   Docs"). This is a label, not a check against anything.
2. **Paste an internal-integration token** — Notion's own kind of credential
   for one workspace. hiy says the boundary plainly before you paste it:
   *anything you share can be repeated by any agent it's assigned to, to
   anyone that agent talks to.*
3. **hiy reads the workspace.** This can take a few minutes for a large one;
   it never spins forever, and it always hands you on to the next step —
   with whatever it found so far — rather than leaving you watching a
   spinner.
4. **Pick the first pages to track.** A plain checklist of what hiy found.
   Nothing is added to the pool until you tick it, and you can skip this
   step and pick pages later from the connection's own page.

Cadence — how often an agent checks for changes — isn't asked here. It
belongs to each agent's own attachment, not to the connection (see
[Attach an agent](#attach-an-agent)).

**Note:** Free plans can connect a workspace too — creating a connection isn't metered.
The plan limit applies when you attach an agent to it (below), and it's
explained in place if you hit it, never behind a dead button.

## Add or drop tracked pages

From the connection's own page (open it from **Connections**): **Add pages
from the workspace** opens a checklist of everything hiy has seen there that
nobody has picked yet — new since your last look is marked. Ticking pages and
saving adds them to the tracked pool, available to assign to any attached
agent.

**Untracking** a page — taking it out of the pool entirely — is a real
withdrawal, the same weight as Disconnecting: it's unassigned from every
agent that had it, and each of their copies is marked for removal at that
agent's next sync. It isn't wired to a button in the tracked-pages list yet;
when it is, this page will say where.

**Re-check workspace** asks Notion what's changed since the last check and
updates the pool — new pages arrive untracked (so they show up in the
checklist, not silently in anyone's agent), and pages that vanished upstream
are marked gone without deleting their cache. If a re-check would remove more
than half the pool in one pass, hiy holds rather than acting on it and says
so — a provider hiccup that returns almost nothing looks exactly like "delete
everything," and hiy refuses to guess which one happened.

## Attach an agent

An agent gets nothing from a connection until it's attached. Two ways in:

- **From the agent's own Sources panel** — "Add a connection" lists the
  account's existing connections; press Attach.
- **From the connection's own page** in Connections — "Attach an agent"
  picks any agent not already on it.

Attaching asks for a schedule:

- **Once a day** — checks the shared pool and pulls in whatever this agent
  is assigned, every night.
- **Only when I ask** — nothing automatic; you trigger it with Sync now.

A freshly attached agent starts with **no pages assigned** — attaching and
assigning are two separate steps on purpose, so bringing an agent onto a
shared workspace never silently hands it everything in the pool.

**Note:** Attaching an agent is the step your plan limits, not connecting the
workspace. The limit counts distinct agents attached anywhere in the
account — an agent already attached to one connection never spends a second
slot attaching to another. Hitting the limit shows the plan sentence in
place, with a real upgrade path, never a refusal with nothing to do about it.

## Choose an agent's pages, or change its schedule

**Choose pages**, on the agent's own card (or the per-row dots on the
connection's pool list), sets which tracked pages that one agent pulls —
independent of every other agent on the same connection. Saving replaces the
whole set: unchecking a page un-assigns it, and it leaves that agent's
Knowledge at its next sync.

**Cadence** can be changed anytime from the agent's card — switching to
"Only when I ask" doesn't lose anything already synced, it just stops the
nightly check.

**Sync now** re-reads the *shared pool* for this agent alone — instant,
because it never has to ask the workspace itself, only the cache hiy already
holds. It won't discover pages nobody has tracked yet; for that, use
**Re-check workspace** on the connection.

## What Remove, Detach, and Untrack each do

| Action | Where | What it does |
| --- | --- | --- |
| **Untrack** a page | The connection's pool | Takes one page out of the pool. Every agent that had it loses that page at its next sync. The connection, the credential and every other page are untouched. |
| **Detach** an agent | The agent's own card | Ends just that agent's attachment. That agent's synced copies are marked for removal; the connection, its pool, its credential, and every other attached agent keep going exactly as before. |
| **Remove** a connection | The connection's own page, in Connections | Ends the whole connection: the credential is revoked for real, and **every** attached agent loses its synced copies from that workspace — not just one. |

Both Detach and Remove tell you, before you confirm, whether the agent losing
its synced pages will have anything left — if a connection is an agent's only
knowledge, removing it says so plainly, rather than leaving you to discover a
blank agent afterwards.

## The states you'll see on an agent's card

Each attached agent shows one line, in plain language, read off that
attachment alone — never a raw error, never a spinner standing in for a fact.
There are ten distinct sentences underneath; they group into five words on
the card, below, because that's what a glance actually needs:

| Word on the card | What it means |
| --- | --- |
| **Reading your workspace** | The first sync is still running; the card counts pages as they arrive rather than showing a total it doesn't know yet. |
| **Up to date** | Checked, and either nothing changed, some pages were added (training tonight), or some were edited (the agent keeps answering from the old version until then). |
| **Needs a look** | hiy hasn't been able to check for a while, the workspace returned nothing on a check (nothing was removed, just in case), a page limit stopped it partway, or a check failed once and will retry tonight. |
| **Paused** | Either your plan no longer includes attached agents, or pages were read but training is paused until the next cycle — nothing already read is lost either way. |
| **Needs reconnecting** | The workspace access was removed on Notion's side. The agent still knows everything it already read; reconnecting isn't available yet (see below), so the way forward today is Remove, then connect the workspace again with a fresh token. |

Two more moments live outside this card: **before you attach**, hiy explains
what a connection would do rather than showing a control with nothing behind
it yet; and **detaching or removing** always shows the consequence above
before you confirm it.

## What's coming

The Connections catalog lists every integration hiy plans to support before
any of them is live — so you can see what's coming without us pretending it
already works. Every card is dimmed and does nothing when pressed; each says
**Coming soon**.

**Notion** — first in line. The workspace flow, the tracked pool and
per-agent assignment described above are built; what's left is the sync
against Notion's own API, and the card goes live the day it lands.

**More sources for the pool** — Google Drive, Confluence, GitBook, Intercom,
HubSpot, Zendesk.

**Tools your agent could act through** — Slack, GitHub, Linear, Jira,
Calendly, Cal.com, Stripe, Pipedrive, PostHog, Figma. These would let an
agent act (send a message, open a ticket, look up an order), which is a
different job from the tracked pool above — they're catalog placeholders
today, wired to nothing.

Reconnecting a workspace with a fresh token — instead of removing it and
starting over — is also planned and not live yet.