Ask a research question. Scout does the work.

Scout is the autonomous research agent inside Sigmatic Sciences, Sapio's agentic platform for life-sciences R&D. You give it an open-ended research question; it figures out the plan, selects and wires together the right validated pipelines and specialized tools, runs them, checks its own work, and returns an answer you can trace back to the underlying data.

Think of it less like a chatbot and more like a tireless research associate who can run an entire informatics workflow on their own — across both biology and chemistry. That spans target validation, druggability, clinical precedent, and off-target profiling on the biology side, and active design work on the chemistry side: generating de novo molecules, hit discovery and expansion, scaffold hopping, and antibody developability.

Type your research question. That's the whole job. No code, no choosing tools, no wiring pipelines together, no formatting data. Scout handles all of that for you.

Your entire time investment is the minute or two it takes to phrase a good question. Once you hit go, you can walk away — Scout keeps working in the background.

Anything that maps onto real drug-discovery research. A few examples to give you the shape of it:

• "How strong is the genetic and clinical evidence for target X in indication Y?"
• "Is target X druggable with a small molecule, and what does the precedent look like?"
• "Find and rank novel hit candidates for the binding pocket in this structure."
• "Expand this hit series and flag the likely off-target liabilities."
• "Assess the developability risks for this antibody sequence."

Open-ended and multi-step is exactly where Scout shines. You don't need to break the problem down — that's its job.

No. Describe the science you want, not the machinery. Scout reads your intent and selects the appropriate validated pipeline or assembles tools itself. If you happen to know exactly which workflow you want, you can name it — but you never have to.

Yes. Alongside your question you can attach files for Scout to work from — including scientific formats like SMILES, SDF, PDB, mmCIF, and FASTA, as well as documents such as PDFs. So you can hand Scout your own structures, sequences, or compound sets and have it build on them directly.

When Scout finishes, it produces a research report in a new tab. That report is your starting point: read it first to understand the outcome. From there you can review the pipelines and the chat to drill into exactly what happened and why Scout made the choices it did.

It varies a lot — from a few minutes for a literature or evidence question, to considerably longer for compute-heavy work like generating de novo molecules, structure prediction, docking, or generative design. Scout is running real computational chemistry and biology — actually building and scoring molecules and structures, not just answering from memory — so some steps genuinely take time to compute.

The good news: you don't have to sit and watch. Start a run, go do something else, and come back to the result. The cost to you is the sentence you typed — the wall-clock time is Scout's.

A real research question decomposes into many smaller tasks — gather data from several sources, reconcile it, run a model, check the output, adapt the plan, run the next thing. Scout works through that chain one step at a time, the way a careful scientist would. A long list of steps is a sign it's doing the work thoroughly, not a sign something's wrong.

Sometimes, yes. When Scout identifies more than one reasonable way to proceed, it may poll you for your preferred approach rather than just picking one. You'll see the question in the chat — and if you're not watching the run, you'll also get an email notification so you can weigh in and keep things moving.

No — and we'd rather tell you that up front. Most of the time Scout is impressively on target, but occasionally a result will be off: a value computed a little wrong, a step that took a coarse approximation, a retrieval that missed a relevant paper, or an edge case the tools don't handle perfectly.

The right mental model is a brilliant, fast, tireless research associate — not an oracle. Use Scout to cover enormous ground quickly, then apply your own judgment to the handful of numbers or conclusions you're about to bet a program on. The full audit trail (see below) exists precisely so you can check.

Yes — quickly. We already know how to make Scout substantially smarter about the science, and we're iterating fast. The "the science is occasionally off" caveat above is a snapshot of today, not a fixed ceiling: our explicit goal is to make Scout the best drug-discovery researcher possible, and it improves on a short cycle.

Practically, that's a reason to build the habit of reaching for Scout now — the workflow you learn today only gets more capable underneath you.

It helps to picture a Scout run as a sequence of mini pipeline runs we call turns. Scout takes your question, looks at the available pool of agents and pipelines, and decides what to run in turn one. It then analyzes the output of turn one and decides what to do in turn two — and onward.

