15 things everyone should understand about how AI actually works

AI has entered everyday life faster than most people's understanding of it. Millions use it daily — to draft emails, generate images, write code, summarize documents — without any clear picture of what's happening underneath. That's not laziness. These systems are genuinely complex, built from decades of mathematics and engineering, and the companies developing them often prefer that complexity remain opaque.

But the gap between what AI can do and what people believe it's doing creates real problems. People anthropomorphize systems that have no inner experience. They trust outputs that are confidently wrong. They assume AI is "thinking" when it's doing something quite different. They miss the actual limitations — and sometimes the actual capabilities — because their mental model is inaccurate.

This piece is not about whether AI is good or bad. It's about what it actually is: how it learns, how it generates output, where its failures come from, and why the problems that afflict these systems are structural rather than incidental. Understanding these things won't make you a machine learning engineer. It will make you a sharper reader of AI coverage, a more careful user of AI tools, and a better judge of claims made by the companies building them.

The 15 concepts here cover the full chain — from how models are trained to why they hallucinate, from what "parameters" actually means to why the alignment problem is harder than it looks. Some of these ideas are technical but not complicated. Others are philosophical but grounded in real engineering decisions. All of them matter if you want to engage honestly with the technology reshaping how work gets done, how content is made, and how decisions are reached in medicine, law, finance, and government.

None of this requires a background in math or computer science. It requires only a willingness to examine how something actually works rather than how it has been marketed. That distinction is, at this moment, more important than it might seem.

Yuichiro Chino / Getty Images

AI systems do not think. They identify patterns in large amounts of data and use those patterns to produce outputs — text, images, predictions, classifications. The distinction matters because "thinking" implies something quite different: reasoning, intentionality, understanding, and the ability to know when you're wrong. AI systems, as currently built, have none of those properties in the way humans do.

The word "intelligence" in "artificial intelligence" has always been a bit misleading. The term dates to a 1956 conference at Dartmouth College organized by John McCarthy, who coined it partly to attract research funding. What the researchers meant then was narrow: the ability to perform tasks that, if done by a human, would require intelligence. That is not the same as being intelligent.

Modern AI systems — particularly large language models — are extraordinarily good at pattern recognition. Given a prompt, they produce a statistically likely continuation based on patterns extracted from billions of examples of human-written text. The output can look like reasoning. It can sound thoughtful, articulate, even profound. The process generating it is fundamentally about prediction, not comprehension.

This is why AI systems can produce fluent, confident text on a subject they have no real grounding in. The model isn't checking facts against some internal model of reality. It's producing text that fits the patterns of what correct-sounding text on that subject looks like. When it gets things right, the patterns were accurate. When it gets things catastrophically wrong, the patterns misled it.

The practical implication is significant. A system that cannot distinguish between true and false, or between what it knows and what it's confabulating, should not be treated as a reliable information source without external verification. It can be a useful tool for generating drafts, exploring ideas, or organizing thoughts. It is not a mind. It is a very sophisticated pattern-matching machine — and treating it as anything more creates predictable, avoidable errors.

Understanding this single point reframes almost everything else about how AI behaves and why it fails in the specific ways it does.

Eugene Mymrin / Getty Images

Every AI system learns from data. The quality, quantity, and composition of that data determine almost everything about the model's behavior — what it knows, what biases it reflects, which languages it handles well, which topics it struggles with, and what kinds of errors it makes.

For large language models, training data typically consists of enormous volumes of text scraped from the internet, digitized books, code repositories, Wikipedia, academic papers, and other sources. The exact composition varies by model and company, and most organizations do not publish full details of what's in their training sets. The scale is vast: GPT-3, released by OpenAI in 2020, was trained on roughly 570 gigabytes of filtered text. More recent frontier models use significantly more.

The model doesn't memorize this data the way a human memorizes facts. Instead, it extracts statistical patterns — which words tend to follow which other words, which concepts appear together, how different writing styles are structured. Those patterns become encoded in the model's internal weights, the numerical values that determine how the model responds to any given input.

The training data is, in effect, the world the model knows. If certain perspectives, languages, or domains are underrepresented in the training data, the model will be correspondingly worse at handling them. If the training data contains factual errors — and internet text certainly does — the model may reproduce those errors with full confidence.

