Dolly

Dolly

Open-source instruction-following LLM that fine-tunes on a single GPU

66/100MonitorFreeFree

Dolly is a great teaching tool for LLM fine-tuning on a single GPU, with a permissive Apache 2.0 license. But it's archived, and its weak math and coding performance means it's not for production. Use it to learn, then graduate to Llama 3 or Mistral.

Verified 5d ago · liveness 66/100 · cite: rightaichoice.com/tools/dolly

Best for
  • Researchers experimenting with LLM fine-tuning on limited compute
  • Developers needing a commercially safe open-source LLM for demos and prototypes
  • Hobbyists training their first instruction-following model
  • Teams exploring lightweight alternatives to large proprietary models
Not ideal for
  • Production chatbots requiring low latency and high reliability
  • Tasks needing strong math, code, or complex reasoning
  • Users seeking ongoing updates or community support
Visit Website

IntermediateFor a researcher with GPU access, you can go from cloning the repo to fine-tuning in about 1-2 hours, including setup. For a developer using the pre-trained model for inference, expect under 30 minutes to have a basic pipeline working.CLI · DesktopNo public APIVerified 5d ago
Pricing
Free
FreeFree tier4 hidden costs
Learning curve
Intermediate
For a researcher with GPU access, you can go from cloning the repo to fine-tuning in about 1-2 hours, including setup. For a developer using the pre-trained model for inference, expect under 30 minutes to have a basic pipeline working.
Runs on
CLIDesktop
No public API
Who it's for
ResearcherHobbyist developer
Live sentiment
Is Dolly actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip Dolly if you need a model for production use, require strong math or code capabilities, or want a project with active maintenance and community support.

The 30-second take
Biggest gripe

You'll need your own GPU for fine-tuning (A100 or similar) or pay for cloud compute, which can add hundreds of dollars per hour.

Price reality

Dolly is free and open-source, so the main cost is your compute and time. Compared to commercial APIs like OpenAI's GPT-4 (usage-based) or other open models like Llama 3 (also free but more modern), Dolly fits best for learning and prototyping on a tight budget where you already have GPU access.

In short

Dolly — Open-source instruction-following LLM that fine-tunes on a single GPU. Best for Researchers experimenting with LLM fine-tuning on limited compute, Developers needing a commercially safe open-source LLM for demos and prototypes, Hobbyists training their first instruction-following model. Free to use.

What people actually say about Dolly — is it worth it?

We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.

50 mentions across 3 sources (Hacker News, GitHub, Lemmy) · researched Jul 3, 2026.

25% positive75% critical
Recurring strengths
  • +Open-source and Apache 2.0 licensed for commercial use.
  • +Fine-tunes in ~30 minutes on a single machine.
  • +Dolly-15k dataset is high-quality and community-driven.
  • +Based on Pythia-12B, a well-known architecture.
  • +Inference possible on consumer hardware with optimizations.
Recurring frustrations
  • CUDA out-of-memory errors plague even large GPU instances.
  • Deepspeed setup is broken with missing shared library errors.
  • Model loading fails with standard transformers classes.
  • Documentation lacks key parameters for inference success.
  • Project activity has stalled with unresolved issues.
Patterns worth knowing
CUDA memory issues are the top blocker for adoption, even on powerful cloud instances.
Seen on GitHub
Deepspeed integration is fragile and frequently fails with missing dependencies.
Seen on GitHub
Model loading and inference require non-obvious configuration steps.
Seen on GitHub
Learning curve
intermediateProductive in ~A few hours to days of setup
Hidden costs people mention
  • Requires expensive GPU hardware for training (e.g., p3.16xlarge at $5+/hr)
  • Potential cloud compute costs if not self-hosted

Viability Score

66/100
Monitor

How well maintained and how widely used is Dolly? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
90
Traction
100
Site health
95
User sentiment
25
What the vendor publishes
20

Last calculated: September 2026

How we score →

