Skip to main content

What is a large language model (LLM)

What is a large language model (LLM)

A large language model (LLM) is a type of neural network trained on massive amounts of text so that it can understand and generate human language. Imagine an extremely well-read assistant that has absorbed billions of pages of books, articles, code, and conversations. It does not "know" things the way a person does; instead, it has learned statistical patterns — which words and ideas tend to follow which — well enough to write coherent paragraphs, answer questions, translate between languages, summarize documents, and even reason through multi-step problems.

The defining property (and the limitation) of an LLM is that it works by prediction. Given the beginning of a sentence, the model calculates the most probable next word, then the next, and so on, one token at a time. A token is roughly a word or a sub-word. By chaining thousands of these tiny predictions, an LLM can produce essays, code, poems, or technical analyses — all without being explicitly programmed for each task. Well-known LLMs include GPT, Claude, Gemini, and Mistral. Most crypto AI projects that mention "AI" in their marketing are either using an LLM internally, claiming to use one, or wrapping a third-party LLM behind their own interface. Understanding what an LLM actually is — and what it is not — is essential for evaluating these claims.

In short: an LLM is the engine behind most modern text-based AI. In crypto AI, the critical question is not whether a project "uses an LLM" but how it uses one and what proprietary value it adds on top.

How it works

Building and using an LLM involves several distinct stages. Each stage requires different resources, expertise, and data — and each one represents a different level of AI depth when evaluating a crypto AI project.

Stage 1: Pre-training

Pre-training is where the model learns the fundamentals of language. During this phase, the LLM reads billions of tokens — words and sub-words drawn from books, websites, code repositories, scientific papers, and other text sources. The model adjusts its internal parameters (weights) to become increasingly accurate at predicting the next token in a sequence.

This stage is expensive. Training a frontier LLM from scratch can require thousands of specialized GPUs running for weeks or months, and the resulting model may have tens or hundreds of billions of parameters. Only a handful of organizations — well-resourced AI labs — routinely pre-train LLMs from scratch.

Stage 2: Fine-tuning

A pre-trained model is powerful but generic. Fine-tuning narrows the model's behavior by training it further on a curated, smaller dataset relevant to a specific task or domain. For example, a medical LLM might be fine-tuned on clinical notes; a DeFi-oriented model might be fine-tuned on smart-contract documentation and on-chain data.

Fine-tuning requires far less compute than pre-training but still demands expertise in data selection, evaluation metrics, and avoiding catastrophic forgetting (where the model loses general abilities while specializing).

Stage 3: Alignment and RLHF

Modern LLMs usually undergo an alignment phase after fine-tuning. Reinforcement learning from human feedback (RLHF) is the most common approach: human evaluators rank model outputs, and the model is trained to prefer responses that humans rate higher. Alignment is what makes a model follow instructions, refuse harmful requests, and produce genuinely useful answers rather than plausible-sounding nonsense.

Stage 4: Inference

Inference is the production phase — when a trained LLM receives a prompt and generates an output. Each time a user sends a message to a chatbot, the underlying LLM runs inference: it reads the prompt, processes it through its layers of parameters, and produces a response token by token.

Inference costs compute (GPU time) but far less per query than training. Most projects that "use an LLM" are only performing inference — often by calling an external provider's API rather than running their own hardware.

The pipeline at a glance

Stage What happens Who typically does it Compute cost
Pre-training Learn language from billions of tokens Major AI labs Very high
Fine-tuning Adapt the model to a domain or task AI labs, well-funded startups Medium
Alignment (RLHF) Make the model safe and instruction-following AI labs Medium
Inference Generate responses to user prompts Anyone with an API key or GPU Low per query

Key characteristics of an LLM