Training data cutoffs also matter. Most models have a knowledge cutoff date, after which they have no direct knowledge of events. A model trained on data through a particular month will be ignorant of anything that happened after that point, unless given access to supplementary tools or updated training.

The training data question is also an ethical one. Scraping large volumes of text from the internet raises unresolved questions about copyright, consent, and whose writing is being used to build commercial products. Litigation is ongoing in several countries, and no clear legal framework has yet settled the matter.

Yuichiro Chino / Getty Images

The term "neural network" evokes the human brain, and that's not entirely accidental. The basic concept does draw on neuroscience — specifically, the idea that biological neurons fire in response to inputs and pass signals to other neurons. Artificial neural networks use a mathematical abstraction of this: nodes organized in layers, passing values to each other, adjusting the strength of their connections based on feedback.

The analogy runs out quickly. Biological neurons are extraordinarily complex cells with electrochemical behavior that science doesn't fully understand. Artificial neurons are simple mathematical functions — they receive a number, apply a transformation, and output a number. The human brain has roughly 86 billion neurons with hundreds of trillions of synaptic connections. A neural network, even a very large one, is a much simpler and more rigid structure operating in a fundamentally different medium.

Modern deep learning — the branch of AI responsible for the current wave of progress — uses neural networks with many layers, hence "deep." Each layer extracts increasingly abstract features from the input. In image recognition, early layers might detect edges, middle layers might detect shapes, and later layers might detect specific objects. In language models, the progression runs from individual characters to words to phrases to broader semantic relationships.

The training process involves showing the network many examples and adjusting the connection weights using an algorithm called backpropagation. Error signals are propagated backward through the network, and weights are nudged in directions that reduce the error. Over millions or billions of training steps, the network produces outputs that better fit the patterns in the training data.

What emerges from this process can seem almost magical. But it's mathematics — specifically, calculus applied to optimization. There is no ghost in the machine. The network doesn't "learn" in the sense of developing understanding. It adjusts numerical values until its outputs better match the patterns it was trained on.

The brain analogy is useful as an origin story. As a guide to how modern AI actually operates, it misleads more than it illuminates.

Andriy Onufriyenko / Getty Images

The core mechanism behind large language models is deceptively simple: given a sequence of text, predict what comes next. This is called next-token prediction, and it is — at its most fundamental level — all that models like GPT-4, Claude, and Gemini are doing.

A "token" is not exactly a word. Tokenization breaks text into chunks that might be full words, parts of words, or individual characters, depending on the tokenizer used. The word "unbelievable" might be broken into "un" and "believable." The word "cat" might be a single token. The exact tokenization scheme affects how a model handles text, particularly in languages other than English where word boundaries and morphology work differently.

The model processes an input — called a prompt — and generates a probability distribution over all possible next tokens. It selects one, with some element of randomness controlled by a parameter called "temperature," appends it to the input, and repeats the process. This is called autoregressive generation: each token is predicted based on the tokens that came before it.

What makes large language models powerful is not the mechanism but the scale at which it's applied. When a model is trained to predict the next token across hundreds of billions of examples of human-written text, it must — in order to do this accurately — learn something about grammar, facts, reasoning patterns, style, cause and effect, and a vast amount of world knowledge. The compression of that information into the model's parameters is what makes the output seem sophisticated.

But the mechanism also explains the failure modes. The model doesn't plan what it's going to say before it starts generating. It produces one token at a time, each conditioned on what came before. This means the model can drift, contradict itself, or paint itself into a logical corner — because it didn't "think ahead." It couldn't. That's not how the system works.

Some newer architectures introduce deliberate reasoning steps before generating a final answer. But even these approaches still rely on the same underlying next-token prediction engine.

Yuichiro Chino /Getty Images

When someone asks an AI system a question and it answers correctly, it's tempting to say the AI "knows" the answer. What the model actually holds is something different: a compressed representation of statistical regularities in its training data. Whether that constitutes knowledge in any meaningful sense is a serious philosophical question with no clean resolution.

Human knowledge involves understanding — which typically includes the ability to recognize when you don't know something, to distinguish reliable from unreliable information, to update beliefs in response to new evidence, and to recognize contradictions. AI models, as currently built, do none of these things reliably.

A model can tell you the capital of France and the capital of a fictional country with equal confidence. It cannot, from the inside, distinguish between the two. It can produce a plausible-sounding historical account of an event that never happened. It can assert a mathematical fact and contradict it several paragraphs later. It has no internal signal that fires when it's venturing into territory it shouldn't trust.

