What Is Intel? A Practical Look at Controlled Content Intelligence

In an environment where content flows from dozens of sources and quality varies wildly, organizations need a way to collect, evaluate, and surface the right material at the right time. Intel is a content intelligence service built to solve that problem through operator control rather than automation. It gathers articles from curated RSS feeds, normalizes and deduplicates them, enriches content with AI-driven summaries and topic extraction, and exposes everything through a stable API for downstream systems to consume.

This post explains what Intel does, how it works, and why manual control sits at the center of its design in version one.

The Core Problem: Too Much Content, Too Little Context

Most content aggregation tools follow one of two patterns. Either they automate everything and risk flooding teams with irrelevant material, or they require heavy manual filtering after the fact. Intel takes a third path. It automates the repetitive work of fetching and normalizing articles, but leaves curation and enrichment decisions in the hands of an operator. This approach keeps AI costs predictable, maintains quality standards, and ensures that only relevant, vetted content reaches internal consumers like the Marketeer Compose workflow.

The service is RSS-first. Feeds are added manually, ingestion is triggered by an admin, and enrichment happens only when an operator selects articles and runs the process. There are no background workers, no automatic schedulers, and no surprise API bills. Everything is deliberate.

How Intel Works: Ingest, Normalize, Enrich

Intel is built around three main workflows.

Ingest and Dedupe

An operator configures sources and their associated RSS feeds through the admin interface. Each source represents a publisher or content origin, and each feed is a specific endpoint that delivers articles. When the operator triggers an ingest run, Intel fetches the latest items from all active feeds, normalizes metadata like title, author, publication date, and canonical URL, and deduplicates entries using a combination of canonical URL and content hash.

If a feed only provides a teaser or summary, Intel attempts to fetch the full text as a fallback. This ensures that downstream consumers receive complete, usable content rather than fragments. All articles are stored in Postgres with clear dedupe keys, publication metadata, and source attribution.

AI Enrichment

Once articles are ingested, the operator can select items for enrichment. This is a manual step. The operator reviews the list, chooses which articles are worth processing, and clicks a button to enrich them. Intel then sends the article content to an AI provider, either a local Ollama instance or a hosted Anthropic API, depending on configuration.

The enrichment process generates a summary, extracts topics, and calculates quality scores. All results are stored in a separate enrichment table with full versioning. Each enrichment record includes the provider name, model identifier, and prompt version, so it is always clear which logic produced which result. This versioning is critical for auditing, debugging, and iterating on enrichment quality over time.

Consumption via API

Intel exposes a versioned pull API under the /api/intel/v1/ path. Downstream systems, primarily Marketeer, query this API to retrieve enriched articles. The API contract is stable and designed to remain backward compatible as Intel evolves. Consumers do not need direct database access, and they do not need to understand the internal schema. They simply request articles by date range, source, or topic, and receive structured JSON responses.

Why Manual Control Matters in Version One

The decision to make ingest and enrichment manual in version one is deliberate. Automation introduces complexity, unpredictability, and cost. By keeping a human operator in the loop, Intel ensures that every article ingested has been reviewed, every enrichment run is intentional, and every API call to an AI provider is accounted for.

This approach also keeps the service simple. There are no queues to monitor, no workers to scale, no retry logic to debug, and no surprise bills from runaway batch jobs. The operator sees exactly what is happening, when it happens, and can adjust behavior in real time.

Manual control does not mean inefficiency. It means transparency. For teams that value quality over volume, this trade-off makes sense. Operators can focus on high-value content, skip low-relevance feeds, and tune enrichment prompts based on actual results rather than guessing what an automated system might do.

Architecture and Technology Stack

Intel is built on Next.js, Postgres, and Drizzle ORM. The application serves both the admin interface and the public API from a single codebase. Postgres acts as the single source of truth for all sources, feeds, articles, enrichments, and run history. Drizzle provides type-safe queries and schema management without the overhead of a heavier ORM.

AI provider logic is abstracted behind a simple interface. The system checks the AI_PROVIDER environment variable and routes requests to either Ollama or Anthropic. This abstraction makes it easy to swap providers, test locally, or run production workloads against hosted models without changing application code.

The data model is straightforward. Sources represent publishers. Feeds represent RSS endpoints. Articles represent normalized content with dedupe keys. Enrichments represent versioned AI output. Ingest runs represent historical execution metadata. This simplicity makes the system easy to understand, extend, and debug.

What Intel Does Not Do

Intel is not a general-purpose web scraper. It does not crawl arbitrary websites, parse non-RSS formats, or attempt to discover new sources automatically. It is not a real-time alerting system. It does not push notifications, trigger webhooks, or send emails when new content arrives. It is not an analytics platform. It does not track user behavior, measure engagement, or generate reports on content performance.

Intel is a focused tool for one job: collect, normalize, enrich, and serve curated content to downstream systems. Everything else is out of scope for version one.

Conclusion: Intelligence Through Simplicity

Intel demonstrates that content intelligence does not require complex automation or black-box algorithms. By giving operators full control over ingest and enrichment, the system remains predictable, auditable, and cost-effective. By exposing a stable API, it enables downstream systems to consume enriched content without coupling to internal implementation details.

For teams that need a reliable way to manage curated content sources, Intel offers a practical starting point. If you are building workflows that depend on high-quality, context-rich articles, consider how a manual-first intelligence service might fit into your stack. The trade-off between automation and control is worth examining closely.