Changelog

If you work in Cursor, Claude Code, Codex, or another agent, you no longer have to bounce over to the Webhound app to run research. Webhound now ships as a first-party MCP server, so your agent can drive it as a set of tools mid-task and hand you back cited results.

The tools are shaped around how an agent actually works. Recall answers straight from research your org has already run — claims, datasets, saved knowledge — for free and with citations, so the agent checks what you already know before spending anything. Consult starts a fresh budget-capped report or dataset when the answer isn't on hand and waits for it. Check returns a quick snapshot of any run in progress, and Ask does cheap follow-up Q&A over a single finished session.

New accounts start with $5 in credits, and an included free run means an agent's first real report can cost nothing. Retries are safe — an idempotency key means a repeated call never double-charges — and status is honest: if a run halts because credits ran out, the agent is told, instead of seeing a silent "completed."

How: open MCP in the app (or the public setup page) and pick Local agents (Cursor / Claude Code / Codex) or Web agents (Manus and other hosted MCP apps). Click Generate key, copy the setup prompt into your agent, and hit Test to confirm it connects. Hound is the research harness behind each run — built with DeepSeek V4 Pro and GPT-5.4, not a selectable model, mode, or single-provider resolver. Defaults lets you set the budget, product, and included-run behavior.

Contractor (our budget-governed supervisor for coding agents) routes through your agent subscriptions first. When it needs paid model usage, it can now bill your existing Webhound credit balance at exactly what the model costs, instead of asking you to paste an OpenRouter API key.

How: start sign-in from the Contractor app (Settings → Contractor Cloud → Sign in) or with `contractor cloud login`; your browser opens webhound.ai/activate, where you confirm the code shown in the app with the Connect device button. Top-ups and auto-recharge work from the existing Billing page.

A Stack is a bundle of long-form research reports built with experts in the field. One purchase, one intake form, one autonomous run. The reports are sequenced so each one builds on the previous, and every prompt is tuned for the specific use case.

First stack: the Founder Stack. Ten reports answering the ten questions every founder gets pressed on — market, why now, first customer, voice of customer, substitutes, competitors, future, wedge, winning scenario, downside. Every report is a standalone document with cited sources, ~15 hours of autonomous research end-to-end.

How: open it from the link below. The run shows up as a single Stack row in your sidebar with an ETA; click Share at the top of the run page to publish a public link, and Download to grab every report as a single ZIP — Markdown, Word, plain text, HTML, or JSON + traces, with or without the agent's working notes. The Download button works on shared stack pages too.

Long Webhound runs used to be one-way. You set a budget, Webhound spent it however it decided to, and the only way to keep the run on track was to watch it and message it in real time. That works if you can sit at the screen for an hour. Most of the time you can't.

Now you can tell it to do something first, then check in with you, and decide together what's next. A check-in is a moment you describe in your own words — after the literature map is drafted, once the shortlist of 20 candidates is ready, before the bulk pull starts — that Webhound pauses on. The agent watches for each registered moment at the end of every research cycle; when one arrives, it stops, sends you a short summary of what it found and a specific question, and waits for your reply in chat.

The session shows up as Reply needed in the sidebar. If you've verified your phone you also get a text, and email-completion subscribers get an email, so you don't need to keep the tab open. Some check-in messages include clickable chips for the working documents the agent thinks you should review before replying — one tap jumps straight to the document.

Replying picks the run back up. The chat agent sees the same working documents as the planner, so when you say to focus the rest on rate limits it understands what the rest means, updates the plan, and the run resumes in that direction. After a check-in, the chat agent will often propose the next pause point as a single follow-up question — answer yes and it gets added to the plan, no and the run goes through to the end.

How: in plan mode, the chat agent proposes a check-in as one of its clarifying questions for any non-trivial brief. In one-shot mode, mention the check-in moment in your prompt — say something like first figure out whether X then come back to me — and it registers on the first cycle. Active check-ins show on the Plan tab right under Research scope; the agent decides at runtime when each one fires.

The old default was $2 in starting credits and a $5 report budget that couldn't actually start because Pro reports require $10. New users hit the paywall before they'd ever seen the product produce anything, which is the worst possible first experience.

Now signup grants $5 in credits and the composer pre-fills with a $5 Flash report — a real run that produces real output without ever leaving the home page. Flash floors are $1 for reports and datasets so quick scans are approachable. Pro is aligned at $10 across both reports and datasets, with deep read at $25.