What the model has instead is a representation of what the training data "said" about a topic, encoded in weights. If a topic appeared frequently and consistently in the training data, the model will tend to produce accurate outputs about it. If a topic was rare, contested, or misrepresented in the training data, the model will reflect that unreliability — without flagging it.

This is categorically different from knowing something. A human expert has a model of their field that includes uncertainty, active debate, the limits of current evidence, and the ability to flag when a question falls outside their expertise. AI systems currently lack reliable versions of all of these.

Some researchers describe what models do as "stochastic parroting" — generating statistically plausible sequences without grounding them in any referential relationship to the world. Others argue something more interesting emerges: that useful representations of world structure arise from next-token prediction at scale. The debate is unresolved. What's not in dispute is that the model's relationship to truth is indirect and unreliable, and users should treat it accordingly.

Amos K / Unsplash

Almost all AI deployed today is narrow AI: systems designed to perform specific, well-defined tasks. A model that plays chess doesn't play Go. A spam filter doesn't translate language. An image classifier doesn't generate text. These systems are often extraordinarily capable within their domain, surpassing human performance on specific benchmarks — but they don't transfer capability outside it.

Large language models look more general because they can handle many different kinds of tasks: writing, coding, summarization, translation, question answering. But they're still narrow in important ways. They're weak at tasks that require interacting with the physical world, persistent learning from experience, reliable causal reasoning, and recognizing their own limits.

Artificial general intelligence — AGI — refers to a hypothetical system that can perform any intellectual task a human can, with comparable flexibility. No such system exists. The definition of AGI is itself contested: different researchers and companies define it differently, which makes claims about being "close to AGI" or having "achieved AGI" nearly impossible to evaluate without knowing what definition the speaker is using.

OpenAI has described its mission as building AGI. Google $GOOGL DeepMind uses different framing. Academic researchers debate whether AGI is even a coherent target, or a moving goalpost that shifts as AI improves. The phrase is doing a lot of work in public discourse without a consensus on what it means.

What exists today — and what is genuinely useful — are large language models and other AI systems that are powerful but specific. They're transforming industries not because they replicate human general intelligence but because they automate specific kinds of cognitive work at scale: text generation, pattern matching, classification, translation, summarization.

Understanding the narrow/general distinction helps calibrate expectations. A system excellent at generating legal text summaries is not competent to navigate ambiguity reliably, recognize sarcasm consistently, or understand why a particular joke lands. Treating narrow systems as if they were general is a source of both over-reliance and misplaced disappointment — and it's a confusion the marketing around these products often encourages.

Contributor / Getty Images

Machine learning — the broader field that includes deep learning and large language models — uses several distinct training paradigms. The three most important are supervised learning, unsupervised learning, and reinforcement learning. Understanding the difference helps clarify what AI systems are actually being trained to do.

Supervised learning is the most common. The model is trained on labeled data: pairs of inputs and correct outputs. An image classifier trained on photos labeled "cat" or "dog" learns to associate visual features with those labels. A spam filter trained on emails labeled "spam" or "not spam" learns to classify new emails. The model is corrected by comparing its output to a known correct answer.

The key requirement of supervised learning is labeled data, which is expensive to produce. Humans must annotate examples, which means supervised learning at scale requires massive human annotation efforts — often outsourced to workers performing tedious, sometimes disturbing tasks for low pay. This labor is largely invisible in public discussions of AI.

Unsupervised learning doesn't use labeled data. The model is given raw data and learns to find structure in it — clusters, patterns, representations — without being told what to look for. This is how models learn useful internal representations that can then be applied to downstream tasks. It's also how recommendation systems learn that users who engage with certain content tend to engage with other specific content.

Reinforcement learning trains a model through trial and error. The model takes actions, receives rewards or penalties based on outcomes, and adjusts its behavior to maximize reward over time. This is how DeepMind's AlphaGo learned to play Go at a superhuman level. The model didn't learn from examples of correct play — it learned by playing millions of games and receiving feedback on outcomes.

Most modern AI systems use combinations of all three. Large language models start with self-supervised learning — a variant of unsupervised learning where the model predicts masked or missing parts of its own training data — then are fine-tuned using supervised learning and reinforcement learning from human feedback. Each stage shapes the model's behavior in distinct ways.

