Industry Intelligence

At a glance

An analyst tracking AI product launches for a living used to spend Friday mornings skimming 30 X threads, 4 Product Hunt pages, a handful of Reddit threads, and 2 RSS feeds, then trying to remember on Monday which ones actually mattered. Most of the time, they couldn't.

The painful part wasn't the reading. It was the memory. "I read something about an Anthropic competitor two weeks ago — what was the name?" "There was a Product Hunt launch last Tuesday that I wanted to follow up on, but I've already lost the thread." The research happened; the retention didn't.

The shortfall isn't discipline. It's the cognitive load of holding 50 launches across 4 sources at the same time.

The user doesn't want another chatbot that waits to be asked. They want an AI assistant that genuinely fits an analyst's week: it does the reading in chat, writes what gets confirmed into Memory, and only finds them when there's a decision that genuinely needs to be made.

Honest about what Loop ships built-in: Email / Calendar / GitHub / Slack / Linear are the five built-in sources. X, Reddit, RSS, and Product Hunt aren't in that list — but they can be registered as custom channels via the openloomi-loop skill, and once registered Loop reads them the same way it reads Linear.

Problem 1: Friday morning was 30 X threads + 4 Product Hunt pages

The exchange used to go like this:

• Open X, scroll the AI-launch mentions from the last 7 days
• Open Product Hunt, filter to AI-tagged launches, read the top 10
• Open Reddit, check r/MachineLearning and r/LocalLLaMA for the threads that bubbled up
• Open 2 RSS feeds, skim the Hacker News front page and a research-blogs aggregator
• Try to remember which of these had already been seen
• Stitch the "5 things worth tracking this week" together from memory

If the week was busy, this got pushed to the next Monday. By then, half of what was wanted to track had already been overtaken by the news cycle.

This is exactly what AI should be doing. The actual hard part of industry intelligence isn't the prioritization — it's the reading and the synthesis across sources, plus the retention so the next week builds on the last.

So the agent is asked in Chat. The agent has read access to memory and can call any registered custom channel. The main OpenLoomi window → Chat is opened and asked:

• "Pull this week's top AI product launches from X and Product Hunt. Save the three most relevant to memory under insights/ai-launches/."
• "What did I save about Anthropic's roadmap two weeks ago? Has anything shifted?"
• "Add a daily 9 AM digest that polls Product Hunt for AI-tagged launches and posts the top 3 to my Brief."

Each insight the agent writes to ~/.openloomi/data/memory/insights/ is timestamped and tagged. A daily analytics refresh surfaces the entries actually engaged with; a weekly compaction archives stale ones instead of deleting them — so context never silently disappears.

The x-twitter-api skill is the public packaging for the X side of this; the composio-cli skill covers Product Hunt and Reddit. Both install on the fly the first time they're asked for.

Problem 2: "I read it last week but forgot the name"

The mirror problem to the reading was the retention. Something gets read, it's meant to be tracked, and by next week the thread is already lost. Notes in Notion never quite worked — the friction of opening Notion, finding the right page, and pasting the link was higher than the impulse to track it.

OpenLoomi Memory made the retention implicit. Every insight the agent writes to ~/.openloomi/data/memory/insights/ is timestamped and tagged. The next week, there's no need to remember "what was the Anthropic competitor" — it's just asked:

"What did I save about Anthropic's roadmap two weeks ago? Has anything shifted?"

The agent reads the relevant slice of memory and returns the entries that were confirmed. The longer it's used, the sharper the research gets, because every confirmed insight becomes a node in the same memory graph.

This is the inversion that made the workflow stick: instead of writing notes to remember things, the agent writes notes that can be asked about later. The note-writing and the asking are the same operation, and the same memory layer serves both.

Problem 3: Sources Loop doesn't ship built-in

The other friction was source coverage. X, Reddit, RSS, and Product Hunt are the four sources actually needed to watch, and none of them is in Loop's five built-in sources (Email / Calendar / GitHub / Slack / Linear). Three options were on the table:

1. Build a custom scraper for each one (no — this was tried, it dies after 3 weeks when one of the APIs changes)
2. Skip the sources and accept the gap (no — the gap is the whole point)
3. Register them as custom channels once and let Loop poll them the same way it polls Linear (yes)

Option 3 was chosen. The registration is one-time per source, in chat:

Register a custom channel called "x_mentions" that polls my X mentions every 15 minutes.
Register a custom channel called "product_hunt_ai" that polls Product Hunt's AI-tagged launches every hour.
Register a custom channel called "rss_ai_news" that polls the Hacker News front page every 30 minutes.

Each registration writes a small JSON record to ~/.openloomi/loop/custom-channels.json and applies on the very next Loop tick. State is per-user, local, human-readable.

X lives in Composio's app catalog, so the skill installs Composio on the fly if not already installed. The custom-channel interface wraps any Composio toolkit + toolSlug combination with a pollIntervalSec ≥ 60. The minimum registration record contains:

