Hyper docs

Goal for this release

The last release put the rebuilt Hyper in front of real teams. Those teams quickly showed us where the product still created friction: important tools were missing, connected information could be shared too broadly, synchronization was hard to understand, and direct links did not always open the information Hyper already had.

Our goal for this release was to address those problems directly:

Add the connectors teams need for customer, product, engineering, and operational work.
Give people explicit control over which connected information their teammates can access.
Make synchronization more reliable and easier to understand.
Make connected information easier to open and act on.
Improve the everyday desktop experience while preparing Hyper for iPhone.

Four new connectors

Hyper now connects to Attio, Jira, Confluence, and Supabase.

Attio

Hyper can now connect to an Attio workspace and use its customer and relationship data alongside information from the rest of a team’s tools.

The connector indexes:

Objects, attributes, and workspace schemas.
People, companies, deals, and custom records.
Lists, list entries, pipeline stages, and relationships.
Notes, tasks, and comment threads.
Meetings and completed call transcripts.

Hyper can search across Attio, query records with structured filters, read a record together with its related activity, inspect meetings and transcripts, and find email activity involving a person, company, domain, or record.

When explicitly asked, Hyper can also create or update records, add notes and comments, manage tasks, and update list entries such as deal stages. Destructive actions remain limited and explicit. (#260)

Attio changes arrive through signed webhooks, with periodic refreshes for information such as meetings and transcripts that Attio does not publish through webhooks.

Jira

Hyper can now connect to Jira sites and work with projects, workflows, issues, custom fields, comments, work logs, attachments, links, boards, and sprints.

It can:

Search issues using Jira Query Language.
Read an issue with its fields, comments, and available workflow transitions.
List projects across an authorized site.
Create and edit issues.
Add comments.
Move an issue through its workflow.

Workflow transitions account for each Jira site’s own fields and statuses instead of assuming every team uses the same process. Hyper refuses ambiguous transitions rather than guessing which workflow action the user intended.

Jira updates arrive through per-site webhooks backed by regular sweeps. This covers missed deliveries, expired registrations, newly added projects, and temporary provider failures. (#317)

Confluence

Hyper can now connect to Confluence spaces and use pages, blog posts, comments, attachments, and action items.

It can:

Search content using Confluence Query Language.
Read a page or blog post with its comments.
List spaces.
Create new pages.
Update existing pages and blog posts.
Add comments.

Confluence edits are version-checked. Hyper reads the current version before replacing content and refuses to overwrite a newer edit made in the meantime.

Confluence does not provide OAuth applications with the same webhook support as Jira, so Hyper checks for recent changes every 15 minutes and periodically reconciles the full site. (#317)

Supabase

Hyper can now connect to one or more Supabase projects through OAuth and run read-only SQL through the Supabase Management API.

The connector applies several limits before a query reaches a database:

Only a single read-only SELECT statement is accepted.
Supabase also receives the request with its server-side read_only setting.
Results are capped at 200 rows.
Large cells are clipped before entering the conversation.
Connections spanning multiple projects require Hyper to identify the intended project rather than guessing.

Supabase is an on-demand connector: it does not copy database rows into Hyper or run a background synchronization process. (#290)

Connected information has clearer access controls

A connection no longer has to expose everything it contains to every member of a workspace.

The person who connected an account can now choose between:

Only you: Other workspace members cannot retrieve information from that connection.
Shared with workspace: Teammates can retrieve information that both the connection owner and the source itself allow them to see.

The owner always retains access to their own connection. Other members only receive an item when both the connection and that item are classified as shared. This rule is enforced when Hyper searches, reads, resolves links, or accesses connected Google documents, not only in the interface. (#282)

Hyper also preserves privacy signals from each source:

Private or confidential Google Calendar events stay private.
Private Slack channels stay private, and direct messages are not ingested.
Google Drive files are shared only when they are in a Shared Drive, available to the team’s domain, or available to anyone with the link.
A file shared with an unrelated external domain does not become visible to the connected Hyper workspace.
Gmail connections start private by default.

Not every provider exposes item-level permissions. When a provider cannot answer who should see an item, Hyper defaults to the safer interpretation instead of assuming it is shared.

This release is the first version of connector access control. More granular controls by member, role, and information type are still to come.

Pasted links now open connected information

Users often already know which document, issue, or page they want Hyper to inspect. Searching by title was an unnecessary and unreliable extra step, especially when several files had similar names.

Hyper can now resolve pasted links to information it has already indexed and open the matching source directly.

Resolution supports canonical source URLs across connected services and stable identifiers embedded in links, including:

Google Drive and Google Docs file IDs.
Notion page IDs.
GitHub issues and pull requests.
Other connected sources whose stored URL matches the pasted link.

The lookup remains scoped to the current workspace and applies the same access-control checks as search and reading. A pasted link does not bypass connector privacy. (#277)

Gmail drafts can reply in existing threads

Hyper could already create Gmail drafts without sending them. It can now draft a reply to a specific message inside the existing Gmail thread.

The connector reads the source message, preserves the thread, and creates the required reply headers. It rejects malformed source headers and still leaves the message as a draft for the user to review and send. (#272)

We also fixed Gmail synchronization that could leave recent messages unavailable after the initial import. New messages should now continue arriving without requiring a manual reconnect or full synchronization.

Synchronization is clearer

Early users could not easily tell whether a connector was actively importing information, had finished, or had simply checked and found nothing new. Notifications were frequent, vague, and disconnected from the rest of the interface.

The sidebar now shows synchronization as a standing activity instead of producing a stream of temporary toasts.

While a connector is actively importing information, Hyper shows a live state such as “Syncing Gmail…”. When synchronization finishes, the sidebar reports which sources changed. Closely timed updates are combined into one message rather than shown individually. (#273, #280)

A completed sync is announced only when it actually stored or removed information. Routine checks that found no changes remain silent.

This required synchronization writes to distinguish between:

New or changed information.
A real deletion.
An unchanged item written again by a polling connector.
A deletion request for an item Hyper did not store.

That distinction also stops connectors such as PostHog from repeatedly announcing unchanged dashboards after every scheduled poll.

Synchronization is more reliable

We fixed several connector-specific failures found in production.

PostHog connections that reached more than one organization could previously fail every scheduled sync because the connector expected exactly one organization when naming the connection. Hyper now treats the full authorized organization set as the connection’s identity while continuing to sync every reachable project. Existing affected connections recover automatically. (#275)

We also stabilized the shared scheduler used by polling and webhook-based connectors:

Scheduled reconciliations can no longer be starved by a steady stream of webhook events.
Webhook events still run promptly after reconciliation.
Temporary failures do not cause valid provider data to be mistaken for deletions.
Repeated writes of unchanged information no longer count as new activity.
Connectors recover more cleanly from missed updates and interrupted work.

These changes are especially important for Attio, Jira, Confluence, Gmail, Google Drive, and PostHog, which combine different forms of webhooks, polling, refreshes, and full reconciliation.

Chat is smoother during everyday use

We made several small changes that remove repeated friction from the desktop app.

The message composer now keeps or restores focus when the app becomes ready, after a message is submitted, and when the user opens or creates a conversation. Users can continue typing without clicking back into the input after normal keyboard-driven navigation. Explicitly clicking elsewhere still moves focus as expected. (#304, #331)

We also made active work easier to distinguish: the stop control now uses a clear destructive treatment instead of looking like a normal primary action. (#273)

Preparing Hyper for iPhone

We built a native SwiftUI application that uses the same Rust core as the desktop app instead of creating a separate mobile implementation.

The current iPhone app supports:

Google sign-in.
Onboarding and workspace switching.
Conversation history.
Streaming chat responses.
Tool activity and source details.
Model selection.
Secure token storage in Keychain.

The shared core owns authentication, workspace state, conversations, and active work. The iPhone app is a native interface over that same state, which reduces the chance that desktop and mobile behave differently. (#263)

The iPhone app is not included in this Mac release. We plan to begin distributing it through TestFlight next week.

What this release enables

The last release showed that teams wanted to use Hyper across more of their actual work, but connector coverage, privacy, and freshness still limited how much they were comfortable connecting.

This release moves each of those constraints forward:

Attio, Jira, Confluence, and Supabase bring customer, engineering, documentation, and database work into Hyper.
Connection-level controls let teams share useful information without automatically sharing everything.
Direct link resolution makes it easier to give Hyper the exact source a task depends on.
Gmail replies, Attio actions, and Atlassian actions let Hyper carry more work through to completion.
Clearer synchronization states make it easier to know when connected information is still arriving.
Reliability fixes reduce missed updates, stale data, and noisy no-op synchronization.
The native iPhone app creates a path to using Hyper away from the desktop.

The next step is to deepen what Hyper can safely do inside every connector while making access controls more granular. We are also working on a more sophisticated agent that can be interrupted or redirected while it works and can delegate parts of larger tasks to specialized subagents.

HubSpot, LinkedIn, Resend, and additional connectors are also under consideration. If there is a connector your team needs, tell us at founders@heyhyper.ai.