For your project · Loom

Memory that builds its own connectors.

When the vault has nothing on a subject, you do not write an integration. You describe it, and Loom builds one.

Ask in plain language

Ask Cortexa a question or describe a subject. When the vault has nothing on it, the request goes to Loom, which looks for where the data lives and checks the vault first, so it doesn't duplicate what you already know.

Ask Cortexa searching the vault, finding no answer, and asking Loom for a new source

It writes and tests its own connector

Loom analyzes the source, writes a connector, runs it against captured samples, checks the output against a schema, and freezes it only when it works.

Loom discovering, analyzing and querying a data source before building a connector for it

Sandboxed by declaration

Each connector declares the hosts and folders it needs. It runs in a sandbox that can reach only those, and undeclared access stops the run.

Credentials stay in your system keychain; the sandbox only ever gets an opaque handle, and authenticated requests are made outside it.

Two hand-reviewed connectors, Gmail and Google Photos, run as trusted code rather than in the sandbox.

Loom: sources and extraction pipelines feeding the vault

Nothing lands until you say so

A new source's first run is held for your approval and delivers nothing until you approve it.

Autonomous building is off by default. When it's on, it's bounded by daily caps on builds, runs, new sources and spend, and every action is logged.

Loom's autonomy log: a connector built and wired, with daily caps on builds, runs, new sources and spend

Breaks loudly, then rebuilds

Before each scheduled run, Loom replays the connector's saved fixture. If the source has drifted, it's marked needs-rebuild instead of silently returning nothing, and one click rebuilds it.

Failed runs back off and retry.

The Cortexa library: captured thoughts from coding sessions, grouped by project and type

Arrives as memory, your way

Records are distilled into thoughts as reference notes, digests, or consolidated summaries. A per-source lens, a plain-language instruction like "focus on breaking changes", shapes what's kept.

Then they're linked into your graph like everything else.

The knowledge graph: thoughts as points of light, links drawn between related ideas

Example. You ask Loom to follow releases of a framework you depend on. It finds the release feed, writes the connector, and, once you turn scheduling on, runs it on a schedule, and the next time an agent upgrades that dependency, the changelog is already in its context.

31 connectors built in. The rest, it builds.

  • Bluesky
  • Confluence
  • CSV folders
  • Discord
  • GitHub issues
  • GitHub (public)
  • GitLab issues
  • Gmail
  • Google Photos
  • Hacker News
  • iCal calendars
  • Jira
  • JSON folders
  • JSONL folders
  • Linear
  • Markdown folders
  • Mastodon
  • media folders
  • Notion
  • Readwise
  • Reddit saved
  • RSS
  • sitemaps
  • Slack
  • Stripe events
  • text folders
  • Todoist
  • Trello
  • web pages
  • YouTube transcripts
  • Zendesk

Off until you turn it on

  • Scheduling and autonomous building default to off.
  • Evidence references on delivered memory are opt-in.
  • Today a person states the subject; Cortexa does not yet raise its own questions.

Give your agents a memory tonight.

Free desktop app for Windows and macOS. Your vault stays encrypted on your machine.

Download Cortexa See integrations