Several properties define how capable a particular LLM is:

  • Parameter count — the number of trainable weights in the model. Larger models generally capture more nuance but cost more to train and run. Parameter counts range from a few billion (small open-source models) to over a trillion (frontier models).
  • Context window — the maximum number of tokens the model can process in a single interaction. A short context window means the model "forgets" the beginning of a long conversation. Modern LLMs offer context windows ranging from a few thousand tokens to over a hundred thousand.
  • Architecture — most modern LLMs are built on the Transformer architecture, introduced in 2017. Transformers use a mechanism called self-attention to weigh the relationships between all tokens in the input, which is what allows them to handle long-range dependencies in text.
  • Training data — the quality, diversity, and recency of the data used during pre-training shape what the model knows. A model trained only on English text will perform poorly on other languages; a model with a knowledge cutoff in a given year will not know about subsequent events.

Real industry examples

Several well-known LLMs illustrate the range of approaches in the field:

  • GPT (OpenAI) — a closed-source, multimodal LLM available through an API. Many crypto AI projects call the GPT API to add conversational or analytical features to their products.
  • Claude (Anthropic) — a closed-source LLM with a strong emphasis on safety and alignment. Like GPT, it is typically accessed via API.
  • DeepSeek-R1 (DeepSeek) — an open-weight LLM released under the MIT license. Its strong reasoning capabilities and open availability make it a popular base model for fine-tuning and for crypto AI projects that want to run models locally or claim deeper AI integration.
  • Mistral (Mistral AI) — a family of open-weight models known for strong performance at smaller parameter counts, making them practical for projects with limited GPU budgets.

These names appear frequently in crypto AI project descriptions. When a project says it "uses GPT," it almost always means it calls the OpenAI API. When it says it "fine-tuned DeepSeek," it implies a deeper technical engagement — though the claim still requires verifiable evidence.

Open-source vs closed-source LLMs

Aspect Open-source / open-weight Closed-source
Model weights Publicly available for download Hidden behind an API
Inspection Anyone can study, audit, or fine-tune No external audit of internals possible
Customization Can be fine-tuned on custom data, run locally Limited to API parameters (temperature, system prompts)
Cost structure Requires own GPU hardware or hosting Pay-per-token API pricing
Examples DeepSeek, Qwen, Mistral GPT, Claude, Gemini

For crypto AI projects, the distinction matters: a project that fine-tuned an open-weight model and published training details demonstrates more AI depth than one that calls a closed API without modification.

Why LLMs matter in crypto AI

Many crypto AI projects reference LLMs in their whitepapers, pitch decks, or product descriptions. The claims vary widely:

  • "We built our own LLM" — implies pre-training or significant fine-tuning, which requires substantial compute and expertise. This is the deepest level of engagement.
  • "We fine-tuned an LLM for DeFi" — implies a domain-specific adaptation of an existing base model. More credible than a raw API call, but details matter.
  • "We use an LLM" — often means calling an external API (such as the OpenAI or Anthropic API) with project-specific prompts. This is the shallowest level of AI integration.

These three scenarios represent fundamentally different levels of AI depth, and DecAIHub evaluates them accordingly through its evidence-based methodology.

Using an API vs building your own

Approach What it means AI depth
API call The project sends prompts to a third-party LLM (e.g., OpenAI API) and returns the response Low — the AI belongs to the provider
Prompt engineering The project designs specialized prompts, chains, or retrieval pipelines on top of a third-party LLM Low-medium — proprietary logic exists but the model is external
Fine-tuning The project adapts an open-source base model (DeepSeek, Mistral, Qwen) on its own dataset Medium-high — the project owns a modified model
Pre-training The project trains a model from scratch on its own data and compute High — full ownership of the model

An API wrapper that passes user prompts to a commercial LLM and returns the response is not the same as a project that fine-tuned DeepSeek on on-chain transaction data. DecAIHub distinguishes between these in the AI component field of the project card.

Where it appears in DecAIHub project cards