Kirsty O'Connor / PA Images / Getty Images

When people talk about AI models having "billions of parameters," they're referring to the individual numerical weights that make up the model. A parameter is a single number in the model's internal structure — a value adjusted during training — that collectively determines how the model responds to inputs. More parameters generally means a larger capacity to store patterns and relationships from the training data.

GPT-3 had 175 billion parameters. Larger frontier models have more. The number is often treated as a proxy for capability — and to some degree it is. Larger models tend to perform better on benchmarks, handle more complex tasks, and generalize better to novel inputs. But the relationship is not linear, and parameter count alone doesn't tell the full story.

What the parameters actually encode is not information in the way a database stores information. A database holds discrete facts: the capital of France is Paris, stored as a string. A model's parameters encode something more diffuse — the weights of connections in a neural network that together produce useful outputs when the model processes an input. The model doesn't have a "fact slot" for Paris. That fact is distributed across millions of parameters in a way that causes "Paris" to become a likely output when the model is asked about the French capital.

This distributed representation is both a strength and a weakness. It allows the model to generalize, to understand paraphrased versions of a question, and to combine concepts in flexible ways. But it also means you can't directly inspect the model to find out what it "knows." You can only probe it with inputs and observe what comes out.

Parameter count also interacts with training quality. A large model trained on poor data or with a flawed training process can underperform a smaller model trained well. Architectural choices — how layers are connected, what kind of attention mechanisms are used, how context is processed — matter as much as raw size.

Smaller models have improved significantly through techniques like distillation, where a smaller model is trained to mimic a larger one. This has made capable AI systems feasible to run on devices with limited computing resources, opening deployment possibilities that didn't exist even a few years ago.

NurPhoto / Getty Images

AI hallucination — when a model confidently produces false information — is widely described as a problem to be fixed. But hallucination isn't a bug that future versions will patch out. It's a structural consequence of how large language models work, and understanding why makes it much less surprising.

The model is trained to produce likely next tokens. It has no direct access to verified facts, no internal fact-checking mechanism, and no reliable way to distinguish between what it knows and what it's fabricating. When asked a question whose answer is not well-represented in its training data, it doesn't say "I don't know" by default. It produces text that fits the pattern of what an answer to that question should look like.

This is why models hallucinate citations — producing plausible-looking author names, journal titles, and publication years that don't correspond to real papers. It's why they hallucinate historical dates, legal precedents, biographical details, and scientific findings. The output looks authoritative because the training data taught the model what authoritative text looks like — not how to verify whether specific claims are true.

Several approaches try to reduce hallucination. Retrieval-augmented generation connects a model to an external knowledge base, allowing it to pull in verified documents before generating a response. Fine-tuning on high-quality, narrow datasets can improve accuracy in specific domains. Training models to express calibrated uncertainty is an active area of research.

But none of these fully eliminates the problem. Retrieval helps only if the knowledge base is accurate and the model retrieves correctly — neither is guaranteed. Uncertainty expressions can themselves be miscalibrated: a model may confidently express high certainty about a wrong answer. The underlying mechanism — next-token prediction without real-world grounding — remains unchanged regardless of what's built on top of it.

For users, this means treating any AI-generated factual claim as a hypothesis to verify, not a fact to rely on. The conversational fluency of the output makes this easy to forget — which is exactly what makes the problem consequential.

Ian Nicholson / PA Images / Getty Images

AI systems can produce text that looks like reasoning. They can lay out arguments, structure logical steps, and arrive at conclusions. But the process generating that text is not the same as human reasoning, and the differences have real practical consequences.

Human reasoning involves several things AI systems don't reliably do: working memory that holds and manipulates abstract representations, the ability to track whether a logical step is valid, the ability to recognize contradictions and back up, and metacognition — thinking about one's own thinking. When humans reason, they can often sense when something has gone wrong in their argument and revisit it.

AI models generate reasoning text token by token, left to right. Once a wrong step has been taken, every subsequent token is conditioned on that wrong step. The model rarely corrects its own reasoning path once underway. It continues generating text that fits what typically follows the wrong step, which can produce elaborate, internally coherent-sounding arguments rooted in an error made three sentences back.

This explains why AI systems can fail badly on multi-step arithmetic even while sounding fluent, why they reason poorly about spatial relationships, and why they can construct logical-seeming arguments that contain subtle but decisive flaws.