If your balance is under $10 and auto-recharge is off, the model dropdown locks explicit Pro behind an Add credits affordance instead of letting you start a session you can't afford and failing silently. Auto uses Flash, so the default $5 report remains runnable on the signup grant.

When something does block the send — budget below the floor, balance under what the run needs — Webhound now shows an inline message above the composer with a one-click action to fix it, instead of the old browser alert popup that disappeared on dismiss.

How: the composer's model dropdown shows Add credits next to any locked option; click it to jump to billing. The budget pill always reflects the floor for the current model and product, and you can switch to Flash to keep going on free credits.

Long-running sessions are easy to forget about. There is now a phone-number opt-in that sits next to the existing email completion notification. Verify a number once with a six-digit code and Webhound texts you when a report finishes assembling, when a dataset extraction wraps, or when a session needs your attention because your account ran out of credits.

Each text uses the actual session title and a short link straight to the session page. The first message after verification doubles as a saveable contact card so the sender shows up as Webhound on every text after that, not as a random unknown number.

Reply STOP at any time to suppress every future text. You can also remove the phone number, or keep it on file but mute completion texts, from Account preferences without losing your verification.

How: a "Get a text when your research is ready?" modal appears on the home page after the welcome tour. It is also reachable any time at Account → Preferences → Dataset completion texts, where you can add, remove, or stop the number.

Plan mode used to ask a couple of clarifying questions and start. The actual plan — scope of investigation, what the final deliverable should look like, the stages a report would work in — was set on the agent's first cycle, after you'd already clicked Start. You could see it in the Plan tab once research was running, but you couldn't shape it.

Now the Plan tab in any report or dataset session has a single card called "What we're producing for you" that names the goal, the scope, what the deliverable should look like, and any constraints. For reports, if the work splits into stages, the agent commits a phase plan you can see right there. For datasets, the schema (the columns the agent will fill) stays its own thing on the Schema tab, where you still review and approve it.

After research starts, every change to the plan — yours via a follow-up message, or the agent's in response to one — is captured under an Earlier versions section with the spend at the moment each version was superseded. Send a message like "drop the third phase and rebalance" or "actually limit it to companies founded after 2023" and the plan rewrites itself for the remaining budget; you can scroll back and see what changed and when.

The chat agent is also less chatty. Instead of reciting the plan to you in conversation and waiting for a "yes", it proposes the plan as an Approve / Reject card in chat with every field visible inline. For reports it goes straight to work after you approve. For datasets you approve the plan, then the schema, then Start — three explicit clicks, no surprises.

How: open the Plan tab in any session. In plan mode, talk through the brief in chat — the agent proposes the plan as a card you approve. Once research is running, send a message in the chat panel and the plan rewrites itself for the remaining budget.

If you point a coding agent at the Webhound API without context, it picks a random model, undersizes the budget, polls forever, and never notices when a session silently halts because the account ran out of credits. None of that is hard to fix once the agent knows the rules — but the rules weren't written down anywhere it could read.

Now they are. SKILL.md is an agent guide we maintain ourselves: how to choose between Flash and Pro per session type, the actual budget floors, how to use context_session_ids for follow-up runs, every status value the polling endpoint returns, the new 402 response when the account can't cover the requested budget, and the credit_exhaustion message-content marker to look for when "completed" might mean "halted under budget."

Three ways to grab it from the API page. Copy for LLM agents pastes both the skill and the endpoint reference into your clipboard — recommended when you're feeding context to an LLM in one shot. Copy API reference only gives you just the spec. Download SKILL.md saves the file with frontmatter so it drops straight into Cursor's .cursor/skills/webhound/ or any other agent skill registry.

How: open the API page in the top nav. The agent skill banner at the top of the page has Download SKILL.md and Copy skill + reference right there — the two options most agents will want. The Get the docs menu in the top right also includes Copy API reference only for cases where the agent already has the skill loaded.

A few months ago we made the home page a chat with an agent. The bet was that some people would want a copilot to plan a run, ask clarifying questions, and chase follow-ups in conversation.

In practice it was friction. For people who already knew what they wanted to research, the chat sat between them and the run. Several of you told us the original direct composer was faster and you missed it.

So today the home page is a composer again. Click the Output pill (Report, Dataset, Chain, or Ask), type the brief, set a budget, hit Send. Mode, model, Deep read, and budget are pill controls under the textarea — same controls as before, just always visible instead of hidden behind a chat.