When reviewing a project card on DecAIHub, several fields relate directly to LLM usage:

  • AI component may mention "LLM," "fine-tuned model," "prompt engineering," or a specific model name. This field describes what kind of AI the project actually has, as verified by DecAIHub reviewers.
  • AI use case describes what the LLM is used for: generation, classification, summarization, agent reasoning, and so on. A project may use an LLM for a narrow task (e.g., intent parsing) or as the core engine for an entire product.
  • ai_score (part of DecAI Fit) reflects how well the LLM usage is documented with Tier-1, Tier-2, or Tier-3 evidence. A project that claims LLM usage but provides no verifiable artifacts will score low on this dimension.
  • AI reality flags (AI_0 through AI_4) indicate the overall depth of verifiable AI, which in many projects is anchored by their LLM integration.

The goal is never to penalize a project for using a third-party LLM — many valid products do exactly that. The goal is to distinguish between projects that transparently call an API and those that misrepresent API usage as proprietary AI research.

What an LLM alone does not prove

  • Having an LLM API key does not mean the project "has AI." It means the project can call someone else's AI.
  • Mentioning "GPT" or "Claude" in marketing does not prove proprietary AI work. Thousands of applications use the same API.
  • Even a fine-tuned model needs verifiable artifacts: a description of the training data, evaluation metrics, a model version identifier, and deployment evidence.
  • A large parameter count does not guarantee a better model. Training quality, data curation, and alignment matter at least as much as raw size.

Do not confuse with

  • Inference — running a trained LLM to produce outputs. Inference is one step in using an LLM, not a synonym for LLM itself.
  • Training — the process of building or adapting an LLM. Training produces the model; inference uses it.
  • AI agent — an autonomous system that may use an LLM as its reasoning core, but adds perception, memory, tool use, and action. An LLM alone is not an agent.
  • Natural Language Processing (NLP) — a broader field of computer science. LLMs are one (very successful) approach to NLP, but NLP also includes older techniques such as keyword extraction, rule-based parsing, and statistical classifiers.
  • Foundation model — a more general term that includes LLMs but also covers large models trained on images, audio, video, or multimodal data. Every LLM is a foundation model, but not every foundation model is an LLM.

Frequently asked questions

What is the difference between an LLM and a chatbot?

An LLM is a model — a set of trained parameters that can process and generate text. A chatbot is a product built on top of a model. The LLM is the engine; the chatbot is the car. A single LLM can power thousands of different chatbots, each with its own prompts, interface, and personality. Conversely, a chatbot does not necessarily use an LLM — older chatbots relied on scripted rules or simple pattern matching.

Are all AI projects using LLMs?

No. Many crypto AI projects use other types of machine learning: computer vision models for NFT generation, reinforcement learning for trading strategies, graph neural networks for blockchain analytics, or traditional ML for anomaly detection. The LLM is dominant in text-based applications but it is not the only kind of AI.

What does it mean to fine-tune an LLM?

Fine-tuning takes a pre-trained LLM and continues its training on a smaller, curated dataset relevant to a specific task. The goal is to specialize the model — for instance, teaching it to understand DeFi terminology, parse smart contracts, or generate responses in a particular style. Fine-tuning is more cost-effective than pre-training from scratch but still requires technical skill, appropriate data, and compute resources.

How can you tell if a crypto project built its own LLM vs using an API?

Look for concrete evidence: published model weights or a model card, documented training data, evaluation benchmarks, and a description of the fine-tuning process. If the project only references a well-known model name (GPT, Claude) without describing any modification, it is likely using an API. DecAIHub captures this distinction in the AI component field and the evidence tier.

What are open-source LLMs?

Open-source (or open-weight) LLMs are models whose trained parameters are publicly available for download, study, and modification. Examples include DeepSeek, Qwen, and Mistral. They allow anyone to fine-tune, deploy, and inspect the model, which increases transparency and enables independent verification — both valuable qualities in the crypto AI space.

Why does LLM size (parameters) matter?

More parameters generally allow a model to capture more complex patterns in language, which can improve performance on difficult tasks. However, size alone is not decisive. A well-trained smaller model can outperform a poorly trained larger one. What matters most is the combination of parameter count, data quality, training methodology, and alignment tuning.

See also

External references

No comments to display

Back to top