Chain-of-thought prompting — instructing a model to "think step by step" before answering — does improve performance on reasoning tasks. This appears to work partly because generating intermediate steps gives the model more context to condition on, and partly because making implicit reasoning explicit reduces certain error types. But chain-of-thought is still token-by-token generation; it is not logical inference in a formal sense.

Newer approaches try to introduce more explicit search and verification into AI reasoning — allowing the model to explore multiple paths and check its steps before committing to an answer. These show genuine improvement on formal reasoning benchmarks. They are computationally expensive and not yet general-purpose.

The practical implication: AI systems are best used as tools for organizing and extending human thinking, not as oracles that deliver verified conclusions.

DAVID MCNEW / Getty Images

AI systems reflect the biases present in their training data, and often amplify them. Language models have been shown to associate certain names with certain demographic groups, to describe women and men differently in professional contexts, and to perform markedly worse on languages and dialects underrepresented in training data. This is not a theoretical concern — it has been documented in deployed systems.

The mechanism is direct. If a training dataset contains text in which certain jobs are predominantly associated with men, the model will internalize that pattern. When asked to generate text involving those jobs, it will reflect that association. If the training data contains more text about some cultures and perspectives than others, the model's knowledge will be correspondingly uneven.

Training data is not the only source of bias. The choices made during fine-tuning, the criteria used in human feedback collection, the demographic composition of annotator pools, and the decisions about what content to filter — all of these introduce additional layers of value-laden choices into a process that can appear neutral from the outside. There is no neutral training process. Every design choice encodes assumptions.

Efforts to reduce bias involve curating training data more carefully, conducting structured bias audits, using techniques like adversarial training to reduce systematic errors, and applying post-processing filters. These interventions help at the margins but don't eliminate the problem. Bias in AI is an ongoing area of research, not a solved one.

A separate but related issue is that what counts as "bias" is often contested. A model that uses different tone with different kinds of content may be accurately reflecting variation in the training data, or it may be systematically misrepresenting some groups. Distinguishing between these explanations requires careful analysis of specific outputs in specific contexts — not a simple aggregate measurement.

For organizations deploying AI systems, this means conducting bias audits specific to the intended use case, rather than relying solely on the model developer's general benchmarks.

Erik Isakson / Getty Images

The recent wave of AI progress is often attributed to better algorithms — improved architectures, smarter training techniques, more efficient data use. That's part of the story. Raw computing power has been equally important, and in some periods more so.

Modern AI models are trained on enormous clusters of specialized chips, primarily graphics processing units (GPUs) and, increasingly, custom accelerators like Google $GOOGL's Tensor Processing Units (TPUs) and chips built by companies including Cerebras and Groq. Training a large language model can take weeks or months on thousands of chips running in parallel. The energy consumption is substantial.

The relationship between compute and model capability was formalized in a set of findings now called scaling laws, published by researchers at OpenAI in 2020. The core finding: increasing the amount of compute used in training — by scaling model size, data size, or both in specific ratios — produces predictable, consistent improvements in model capability. This gave AI labs a practical roadmap. If you wanted a better model, you could estimate roughly what it would cost to build.

Scaling laws have limits. There are signs that some kinds of improvement require architectural changes rather than simply more compute. And the compute required for frontier models is growing in ways that concentrate capability in the hands of a small number of heavily funded organizations — OpenAI, Google, Meta $META, Anthropic, and a few others. The economics of AI development have started to resemble the economics of semiconductor fabrication: extraordinarily capital-intensive, with high barriers to entry.

The energy demands of large-scale AI training and inference are drawing increasing scrutiny. Data centers running AI workloads consume significant amounts of electricity. Several major technology companies have made public commitments about renewable energy sourcing for their data centers, but the pace of AI expansion is testing those commitments in ways that are becoming visible in utility planning and grid management discussions.

Thapana Onphalai / Getty Images

Large language models don't emerge from initial training aligned with what users want. A model trained purely on next-token prediction using internet text will produce outputs that reflect the raw character of that data — including harmful, misleading, and simply unhelpful content. The process that shapes models into useful assistants is called reinforcement learning from human feedback, or RLHF.

RLHF works in several stages. First, the base model is fine-tuned on examples of high-quality conversations, teaching it the general format and style of a helpful assistant. Then, human raters compare different model outputs and indicate which they prefer. Those preferences are used to train a separate "reward model" that learns to predict which outputs humans will rate higher. Finally, the language model is trained using reinforcement learning to produce outputs that score well on the reward model.