Key Features

  • Fine-tune on ~15k instruction records
  • Based on Pythia-12B architecture
  • Apache 2.0 license for commercial use
  • Covers 7 instruction domains (brainstorming, classification, etc.)
  • Inference via Hugging Face Transformers pipeline
  • Weights on Hugging Face (databricks/dolly-v2-12b)
  • Open-source training code on GitHub
  • Fine-tune in ~30 minutes on a single A100 GPU
  • Inference on A10 GPUs with 8-bit quantization
  • Inference on V100 GPUs with float16
  • Dataset released under CC-BY-SA
  • Pre-trained from The Pile corpus
  • Archived project (no updates since Oct 2023)

About Dolly

FreeIntermediateNo APICLI · Desktop

Dolly is Databricks' open-source instruction-following large language model, designed for developers and researchers who want hands-on LLM fine-tuning without a massive compute cluster. Based on EleutherAI's Pythia-12B, it's fine-tuned on ~15,000 instruction/response pairs generated by Databricks employees, covering seven capability domains from the InstructGPT paper: brainstorming, classification, closed QA, generation, information extraction, open QA, and summarization. The model is available on Hugging Face as databricks/dolly-v2-12b, with training code and weights public on GitHub under Apache 2.0, so you can inspect, modify, and commercially deploy it. Dolly's standout trait is efficiency: fine-tune the 12B model in about 30 minutes on a single A100 GPU, and run inference on A10 GPUs with 8-bit quantization or V100s with float16. The training dataset, databricks-dolly-15k, is released under CC-BY-SA, letting you reuse it for your own experiments. This makes Dolly a practical entry point for hobbyists, students, and small teams exploring instruction tuning without a big hardware budget. But don't mistake Dolly for a frontier model. Databricks openly admits it struggles with programming, math, complex reasoning, and factual accuracy — and it lacks some capabilities like well-formatted letter writing. The project is archived as of October 2023, so there are no updates or community support coming. You get the code, weights, and dataset, but no roadmap. Compared to modern open-weight models like Llama 3 or Mistral, Dolly is a learning tool rather than a production asset. Its permissive licensing and modest hardware requirements make it a safe pick for demos, prototypes, and educational projects, but for serious products you'll want an actively maintained model that handles complex tasks better.

Behind the Verdict

Dolly fills a specific niche: affordable, hands-on instruction tuning. If you're a researcher or hobbyist who wants to understand how fine-tuning works without renting a cluster, Dolly is a solid starting point — you can train it on one A100 in about 30 minutes, and the 15k dataset is openly licensed for reuse. But here's the catch: Dolly is archived. The last commit was in 2023, and there's no community support or updates coming. That's fine for a learning project, but it's a red flag if you're building anything for production. You'll be stuck with a model that can't handle coding, math, or complex reasoning well. Where Dolly really shines is in demos and prototypes. The Apache 2.0 license means you can deploy it commercially without legal headaches, and the hardware requirements are modest — you can run inference on A10s with 8-bit quantization. That makes it a low-risk way to validate an idea before committing to a paid API or a beefier model. Compared to Llama 3 or Mistral, Dolly is several generations behind. Those models are actively developed, much stronger on code and reasoning, and often run locally too. If your goal is a working product, skip Dolly. If your goal is to learn the mechanics of instruction tuning, Dolly's transparency and simplicity give it an edge. One more caveat: the model has known bias and hallucination issues, inherited from The Pile and Wikipedia-based training data. Don't use it for anything requiring factual accuracy or unbiased outputs. For a learning tool, that's acceptable; for a customer-facing app, it's a dealbreaker. In practice, we'd recommend Dolly for a weekend experiment or a university course, not for a startup's MVP. It's a footnote in LLM history, but a useful one for education.

Researching Dolly? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas Dolly actually fits — and what changes day-one when you adopt it.

Researcher

You want to fine-tune a model on a small custom dataset to experiment with instruction tuning.

Outcome: You download the Dolly repo, prepare your data in the required format, and run train_dolly.py on a single A100 GPU, getting a fine-tuned model in about 30 minutes. You can then evaluate it on your tasks.

Hobbyist developer