At every turn, Scout has access to the full history of all prior turns, so each decision builds on everything it has already learned in the run. That's what lets it adapt: chase a promising lead, abandon a dead end, or change approach based on what the last turn returned.

Yes — and it's one of the best ways to get great results. Scout shares its thinking in the chat dialog throughout the entire run, so you can follow its reasoning turn by turn.

If you see it drifting off track, or you simply want it to explore a new direction, you can queue up a response. Scout picks up your guidance and folds it into its next turn — so you're collaborating with it as it works, not just waiting for the end.

Absolutely — a finished run isn't a dead end. When Scout wraps up, it asks how it did. Acknowledge that closing question first, then send another prompt telling it to continue, with instructions on what you'd like it to explore next.

Because Scout still carries the full history of the run, it picks up right where it left off and keeps building — no need to re-establish context. You can extend a single line of research across many follow-ups this way.

Yes, at any point. Between stopping, steering mid-run, and continuing after a finish, you have a lot of control. And since your only real investment is the prompt, refining your question and re-running is always a cheap, reliable fallback.

Because the payoff is wildly asymmetric. Your cost is one sentence and some background compute time. The downside of a miss is small — a few minutes spent reading a result that didn't land. But the upside of a hit is enormous.

When Scout nails a research question, that single answer often represents work that would otherwise take a team of specialists days, weeks, or months — pulling data from a dozen sources, writing and debugging analysis code, running models, and reconciling it all. You got it for the price of typing a question.

So even if only a fraction of your runs produce a great answer, you're still far ahead. A "1-in-10" hit rate sounds modest until you remember that the one hit replaced weeks of multi-person effort, and the nine misses cost you almost nothing. Run Scout liberally. Cheap misses, occasional outsized wins — that math works strongly in your favor.

Use it as a fast, broad first pass for almost any research question you'd otherwise queue up for a person or a multi-day analysis. Fire off questions early and often; let the cheap, fast breadth do the legwork, and reserve your expert time for verifying and acting on the wins.

A red box marks an individual step or tool that errored or failed during a run. It's Scout being transparent about its work — including the parts that didn't go cleanly.

Here's the key thing to internalize: a red box is not the same as a failed run. Individual steps fail for all sorts of ordinary reasons — a data source returned nothing, a file came back in an unexpected format, an external API hiccupped, or a particular tool wasn't the right fit for that input. None of those necessarily sink the answer.

Usually not. Scout is built to notice a failed step and route around it — try a different tool, pull from a different source, reshape the data, or take an alternate path to the same goal. A run can light up with several red boxes along the way and still arrive at a perfectly good final answer, because Scout recovered each time.

Think of red boxes as a visible log of attempts and dead ends — the scientist showing their work — rather than as alarms that something has gone irreversibly wrong.

Pay attention when:

• The run ends without a usable answer, or
• The final conclusion clearly depends on a step that stayed red and was never recovered.

In those cases, the simplest fix is almost always to rephrase and re-run — often with a bit more specificity (a structure ID, a clearer objective, a named constraint). If a particular question keeps failing in the same place, that's worth flagging to your team.

Sigmatic Sciences packages drug-discovery informatics as a catalog of specialized agents and a library of pre-built, validated pipelines. When you ask a question, Scout reads your intent, selects the right agents and pipelines, wires in anything extra it needs, runs them in order, and reconciles the outputs into a single answer. Because the building blocks are already validated, Scout focuses on the science of your question instead of reinventing the plumbing each time.

The catalog spans the full arc of a discovery project. Broadly:

• Retrieval & knowledge agents — pull from genetics, genomics, expression, structural, chemical, bioactivity, clinical-trial, and literature sources.
• Structure agents — work with molecular structures of both kinds: small-molecule (ligand) structures and macromolecular (protein) structures. They retrieve experimental structures, predict structures, and detect binding pockets.
• Docking & simulation agents — dock ligands, score poses, and evaluate binding.
• Generative chemistry agents — design de novo molecules, hop scaffolds, and build or optimize linkers and analogs.
• Property & filtering agents — compute physicochemical / ADMET-style properties, druggability, and off-target / selectivity risk.
• Biologics agents — assess antibody developability and design binders.
• Analysis agents — digest large evidence corpora into structured reasoning and summaries.

