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 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 below.
The shape of it
Four things, each doing one job:
One credential for one workspace, held for the whole account — not per agent. Connecting costs nothing and isn't gated by your plan.
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.
One agent's link to a connection: its own schedule, its own status, and Detach without touching anyone else's.
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:
- Name the workspace — whatever you'd recognise it by later ("Acme Docs"). This is a label, not a check against anything.
- 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.
- 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.
- 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).
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.