To share a configuration with a teammate, the JSON file is copied — that's it. The same interface is also used to register RSS feeds (wrap a small local filesystem watcher), Reddit threads (Composio's reddit toolkit), or anything else that lives in a system Loop can poll.

💡 Custom channels are scoped to your local ~/.openloomi/loop/ directory. They're per-user, human-readable, and can be edited by hand if a source changes shape. The Brief and Wrap rollups respect custom channels the same way they respect built-ins — the 9 AM Brief includes the AI-tagged Product Hunt launches from the custom channel without any extra wiring.

What this workflow really solves isn't a few automation scripts

At first the goal was just to save the 2 hours every Friday being spent skimming sources. But after a few weeks, the realization hit: the real problem isn't a few missing automation scripts — it's that industry intelligence is fundamentally a memory + synthesis problem:

• The reading happens across 4 sources, none of which has the full context
• The retention has to span weeks, but notes don't carry forward
• The synthesis has to be cross-source, but each source only knows itself
• The morning brief has to roll up everything confirmed, but the sources don't know what's "confirmed"

In the past, all this had to be done by actively searching and re-reading. The change OpenLoomi brings is inverting that relationship: instead of constantly re-skimming, the agent reads in chat, Memory carries the research across weeks, and Loop rolls the signals up at the right moment.

• If a launch is worth tracking, the agent writes it to insights/ai-launches/ with a timestamp and a tag.
• If a topic asked about last week has shifted, the next chat query returns the updated picture.
• If a custom channel surfaces a new launch, the Brief at 9 AM includes it alongside everything else.
• If an insight goes stale, the weekly compaction archives it instead of deleting it — so the research history never silently disappears.

All that's needed is to focus on the parts that genuinely need judgement — which launches are actually worth tracking, which shifts in the market actually matter.

From "Friday morning skim" to a continuously running intelligence loop

To make this work, two kinds of working patterns are configured in OpenLoomi.

One is event-driven:

The other is scheduled:

Together they form a loop that runs continuously across the four sources:

Continuously watch → Read and synthesize in chat → Write confirmed insight to memory → Roll up in Brief → Human asks, agent answers

Compared to configuring an isolated scraper per source, the preference is to have OpenLoomi keep understanding "what's the picture of the AI market this week, and how does it connect to what was tracked last week."

💡 The reading happens in chat; the polling happens in Loop. Loop's job is to watch the channels that were wired and surface signals. The agent's job in chat is to read those signals, write the ones that matter into memory, and answer the queries asked. The Brief is the daily rollup. None of it requires a scheduled task wired up by hand.

What changed

What OpenLoomi saves isn't just the 2 hours every Friday. More importantly, there's no need to keep re-skimming the same sources, re-finding the same launches, and worrying about which insight was dropped.

How to set this up

Two paths, both start from chat.

Path A: Start with the built-in channels

use openloomi-connectors to connect GitHub
use openloomi-connectors to connect Slack

A few public competitor repos on GitHub are watched, and a Slack channel where peers discuss launches is added. Loop picks them up on the next tick — no prompt to paste, no scheduled task to wire up. Trusted contacts and source toggles are tuned in Settings → Loop.

Then in Chat:

Summarize the last 7 days of launches from the GitHub repos I'm watching and the
Slack channels Loop flagged. Save the top 3 to memory under insights/ai-launches/.

The agent pulls, summarizes, writes to memory. Next morning's Brief references the new entries.

Path B: Add X / RSS / Product Hunt as custom channels

For sources Loop doesn't ship built-in, registration happens in chat:

Register a custom channel called "x_mentions" that polls my X mentions every 15 minutes.
Register a custom channel called "product_hunt_ai" that polls Product Hunt's AI-tagged launches every hour.
Register a custom channel called "rss_ai_news" that polls the Hacker News front page every 30 minutes.

Each registration writes to ~/.openloomi/loop/custom-channels.json and applies on the very next Loop tick. State is per-user, local, human-readable.

To add a skill for the agent to call directly in chat (e.g. for full X search beyond mentions, or for Product Hunt's comments), the matching public skill is installed:

Add the x-twitter-api skill so I can search and post in chat.
Add the composio-cli skill so I can call any Composio toolkit from chat.

Each skill installs on the fly the first time it's asked for.

💡 The Brief and Wrap rollups respect custom channels the same way they respect built-ins — the 9 AM Brief includes the AI-tagged Product Hunt launches from the custom channel without any extra wiring.

OpenLoomi's audit log records every execution — which custom channels fired, which insights the agent wrote to memory, which queries were asked in chat, which signals the Brief rolled up. This way the source-watching can be handed off to AI while every action it took remains visible.

Related

• Loop — the engine that polls the custom channels
• Connectors — wiring the built-in sources
• Memory — long-term retention of the launches you've read
• Automation — the Friday Brief schedule
• Skills — the x-twitter-api / composio-cli skills this story references