The agent isn't gone. It still runs every session as Planner → Executor → Verifier. It still asks Plan-mode questions when you opt into Plan. It still drafts chain steps inside the chain builder. We just stopped putting it in front of the start of every run.

How: same as it always was. Pick what to make, type, send. Carry on.

Equations are stored as katex-source spans with raw TeX inside so the report reader can render them with KaTeX.

For a known DOI, the agent can run an Unpaywall lookup and work from structured JSON instead of guessing from search snippets alone.

How: start a research session as usual; the executor uses these when your brief calls for math or citable papers.

When you start a session, the budget you enter has to clear a minimum that depends on the model. Pro is built for thorough work that needs more room to breathe; Flash is for quick, cheap runs.

How: in the budget field on a new session, the minimum updates as you switch between Flash and Pro. If you want the cheapest possible run, pick Flash; if you want the most thorough run, pick Pro.

Before, you had to trust the output. Now you can trace any single claim down to the raw work behind it.

Click a claim pill in a report (or the small icon next to a dataset cell) and a popover opens with the evidence (the verbatim passage from the source), the method (which search → which page → which section), the sources, and the confidence level.

From there, click "View tool chain →" in the top-right of the popover. A modal opens with each tool call rendered in full — searches show the query and the results, page visits show the URL and content, code runs show the source and the output.

This works the same in your own workspace, in published reports anyone reads anonymously, and in copies of those publications.

You don't have to wait for a session to finish to course-correct. While it's running, open the Activity tab and send a message ("focus more on pricing", "skip the historical context"). The executor stops, in-flight tasks are cancelled, and the planner re-plans with your guidance — anything already written is preserved.

Every time the assembler builds the final output, that assembly is saved as a version. A version timeline at the bottom of the document lets you browse and switch between past versions of the same report.

Webhound has dedicated scrapers for 14 platforms now: Google Maps, Amazon, Zillow, Indeed, TripAdvisor, eBay, Yelp, Telegram, Crunchbase, Airbnb, Pinterest, PitchBook, Google Flights, and Expedia Hotels. Several support direct search ("search Indeed for X", "search PitchBook for investors matching Y"). LinkedIn profile visits also now return the full data (education, work history, featured content) instead of just four fields.

Plus: the planner now creates 3-5 substantial tasks per cycle instead of one tiny one, the executor can grep over pages it already visited (useful for verifying a specific stat), and inline source indicators are now a single confidence-colored pill with the source hostname rather than a number plus a colored dot.

How: open the Activity tab on a running session and chat. The version timeline is at the bottom of any output document. Platform scrapers are picked automatically when relevant.

Recents is a new filter at the top of the workspace tree (next to All / Reports / Datasets). It shows your sessions in order of when you last touched them — running sessions float to the top.

On the agent side: when you upload a long file (a big PDF, a long document) the agent can now keep reading further into it during research, instead of being stuck on whatever fits in the first read.

How: in the workspace sidebar, click the Recents tab to switch out of the folder view. For long files, just attach as usual — the agent calls "Continue Reading File" when it needs more.

Code execution got way more powerful: combined with stored credentials, the agent can now write Python that calls real APIs you authenticate against. Ask it to "pull my Notion database X and add a row per company in this dataset", "upload this report to my Dropbox", "post the top 5 findings to our internal Slack webhook" — it writes the code, pulls your saved key, and runs it.

There are two ways to add a key. From chat: paste it in and tell the agent what it is ("here's my Notion token"); the agent saves it under a label of your choosing and remembers it across conversations. From the UI: open Settings → Account → Secrets to add, view, edit, or delete keys yourself.

Keys are stored per-user with row-level security (only you can read your own) and are only loaded when the agent explicitly fetches one to use in code.

How: in chat, paste a credential and tell the agent what to do with it. To manage keys directly, open Settings → Account and scroll to Secrets.

You can now share a session or a whole folder as a permanent published artifact at /p/{slug}. Pick one of four licenses: View Only, Attribution (copy into your workspace, no republishing the copy), Open (copy + republish under same license), and Open + Commercial.

When you find someone else's public publication that's relevant, click Copy to workspace and the whole thing — sessions, documents, datasets, sources — lands in a new folder in your workspace so you can keep researching from there. Lineage and attribution back to the original are tracked automatically.

