Tabstack Research: Verified Answers from the Open Web

Web browsing is the hidden tax of AI development. When you connect an agent to the open web, you are forced to stop building AI and start managing the overhead of browser orchestration. You end up debugging JS-rendering, rotating proxies, and writing brittle selectors just to turn the chaotic web into clean inputs. This is why we built Tabstack: to turn browsing into a reliable infrastructure layer.

But even with a stable browser fleet, developers face a secondary bottleneck: The Synthesis Gap.

Fetching raw data from a single URL is an infrastructure problem. Answering a complex question like "Compare Slack vs. Teams retention policies" is a state management and reasoning problem. To answer that, an agent must spawn a fleet of parallel searches, navigate dozens of unvetted URLs, filter out 90% marketing noise, and reconcile conflicting data.

Processing this at scale creates a direct conflict between latency and context window density. If you feed your model every raw byte, you burn your token budget on noise. If you truncate too early, you lose the ground truth.

Today we are launching Tabstack Research. It is a high-level research primitive that moves the autonomous reasoning loop into the infrastructure layer. You give us a goal. We execute the coordinated workflow of discovery, extraction, and verification to return a synthesized report backed by source citations.

The Drudgery of Scale

Most developers begin by wrapping a basic scraper in a loop, but they quickly hit an infrastructure wall. Scaling a research task does not just increase your bandwidth requirements. It multiplies your orchestration complexity.

When an agent tackles a non-trivial query, it rarely performs a single lookup. It spawns a fan-out of parallel sub-queries. In this scenario, "ten blue links" quickly explode into 100 unvetted URLs.

Processing this volume in production requires you to solve three high-stakes problems:

1. The Concurrency Bottleneck: Running 100 parallel headless sessions to handle modern, JS-heavy sites requires massive compute overhead. Managing the memory leaks, zombie processes, and proxy rotation needed to avoid rate limits turns into a full-time DevOps job.
2. The Token Tax: Consumption is not comprehension. Shoveling 50,000 tokens of raw HTML boilerplate into your model is a recipe for high latency and "lost in the middle" reasoning errors. Without a pre-processing layer, you are paying to process navigation menus and footer links instead of actual data.
3. The Resolution Logic: You are forced to build custom logic to reconcile conflicting data points across different domains. You end up spending more time on data cleaning and deduplication than on your core agent logic.

The result is a fragile pipeline where engineering cycles are wasted managing a browser fleet instead of refining the product.

An Adaptive Research Loop

We built Tabstack Research to move this orchestration logic out of your application and into our specialized browsing layer. When you send us a request, we initiate a multi-phase agentic loop designed to mimic the recursive nature of human research at machine speed.

By offloading the "discovery and verification" cycle to our infrastructure, you avoid the complexity of building custom state machines to handle search branching and error correction.

Behind the scenes, the system executes a coordinated workflow that treats research as an iterative process rather than a linear fetch:

• Planning and Decomposition: The system mimics a researcher's initial "mental map" by breaking your goal into targeted sub-questions. It identifies that a true comparison requires hitting distinct data silos: official documentation, enterprise pricing tables, and compliance whitepapers.
• Parallel Execution: We visit these sites in parallel using our core browsing infrastructure. We perform real-time content extraction, filtering out the DOM noise and marketing fluff that typically bloat a context window.
• Gap Evaluation: This is the recursive heart of the system. The system evaluates the collected data against the original intent. If it identifies a missing variable or a conflicting date, it detects the gap and triggers a new iteration to hunt down that specific information.
• Verification and Termination: The loop concludes when the system determines the claims are sufficiently verified against the source text or when it reaches the iteration limit for the selected mode. For example, while the system stops early if it has all the required information, Balanced Mode allows for up to three rounds of recursive discovery to ensure the final output is grounded in retrieved evidence rather than model weights.

Anatomy of a Request

To see how this works in production, consider a complex research task: "Compare enterprise data retention policies for Slack vs. Microsoft Teams."

import os from tabstack import Tabstack

# Initialize the client
tabs = Tabstack(api_key=os.getenv('TABSTACK_API_KEY'))

# Ask a research question
result = await tabs.agent.research(
    query="Compare enterprise data retention policies for Slack vs. Microsoft Teams.",
    mode="balanced",
)

print(result)

If you pass this query to a standard LLM or a basic search-based agent, you will likely get generic advice or a surface-level summary of the marketing pages. Here is how the Tabstack Research loop executes it:

The Planning Phase

The system deconstructs the high-level prompt into a series of technical primitives. It identifies that "retention" is not a single value. It generates sub-queries for "Teams Purview chat retention," "Slack Enterprise Grid file storage limits," and "M365 E5 compliance overrides."

The Discovery Phase

It executes these searches in parallel. It prioritizes official documentation like learn.microsoft.com and slack.com. Critically, our browsing layer ignores the SEO-optimized "Top 10" blog posts from 2023 that no longer reflect the 2026 pricing and policy landscape.

The Recursive Pivot

During extraction, the system hits a common stumbling block. Initial results for Teams mention a 30-day default retention. However, our evaluation step detects a critical gap: Files shared in Teams are actually stored in SharePoint and OneDrive, which often have conflicting retention policies. A standard agent would miss this nuance. Tabstack Research detects the ambiguity and triggers a targeted, second-pass search to clarify the "Conflict Resolution" logic between these interdependent Microsoft services. The engine identifies that while messages appear in Teams, the actual preservation happens in a hidden “SubstrateHolds” folder within the “Exchange Recoverable Items” folder. This is a nuance that dictates how legal holds are actually applied and accessed.