Scout mixes and matches these per question — a literature ask might touch two or three; a full design campaign, a dozen or more.

Both. Scout can call a single agent for a focused task, or invoke a powerful pre-built, multi-agent pipeline when the job calls for it. These pipelines encode drug-discovery best practices — proven, validated ways of going about a common problem.

For example, a pipeline might capture the established workflow for finding new ligands that bind the same pocket as a known drug: start from the existing drug and its bound structure, characterize the pocket, generate and dock candidate molecules, score and filter them, and rank what's worth pursuing. Sigmatic scientists build and validate these so neither you nor Scout has to reinvent the steps each time.

Every agent in the standard Scout catalog is open source — chosen deliberately so the same pipelines run for any customer, with no licensing barrier in the way.

We also work with commercial partners. On the Enterprise plan you can swap a commercial solution in for the open-source default on a given step — for example Schrödinger (Glide), OpenEye, Cadence, and Elsevier, among others. You get the universal open-source baseline out of the box, with the option to plug in the commercial tools your organization already trusts.

Evidence Synthesis is the way Scout writes your final report. When a run finishes, Scout looks back across every step it took — and the evidence each one produced — and reasons over all of it together, weighed against your original research question.

So your report reflects the whole run as one body of evidence, rather than a summary of whatever step happened to run last.

Reasoning over the whole run rather than the last step prevents two failure modes that quietly erode trust in a report:

• Findings from earlier in the run are properly weighed — they don't get lost behind whatever happened most recently.
• A step that failed for a purely technical reason — an external database timing out, say — is not mistaken for a real scientific result ("no pathways found"), which would be the exact opposite of the truth.

The result is a more trustworthy report, a meaningfully lower risk of that kind of false negative, and a clear evidence trail behind every conclusion.

Yes. Evidence Synthesis is built around a few guarantees you can count on:

• Exact figures are preserved. Counts, identifiers, and scores appear in the report exactly as the tools produced them — nothing is rounded off or invented.
• Failure is told apart from finding. A technical or tool failure is flagged as such, never dressed up as a scientific negative.
• It works at any run size. Whether a run has a handful of steps or a great many, the report still accounts for all of the evidence.
• Every conclusion is traceable. You can follow any statement in the report back to the step and data it rests on.

Evidence Synthesis works within a single run. Ensemble Analysis works across several. Because Scout is autonomous, any one run can be thrown off by bad luck — a flaky data source, an unlucky path through the problem, the occasional wrong turn. Running the same question several independent times and seeing what holds up is a strong guard against that.

Ensemble Analysis takes those independent runs and reports the consensus across them: how often each target, mechanism, or conclusion independently recurs. A finding that shows up in nearly every run is a robust signal you can lean on; one that appears in only a single run is a lead worth checking, not a result to bet on.

Reproducibility. A conclusion that recurs across many independent runs is far more trustworthy than any single run's output — it's the practical answer to "the science is occasionally off." Single-run noise, an unlucky miss, or an occasional hallucination tends to wash out across the ensemble, while the real signal keeps reappearing.

It also handles the odd failed or empty run gracefully — those are simply averaged over rather than skewing the picture. When a question really matters, Ensemble Analysis turns agreement across runs into confidence.

Because Scout is built to be auditable end to end. You can click any agent in a run and see exactly what it produced — its actual output, whether that's structured data (tables, scores, structures, properties) or unstructured text. Nothing important is a black box you have to take on faith.

Beyond individual steps, we maintain full audit trails for every Scout run and every pipeline execution, so any result can be traced from the final conclusion all the way back to the primary data it rests on. That traceability is the real answer to "the science is occasionally off": when a result matters, you don't trust it blindly — you open the trail and verify the specific number or claim you care about.

Scout is designed to ground its work in real data and real tool outputs rather than inventing results, and it has guardrails aimed at catching fabricated values, sources, or identifiers. That said, no system is perfect — so the honest guidance is the same as everywhere else on this page: for anything load-bearing, verify against the cited source before you act on it. The audit trail makes that quick.

