Social Radar is powered by a new agentic harness precisely engineered to find, evaluate, rank, and return first-party social content relevant to your natural language query. It is faster and more accurate than any existing alternative. We call this harness Scout, and since this is the first publicly accessible version, we refer to it as Scout-v1.
This is not a single large language model. It is a series of large language models — both off-the-shelf and custom-built — carefully orchestrated to perform best-in-class search over social media. Below are the core principles behind the framework.
Data Access
Most research agents struggle with data locked inside "walled garden" social networks. When asked to fetch content from LinkedIn, for example, a typical agent may attempt a raw curl request — which is quickly blocked. Others, like Manus, ask you to provide your personal credentials, which are then stored server-side, introducing latency and serious privacy risks.
Scout takes a different approach. Through a combination of partnerships and careful code generation, it can directly access data stored on these websites without requiring user credentials. All data is fetched in real time, which is essential given the fast-changing nature of social feeds.
Cross-Channel Parallelism
When answering a query, Scout examines every available channel in parallel. It collects every potentially relevant post, profile, comment, or other item, then analyzes each individually before making a final decision.
Scout dynamically provisions thousands of ephemeral sub-agents across a distributed execution layer. Each sub-agent runs as an isolated evaluation process with its own toolchain and context, enabling safe parallelism and fault isolation. This allows the system to sustain massive concurrency while maintaining deterministic behavior.
Each sub-agent is tool-oriented, meaning it can selectively invoke scraping, classification, entity linking, or ranking tools depending on the content type it encounters. This modular design allows new tools to be introduced or retired without re-architecting the system.
To further improve efficiency, Scout employs a deduplication layer that normalizes redundant content across channels before semantic re-ranking. This prevents near-identical items from inflating the result set, reduces wasted reasoning steps, and ensures the candidate pool reflects only unique, high-signal content.
This parallelism means Scout can infer that someone is interested in machine learning if they've liked several ML-related posts, even if "machine learning" never appears in their profile text. By running thousands of isolated evaluations simultaneously, Scout achieves complete semantic analysis across entire feeds, reducing irrelevant results and surfacing subtle but high-signal connections.
Memory-Driven Conversational Follow-Ups
One of Scout's most powerful differentiators is its structured memory architecture, which lets you engage in true conversational UX over social search. Unlike agents that treat each query statically, Scout maintains a memory graph over the course of a session: every item it examines, every filter or refinement you request, and every rationale is compartmentalized.
Here's how it works under the hood:
- Compartmentalized Memory Units — As Scout fetches and evaluates posts, profiles, comments, etc., it stores them in discrete memory units: each unit links a social item, metadata, its evaluation rationale, and a trace back to your query context.
- Traceable Memory Links — These units are interconnected via edges (e.g. "came from this query," "matched this sub-agent," "filtered out in this follow-up") so the system can walk backward, re-evaluate, or re-rank based on new constraints.
- Dynamic Refinement Without Re-execution — Because memory is structured and query context is preserved, when you ask a follow-up (e.g. "only those who liked a post from my company or one of my competitors" after "nuclear engineers at Stanford"), Scout doesn't rerun the entire fetch. Instead, it refilters and reranks from its existing memory graph, applying the new constraints quickly and with full explainability.
- Memory Abstraction & Pruning — To stay performant, Scout consolidates memory units over time (merging, compressing, discarding low-signal units) while retaining key decision paths.
The result: a research experience that feels conversational and iterative. You can start broadly and keep refining in natural language, all while the system maintains context, memory, and explainability in the background. No agent today delivers this level of fluid follow-through in social media research.
Ranked Results with Rationales
Most research agents operate like black boxes: they deliver a list of outputs, but offer little transparency into why those outputs were selected. Scout takes a different approach. Every query returns a ranked set of results, ordered by relevance to the user's intent.
Scout implements a multi-stage ranking pipeline: candidate retrieval, semantic re-ranking, and rationale aggregation. Each stage is powered by models specialized for its role — from lightweight lexical filters to deep semantic encoders. The final ranked list is produced via a learned scoring function, with rationales surfaced as structured annotations attached to each item.
Crucially, rationales are stored as structured metadata, not just human-readable text. This means they can be consumed programmatically by downstream systems — CRMs, recruiting platforms, or analytics dashboards — making Scout's outputs both explainable and composable.
This makes results easier to trust and easier to act on. Instead of scrolling through opaque lists, users can immediately understand the logic behind Scout's choices and move faster to engage, share, or follow up.
Hardware Acceleration
Scout is built alongside vendor partners Cerberas and Groq. Their low-latency accelerators dramatically reduce inference time and increase throughput. Unlike GPU-bound systems, Scout can evaluate thousands of social items in parallel with millisecond-level responsiveness.
This architecture drastically reduces the compute overhead per sub-agent, making the evaluation phase up to 10× faster than GPU-based systems. While network requests remain the dominant factor in end-to-end latency, hardware acceleration ensures that once data is retrieved, Scout can process and rank it with minimal delay, keeping overall response times consistently tight even under heavy load.
Just as importantly, lower per-step latency allows Scout to perform more reasoning steps within the same time budget, which improves semantic accuracy and reduces false positives.