The Verification Phase

The final report is compiled with specific, time-sensitive data points that are verified against the source text to mitigate the risk of model hallucinations:

• Service Interdependence: It clarifies that while Teams manages the message metadata, SharePoint manages the physical file retention.
• Price Adjustments: It catches upcoming M365 price increases scheduled for July 1, 2026 (e.g., E3 moving from $36 to $39).
• Infrastructure Transitions: It identifies technical shifts scheduled for late 2025 and 2026, such as Slack implementing a two-year rolling retention policy for audit logs and Teams migrating private channel messages to group mailboxes.
• Retention Granularity: It identifies that Slack offers channel-level control, whereas Microsoft favors a centralized "longest-period-wins" logic.

Every single claim is returned with an inline citation and a direct link to the specific documentation used for the extraction.

Verifiable Claims

The output is not a block of prose. It is a structured synthesis designed for downstream application consumption. We prioritize high-fidelity data over general summaries.

A Note on AI-Generated Research

LLMs can be remarkably confident even when they are incorrect. While Tabstack Research is built to minimize errors through recursive browsing and cross-referencing, no automated system is perfect. This is why we provide thorough, inline citations for every claim. We believe the value of an AI agent is not in replacing human judgment, but in providing the clear, sourced evidence required for you to make an informed decision.

Grounded Attribution

In an era of black box AI, we have moved the burden of proof from the model to the evidence. Every claim in a Tabstack Research report is backed by an inline citation. If the system reports that Slack Enterprise Grid requires a custom quote for the Discovery API, it provides the specific URL and the text fragment used to verify that fact. This allows your application to provide "click to verify" functionality for your end users.

Conflict Resolution

The system does not just aggregate data. It reconciles it. The loop often encounters conflicting information. For example, one source may claim Slack retention is limited to 90 days while another cites indefinite storage for paid tiers. The system resolves this by verifying the context, such as Free tier visibility limits versus Enterprise Grid storage policies. The result is a reconciled data point that prioritizes the most authoritative source.

Structured Data Primitives

Because we strip the DOM noise and marketing boilerplate during the execution phase, the final synthesis is high-density. You receive clean and actionable data points:

• Logic Mapping: You learn that Slack offers granular channel level control while Microsoft favors a centralized "longest period wins" conflict logic.
• Temporal Accuracy: You get specific price points like Slack’s ~$15 to $45 per user per month (custom pricing) versus Microsoft 365's $36 for E3 and $60 for E5 list price, which accounts for upcoming 2026 shifts.
• Infrastructure Insights: You receive technical specifics that impact compliance. This includes the fact that Teams video clips and embedded images are retained, but code snippets and voice memos are often excluded from standard retention policies.

By the time the data reaches your application, the heavy lifting of discovery and extraction is complete. You are left with a verified asset that is ready to be stored in a database or presented in a UI.

Continuum of Execution: Choosing Your Speed

Research is not a one-size-fits-all operation. Different use cases require different levels of recursion and computational depth. We offer two primary modes to help you manage the balance between latency and comprehensiveness.

• Fast Mode: This is optimized for instant answers and populating UI tooltips. It uses lightweight fetches and high-priority search excerpts to return an answer in 10 to 30 seconds. It is ideal for "what is" questions where the answer is likely available in the primary search result or a single documentation page.
• Balanced Mode: This triggers our full agentic loop. The system visits, renders, and analyzes pages deeply. It performs the multi-pass gap evaluation we described earlier. Typically delivering a comprehensive report in 1 to 2 minutes, this mode is designed for complex comparisons and multi-source verification.

Built for Trust

In an era of opaque AI, we have taken a different path. As part of the Mozilla ecosystem, Tabstack is built on a foundation of privacy and responsibility. This is not just a marketing claim. It is a technical constraint on how we handle your data.

• Zero Training: We do not train AI models on your research queries or the data we collect for you. Your intellectual property remains yours.
• Ephemeral by Design: Your research data is treated as ephemeral. It is used to execute the specific task and is then discarded from our active processing memory.
• Full Verifiability: By providing full citations and source metadata, we move the burden of proof from the model to the evidence. This allows you to build applications where the AI can be audited in real time.

What You Can Finally Ask

When you stop worrying about how to get the data, you can finally focus on asking the right questions. By moving the orchestration of web browsing into the infrastructure layer, the scope of what your agents can accomplish expands significantly.

You can build agents that handle:

• Competitive Intelligence: Compare enterprise pricing and data retention policies for Slack versus Teams.
• Regulatory Compliance: Extract mandatory data residency requirements for healthcare SaaS in the European Union.
• Due Diligence: Identify strategic supply chain risks in the latest 10-K filings from NVIDIA.
• Strategic Analysis: Summarize the major commercial partnerships announced by Salesforce in the last year.

We take care of the hard parts. We handle the browsing, the parsing, and the noise reduction so you can focus on the reasoning that makes your agent unique.

Ready to build? Sign up to get started and receive 50,000 free credits per month or explore the technical implementation in our documentation.