Treat it as high-quality decision support: a fast, broad, well-sourced first pass that gets you most of the way and shows its reasoning. Then add the one thing only you can add — expert judgment on the few conclusions that will actually drive a decision. Scout supplies the speed and breadth; you supply the final call.

On the free plan we do capture data about your Scout runs — but we're deliberate about what it's for. To be clear:

• We do not use any of it to train Scout's models.
• It's used only to understand the kinds of questions people are asking, gauge how Scout is performing, and surface failures so we can fix them.
• None of it is shared outside Sigmatic.

In short: the data helps us improve Scout, faster — it never leaves Sigmatic and never trains the models.

Yes — use the Invite button and enter their email addresses. That ensures they sign up inside your instance of Scout, where work lives together.

This matters more than it sounds. If you simply tell someone about Scout and they sign up on their own, they get their own separate tenant. That data stays separate from yours — it can't be shared, and it cannot be merged later, even if either of you upgrades to Professional or Enterprise. So whenever you want a colleague in the same workspace, bring them in with the Invite button rather than word of mouth.

Usage is metered in credits, consumed both by the agents Scout runs and by Scout's own reasoning. The amount varies with the work:

• What an agent does — a GPU-heavy agent (structure prediction, docking, generative design) costs far more than a light CPU agent like a quick property calculation or a database lookup.
• How much you give it — an agent asked to process many inputs consumes more than one processing only a few.
• Scout's own thinking — it isn't only the agents. Scout makes numerous LLM calls to plan each turn, analyze results, and decide what to do next, and those consume credits too.

So the size and shape of your question directly affect how many credits a run uses.

We give you visibility into it. From the home page, open the credit usage view to see how much you've consumed and where the credits are going. It's the quickest way to spot which runs or steps are heaviest and to plan around your daily limit.

The free plan gives you one month free plus a daily credit limit. That's plenty for exploring the system, learning how to ask good questions, and running real research — just at a metered daily pace.

On the Free and Professional plans, you run one Scout at a time — kick off your next run once the current one pauses or finishes. Enterprise removes that limit, so your team can run many investigations in parallel.

Most likely it reached your daily credit limit. When that happens the run pauses mid-stream rather than failing — and it resumes automatically the next day, after midnight US Eastern (ET), when the daily credit counter resets for everyone. A genuinely compute-heavy run can legitimately span several days this way on the free plan.

Yes. If you feed in too much at once, a run can exceed any single day's limit and never start or resume. The classic example: docking 10,000 ligands against a protein — that would tie up a full GPU for days and blow past any daily credit budget, so it simply won't go through.

The fix is to scope inputs to a sensible size: dock a focused, prioritized set rather than an entire library, and let Scout iterate. Smaller, well-aimed runs finish, stay within your limits, and are usually better science anyway.

You don't need to be elaborate, but a little specificity goes a long way:

• Name the entities precisely — the target, molecule, disease, or sequence you mean. Use an identifier (gene symbol, PDB ID, SMILES) when you have one.
• State the decision behind the question — "is this worth a screening campaign?" tells Scout what kind of answer is useful.
• Mention real constraints — modality, must-avoid liabilities, a particular pocket or chain.
• Keep one clear objective per run — if you have three questions, three focused runs usually beat one sprawling one.

• Run early, run often. Misses are cheap in time and effort; treat Scout as your default first move on a hard question.
• Right-size your inputs. Aim a run at a focused, prioritized set rather than an entire library — it fits your credit budget, finishes, and is usually better science.
• Let it finish. Long runs are usually thorough runs — don't kill them prematurely. If one pauses, it'll resume when your daily credits reset.
• Read past the red boxes. Check whether Scout recovered before assuming a failure.
• Refine and re-run instead of fighting a single run — iteration is the cheapest tool you have.
• Verify the wins. When an answer matters, click into the agents and open the audit trail to confirm the load-bearing numbers.

If a question reliably fails to produce any answer, or a result looks clearly wrong against a source you trust, flag it to your Sigmatic Sciences / Sapio team. The audit trail makes these reports especially useful — sharing the run lets the team see exactly where things went sideways. For data-governance and privacy specifics in your environment, check with your Sapio administrator.