Each republish creates a new immutable version (/p/{slug}/v/1, /v/2, …) with an update note. Authors get a profile page at /author/{id} with their publications and aggregate stats; you can follow authors and watch specific publications for updates.

Shared links unfurl with rich previews on Slack, X, etc. Sharing also works on mobile.

How: in any session or folder, click Share → Publish. Open Explore in the top header to browse public publications. On any public publication, click Copy to workspace.

Research runs now produce several working documents — one per topic cluster — and an assembled final output. The executor writes into the working docs; the assembler synthesizes them into the output you read. Switch between them from the Document tab.

Every factual statement in a report gets a structured trace recording the type of claim, the verbatim evidence, the research method, the confidence level, the importance to the argument, and which other claims it depends on. The Claims tab lists every traced claim with filters for type, confidence, importance, and document.

Inline citation numbers are generated automatically from the trace's source URLs — no more mismatched or duplicate citations.

New API endpoints: GET /research/:id/documents (all docs with stats), GET /research/:id/claims (every traced claim deduplicated), and a doc_type parameter on the existing document endpoint (output | working | all).

How: open the Document tab strip above any report to switch documents. Open the Claims tab to scan every traced claim with its sources.

Webhound can now string multiple sessions into a pipeline. Describe a sequence — for example, "research the best CRMs, then extract 30 of them with pricing, then write a buying recommendation" — and the agent proposes a plan with editable budgets per step. You approve before anything runs, and you can stop the pipeline at any point.

Sessions run in the background while you keep chatting. You're notified when each one finishes, and the agent summarizes what completed.

The agent can also read and analyze sessions you've already done, run Python over your actual datasets, and remember your research interests, budget preferences, and working patterns across conversations (Memories).

How: switch to Agent in the session-type selector under the prompt box. Set a working folder in the chat's top bar to scope the agent's context to one project. The agent runs while you keep chatting.

If you want to fold Webhound output into your own product, dashboard, or pipeline, v2 gives you structured access to documents, individual claims with traces, and the full publication lifecycle (POST /publications, copy, watch, attribution graph).

How: open the API Docs page from the app menu for the full v2 reference and auth setup.

Some questions are easier to answer with code than with searching — "what's the CAGR over these 10 years", "deduplicate this list of 800 companies", "plot revenue against headcount". Webhound now writes and executes Python during the run and drops the result (number, table, chart) into the document.

Works in reports, datasets, enrichment, and Ask mode. The agent picks code automatically when it's the right tool for that step — including running over your actual datasets, not made-up data.

Combined with the secrets feature added Apr 3, code execution is also how the agent calls external APIs you provide credentials for (Notion, Dropbox, your own services, etc.).

When something interesting shows up in an old session, you don't have to start over — you can hand that whole session to a new run as context. Try things like: "Take the section on pricing from this attached session and dig deeper into competitor pricing." Webhound reads what was already done and only re-searches what's actually new.

Three ways to attach a past session: drag it from the workspace sidebar onto the chat box, type @ in the chat box and pick it by name, or click + → Attach Sessions. Folders work the same way. You can also just describe what you want — "look at my last 5 sessions on competitor analysis" — and Webhound will find and read them itself.

Plan mode is now a back-and-forth conversation about scope before the run starts, instead of a list of yes/no questions. Discuss what to focus on, what to skip, then kick off when you're happy with the plan.

Research phases let you tell Webhound how to spend its budget across the run — e.g. "spend 90% searching broadly, then 10% deciding" — so it doesn't lock onto an answer early and spend the rest of the budget confirming it.

How: drag a session from the left workspace onto the chat box, or type @ to pick one. To use phases, just say how you want the time split in your prompt, or refine it in Plan mode.

Once a session is done, you don't have to start a new full run for one follow-up question. Switch to Ask and ask things like "give me a one-paragraph summary", "is the second recommendation on page 3 still valid?", or "how many rows have no email?" — Webhound answers from the existing document and only goes to the web if it actually needs to.

Mode names also changed: Guided is now Plan, One shot is now Agent. Behavior is the same; only the labels.

How: pick Ask from the mode dropdown (Plan | Agent | Ask) on any session you've already finished.

You and the friend you invite both get rewarded — $2 each on signup with your code, plus matching credits up to $50 when they buy their first credits.

How: open Settings → Referrals to grab your personal invite link.

No more monthly tiers, no more wasted seats. Top up credits when you want to and Webhound only charges what each run actually costs.

How: open Settings → Billing to add credits.