You want to build a simple chatbot for a personal project without spending money on API calls.

Outcome: You load the pre-trained Dolly model from Hugging Face using the Transformers pipeline and run inference on your local A10 GPU, creating a brainstorming assistant that runs offline.

Use Cases

  • Fine-tune a custom instruction-following model on domain-specific data for internal tools
  • Experiment with LLM alignment techniques using a small, fast-to-train base model
  • Deploy a chatbot for brainstorming or closed QA on a private dataset
  • Teach yourself modern LLM fine-tuning with a fully open-source pipeline
  • Create a lightweight assistant for classification or information extraction tasks
  • Run inference on a single A10 GPU for low-cost proof-of-concept

Models Under the Hood

Pythia-12B

as of 2026-09-02

Limitations

  • Dolly is an open-source large language model fine-tuned on 15,000 instruction/response pairs.
  • It is based on the Pythia-12B architecture and is intended for research and development.
  • The model was trained in about 30 minutes on a single A100 GPU and is commercially licensed under Apache 2.0.
  • The GitHub repository is archived as of October 2023, indicating it is no longer actively maintained.
  • It struggles with programming problems, mathematical operations, complex reasoning, and may produce factual errors or hallucinations.

as of 2026-08-21

Verification history

We have re-verified Dolly 7 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  2. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it

Showing the 6 most recent of 7 verification passes.

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published Dolly tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Open Source

$0

Ideal for

Researchers and hobbyists who want to learn LLM fine-tuning on a budget, with access to a single GPU.

What this tier adds

This is the starting tier: free Apache 2.0 license, includes training code, weights, and the dolly-15k dataset.

Hidden costs & gotchas

What the public pricing page doesn't put in bold. Captured from pricing-page footnotes, contract terms, and recurring complaints.

  • You'll need your own GPU for fine-tuning (A100 or similar) or pay for cloud compute, which can add hundreds of dollars per hour.
  • Running inference on A10 or V100 GPUs requires you to have that hardware or rent it, so variable cloud costs depend on your usage.
  • The training dataset, while open, is small at 15k records, so you'll likely need to invest time in curating or augmenting your own data for domain-specific use.
  • There is no vendor support or maintenance, so any bugs or security issues are on you to fix, which can cost engineering time.

Where the pricing makes sense

The company stage and team size where Dolly's pricing actually pencils out — and where peers do it cheaper.

Dolly is free and open-source, so the main cost is your compute and time. Compared to commercial APIs like OpenAI's GPT-4 (usage-based) or other open models like Llama 3 (also free but more modern), Dolly fits best for learning and prototyping on a tight budget where you already have GPU access.

Setup time & first value

How long it actually takes to get something useful out of Dolly — broken out by persona, not the marketing-page minute.

For a researcher with GPU access, you can go from cloning the repo to fine-tuning in about 1-2 hours, including setup. For a developer using the pre-trained model for inference, expect under 30 minutes to have a basic pipeline working.

Switching to or from Dolly

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • From Any LLM API: If you're currently using a paid API like OpenAI, you can switch to Dolly for prototyping by downloading the model and running it on your own GPU, saving on per-token costs.
Migrating out
  • To Llama 3: If you need better performance and active maintenance, you can start with Llama 3, which has a larger ecosystem and ongoing updates.

Resources & Guides

Tutorials & Learning

Tools that pair well with Dolly

Common stack mates teams adopt alongside Dolly, with the specific reason each pairing earns its keep.

Featured Head-to-Head Comparisons

Alternatives to Dolly

View all
Zhipu AI

Zhipu AI

Zhipu AI's GLM-5.2 delivers 1M lossless context, open-source SOTA coding, and autonomous agent APIs for enterprises.

FreemiumTry
StableLM

StableLM

StableLM: open-source, self-hostable LLM suite for transparent text and code generation

FreeTry
Falcon LLM

Falcon LLM

Open-weight multilingual AI with hybrid Transformer-Mamba architecture from TII.

FreeTry

Frequently Asked Questions

Used Dolly? Help shape our editorial sentiment research.