TL;DR: OpenScience is an Apache 2.0 AI research workbench from Synthetic Sciences that runs the full research loop — literature review, hypothesis, code, experiments, write-up — in a browser workspace on your own machine, with 309 bundled skills and 42 scientific database connectors. It installs with one npm command and talks to any OpenAI-compatible endpoint, so a local Ollama model works with zero paid API keys. Pick it over Claude Science if you need your data local and your models swappable; skip it if you just want polished chat over PDFs.

	OpenScience	Claude Science	DIY (Jupyter + Ollama)
Best for	Full research loop, self-hosted, model-agnostic	Best-in-class reasoning, zero setup	Total control, no framework
Price / Cost	Free (Apache 2.0) + your compute or API keys	Anthropic subscription	Free + your compute
License	Apache 2.0	Proprietary	MIT/Apache components
Database connectors	42 built in (UniProt, PDB, ChEMBL, arXiv…)	Anthropic-curated set	You write every integration
The catch	Agent quality capped by the model you plug in	Data leaves your machine, no local models	You rebuild skills OpenScience ships free

Honest take: OpenScience is the first self-hostable “AI scientist” that feels like a product instead of a research demo — install it, wire Ollama, and keep every prompt on your own hardware. Just don’t expect a 24GB-card local model to match a frontier model on multi-step research; for that, use your own API key and keep the workflow open anyway.

What OpenScience actually is

Synthetic Sciences released OpenScience in July 2026 as the open answer to Anthropic’s Claude Science, and it has moved fast since: as of this writing the repo at github.com/synthetic-sciences/openscience sits at ~3.4k stars and 459 forks, with v2.0.66 shipped on August 31, 2026 — three releases landed that day alone, which tells you the maintainers are iterating daily.

The pitch: you set a research goal, and an agent reads the relevant papers, forms a hypothesis, writes and runs code on your compute, queries scientific databases, and drafts the write-up. The pieces that make this more than a chatbot wrapper:

• 309 bundled skills — editable instruction packs covering model training (DeepSpeed, PEFT, TRL), evaluation, dataset work, molecular and clinical biology, cheminformatics, paper analysis, LaTeX, and figure generation. They’re plain files you can read and modify, not black-box behaviors.
• 42 database connectors — UniProt, PDB, Ensembl, ChEMBL, PubChem, arXiv, OpenAlex, and Semantic Scholar among them, wired in as tools the agent calls directly. The big public databases here are free-access; you don’t need institutional credentials to get value.
• Model-agnostic routing — requests go per-call to whatever provider you configure: ChatGPT/Codex subscriptions, your own API keys, or any OpenAI-compatible endpoint. That last option is the self-hosting story, because it means Ollama, vLLM, and llama.cpp’s server all work.

Architecture-wise it’s a TypeScript monorepo: a backend/CLI that runs the server, providers, and skills on your machine, and a browser frontend that connects to it. Your workspace lives locally. The footer is explicit that the project is not affiliated with or endorsed by Anthropic — compatibility framing only.

Install in two commands

Requirements are modest because the workbench itself is lightweight — the heavy lifting happens in whatever model backend you point it at. On Linux you need kernel 5.1+ and glibc 2.17+ (musl builds exist); macOS and Windows are supported. If you hack on the source, the repo wants Bun 1.3+.

npm install -g @synsci/openscience
openscience

Or skip the global install entirely:

npx synsci

The CLI starts the local server and hands you a workspace URL to open in your browser. From there, everything model-related lives under Customize → Models.

Wire it to Ollama for a zero-key setup

This is the configuration the aifoss audience cares about: no OpenAI key, no Anthropic key, nothing leaving your machine. OpenScience accepts any OpenAI-compatible base URL, and Ollama exposes exactly that at http://localhost:11434/v1.

First, pull a tool-calling model. This matters more than parameter count — the agent loop drives everything through tool calls, and a model that can’t emit them will sit there doing nothing useful:

ollama pull qwen3.6:35b-a3b
ollama ps
# NAME              SIZE     PROCESSOR    UNTIL
# qwen3.6:35b-a3b   ~22 GB   100% GPU     4 minutes from now

Then in Customize → Models, add a custom OpenAI-compatible provider:

• Base URL: http://localhost:11434/v1
• API key: ollama (Ollama ignores the value but the field can’t be empty)
• Model ID: the exact Ollama tag, e.g. qwen3.6:35b-a3b

Model picks by VRAM tier, based on what we’ve tested across this site: Qwen3.6-35B-A3B (Apache 2.0, ~22GB Q4_K_M) is the best agentic model that fits a 24GB card; Gemma 4 26B-A4B QAT (~15GB) is the 16GB-card pick; below 12GB, run Gemma 4 12B QAT and keep research tasks narrow.

The trap that breaks every local agent: context length