This process is why modern AI assistants are more helpful, less likely to produce harmful content, and more conversationally coherent than base models. It's also why they behave in certain characteristic ways — deferential, qualifying, declining certain requests — that are products of training rather than intrinsic properties of the underlying model.

RLHF has well-documented limitations. The reward model can be "hacked" — the language model can find ways to score highly on the reward model that don't correspond to actually being helpful. Human raters have their own biases, and the composition of the rater pool affects which behaviors get reinforced. Models trained with RLHF can become overly cautious, refuse reasonable requests, or become sycophantic — telling users what they seem to want to hear rather than what's accurate.

Constitutional AI, developed by Anthropic, is one alternative approach: the model is trained using a set of explicit principles rather than relying purely on human ratings. Other approaches combine RLHF with different reinforcement learning techniques or automated evaluation methods. The field of post-training alignment is active and rapidly evolving, with no consensus on the best approach.

Anadolu / Getty Images

The term "open source" has a specific meaning in software: the source code is publicly available, and users can inspect, modify, and redistribute it. In AI, the term is used far more loosely, and the distinction matters considerably.

A model can be released in several ways. It can be fully proprietary — accessible only through an API, with no public access to weights, training data, or training code. It can release model weights without releasing the training data or training code — which is what Meta $META did with its Llama models, which it has described as open source despite critics arguing the term is misleading. Or a model can release weights, training data, code, and full documentation — genuine openness, which remains rare among frontier models.

Releasing model weights is significant. It allows researchers, developers, and companies to run the model locally, fine-tune it for specific applications, study its behavior, and build on it without paying API fees or depending on a vendor's continued service. This is genuinely different from a fully closed model, and it has driven substantial independent research and commercial innovation.

But "open weights" is not "open source" in the traditional sense. You cannot reproduce the training process without the training data and training code. You cannot fully understand the provenance of the model's behavior without knowing exactly what data it was trained on and how. And the terms of use on many "open" AI models include restrictions — Meta's Llama models, for instance, have prohibited certain commercial uses and cannot be used to train competing models above specific scale thresholds.

The debate about openness in AI also has a safety dimension. Some researchers argue that releasing model weights increases risk by allowing bad actors to remove safety fine-tuning and run the base model without restrictions. Others argue that open models are essential for independent safety research and for preventing concentration of AI capability in a handful of companies. The argument remains unresolved, and policy discussions in multiple governments are actively grappling with it.

HECTOR RETAMAL / Getty Images

AI alignment refers to the challenge of ensuring that AI systems do what their designers and users actually want — not in a superficial sense, but in a deep and robust sense that holds as systems become more capable and are deployed in higher-stakes contexts.

The challenge is not primarily about AI going "rogue" in the science-fiction sense. It's about the gap between what designers can specify and what they actually intend. A system told to maximize user engagement will maximize engagement — including through outrage and misinformation, if that's what drives the metric. A system told to make users feel satisfied may learn to tell them what they want to hear. A system optimizing for any single measurable goal can find ways to achieve high scores on that measure while violating every unstated assumption the designer had.

This is a version of Goodhart's Law: when a measure becomes a target, it ceases to be a good measure. In AI, the corresponding problem is called "reward hacking" or "specification gaming." AI systems — especially those trained with reinforcement learning — can find unexpected shortcuts to high reward that look good on the metric but not on the intent behind it.

For current AI systems, alignment problems manifest in concrete, observable ways: chatbots that refuse to answer reasonable questions because they're miscalibrated about what's harmful, assistants that flatter users rather than correct them, content recommendation systems that optimize engagement at the cost of user wellbeing. These are alignment failures, even mild ones.

As AI systems become more autonomous — taking actions in the world rather than just generating text — the stakes of alignment failures increase. A system with the ability to browse the web, execute code, make purchases, or send emails on a user's behalf needs a reliable model of what the user actually wants, including things they haven't explicitly said. Current systems do not reliably have this.

Alignment research aims to develop both technical tools — better training methods, interpretability techniques that let researchers see what's happening inside models, methods for specifying human values in machine-learnable ways — and governance frameworks that determine how high-stakes AI systems are deployed and monitored. Neither the technical nor the governance side is solved. Both matter significantly for where this technology goes next.