Here’s the problem you will actually hit, because we hit it with OpenCode, Goose, and Browser-Use before this: Ollama defaults to a small context window, and when an agentic workload stuffs system prompt + skills + tool schemas + paper text into the request, Ollama silently truncates from the top. The agent loses its own instructions mid-task and starts looping, “forgetting” the goal, or calling tools with empty arguments. Nothing errors. It just gets stupid.

The fix is one environment variable before you start the server:

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

Or bake it into the model with a Modelfile (PARAMETER num_ctx 32768). A research agent reading papers wants 32k as the floor. Budget the VRAM for it — KV cache at 32k on a 35B-A3B MoE eats several extra GB, which is another reason the 24GB tier is where local research agents start being pleasant.

The second trap: picking a model without tool-calling support. If the agent connects fine but never queries a database or writes a file, that’s almost always the model, not OpenScience. Stick to tags documented as tool-capable — the Qwen3.6 and Gemma 4 instruct families both are.

What the skills and connectors give you in practice

A “skill” in OpenScience is an editable instruction pack the agent loads for a task type — the same pattern coding agents adopted in 2025, applied to science. The training skills (DeepSpeed, PEFT, TRL) mean you can tell it “LoRA-tune this base model on this CSV” and it scaffolds the actual run on your GPU rather than hallucinating an outline. The biology and cheminformatics skills pair with the connectors: ask a protein question and it pulls from UniProt and PDB itself instead of citing from model memory — which is the difference between a research tool and a plausible-sounding liability.

Because skills are files, you can also fix them. If the LaTeX skill formats citations in a style your field doesn’t use, edit it. That’s the concrete meaning of “open by design” here, and it’s the thing Claude Science structurally can’t offer.

GPU-heavy skills are where local-only setups hit a wall: fine-tuning runs and big experiment sweeps want more than a single consumer card. The sane middle ground is renting — a RunPod A100 pod for the training step while the workbench and your data stay home. For a permanent local setup, a used RTX 3090 remains the value pick at 24GB, and an RTX 4090 buys you roughly double the throughput for both inference and PEFT runs. Our sister site runaihome.com keeps a current VRAM-to-model table if you’re speccing a box for this.

When NOT to use OpenScience

• You mostly want chat over your documents. AnythingLLM or Open WebUI do RAG-over-PDFs with far less surface area. OpenScience earns its complexity when you need the agent to run code and experiments, not just retrieve.
• You need frontier-model reasoning and can’t send data out. A local 35B model executes the loop but plans noticeably worse than the frontier models on multi-step research. If your data can’t leave and your questions are hard, the honest answer is that no current self-hosted setup fully replaces Claude Science quality — OpenScience narrows the gap and keeps you in the game.
• You want something settled. Three releases in one day is great velocity and also a moving target. Skills, UI, and config surfaces are still shifting; pin a version if you need reproducibility across a project.
• Regulated lab environments. It executes model-written code on your machine. Sandbox it (container, dedicated user, no credentials in reach) before pointing it at anything that matters — the same caution we covered for smolagents applies doubly to an agent that installs its own dependencies.

Verdict

OpenScience is the most complete self-hostable research agent available in 2026, and the license is genuinely clean — Apache 2.0, no revenue caps, no attribution clauses, the same tier as Qwen and Gemma 4 in our license shootout. Install takes two commands, the Ollama path costs nothing, and the 309 skills are a real head start you’d otherwise spend months rebuilding in notebooks. Run it with Qwen3.6-35B-A3B on a 24GB card for private day-to-day work, keep an API key configured for the problems that deserve a frontier model, and treat the beta-speed release cadence as the price of watching a good tool grow up in public.

FAQ

Does OpenScience work fully offline? Mostly. The workbench, skills, and a local Ollama model run without internet, but the point of the database connectors (arXiv, UniProt, PDB) is live queries — offline you lose literature and database lookups, which guts the research loop. Realistic framing: fully local inference, online retrieval.

Is Apache 2.0 safe for commercial lab use? Yes. Apache 2.0 permits commercial use, modification, and internal deployment with no user caps or disclosure requirements. Check the licenses of the models you plug in separately — the workbench license doesn’t cover model weights.

What’s the minimum hardware for a usable local-model setup? A 16GB GPU running Gemma 4 26B-A4B QAT is the practical floor for agentic research tasks; 24GB with Qwen3.6-35B-A3B is where it stops feeling compromised. The workbench itself runs on any modern machine (Linux kernel 5.1+, glibc 2.17+) — it’s the model that needs the VRAM.

Recommended Gear

• RTX 3090 — 24GB VRAM, the used-market value pick for running Qwen3.6-35B-A3B locally
• RTX 4090 — 24GB with roughly double the inference and fine-tuning throughput

Sources

• OpenScience GitHub repository — license, skills count, connectors, install (accessed Sep 3, 2026)
• OpenScience releases — v2.0.66, Aug 31 2026
• AICell Lab newsletter, Jul 24 2026 — launch coverage and framing vs Claude Science
• MarkTechPost: Synthetic Sciences Releases OpenScience
• Ollama OpenAI compatibility docs — the /v1 endpoint used above

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.

Email address Subscribe