The vocabulary of AI, in plain English and Bahasa Indonesia.

A moving label, not a technology. It points at whatever computers have newly learned to do well.

Programs that improve from examples instead of hand-written rules.

Machine learning with many-layered networks that learn their own features.

A stack of weighted layers that transforms input into output by adjusting numbers.

AI that produces new content: text, images, audio, code, video.

A hypothetical AI that matches human ability across most intellectual tasks.

The trained file of learned parameters that turns input into output.

The learned numbers inside a model. Their count is the model size.

The expensive process that sets a model's parameters by exposing it to data.

Running a trained model to produce an answer. What happens on every request.

When a model memorises the training examples instead of learning the pattern.

Settings you choose before training, which the training process does not learn.

Learning from examples that come with the right answer attached.

A model trained on a huge amount of text to predict the next token. The engine behind most AI products.

The unit a model reads and writes. Roughly word-sized, but not exactly.

Everything the model sees on one request. Finite, and it decides what fits.

The input you give a model. The word covers more than the question you type.

The standing instructions a harness sends on every request.

The dial for randomness. Low is repeatable, high is surprising.

Output that is fluent and wrong. Two different problems hide under one word.

Further training of an existing model on your own data to shape its behaviour.

Fetch the relevant documents first, then let the model answer using them.

A list of numbers that places text near other text with similar meaning.

Storage and search built for embeddings rather than exact values.

The neural network design behind nearly every modern language model.

The mechanism that lets each token weigh the relevance of every other token.

Storing weights in fewer bits so a model runs with less memory and cost.

A model that handles more than one kind of input or output: text, image, audio, video.

Training a small model to imitate a large one, keeping most of the capability at a fraction of the cost.

A model with many specialist sub-models, of which only a few run per token.

One round-trip from the harness to the model provider. The unit that tokens are billed on.

Tokens the harness sends on each request. Billed at a lower rate than output tokens.

Tokens the model generates back. Billed at a higher rate, because generating costs more than reading.

Input tokens the provider cached from a previous request, billed at a much lower rate.

The provider-side store that lets consecutive requests skip re-processing a shared prefix.

What the model actually does. Samples one next token from the context, appends it, and runs again.

A dial for how much reasoning the model does before it answers. More effort means a better shot at hard problems.

Carries no information forward. The model is stateless across requests; an agent is stateless across sessions by default.

Carries information forward. Sessions are stateful across turns; agents can be made stateful across sessions.

The relevant information the agent has access to right now. A measure of quality, not quantity.

Each token has a finite amount of influence to distribute across the rest of the context.

The pairing between two tokens. Meaningful pairs influence each other more than unrelated ones.

Facts the agent can read directly from the context right now. Counterpart to parametric knowledge.

What the model knows from training, stored in its parameters. Frozen at training time.

Early in a session the agent is sharp. As the session grows it drifts into the dumb zone.

Ending the current session and starting a fresh one. The next message begins with an empty context.

Compaction triggered automatically by the harness when the context window approaches full.

A system that makes an agent stateful across sessions by persisting to the environment and reloading at session start.

A file in the environment that the harness loads into the context at session start: the project's standing brief to the agent.

A mention in one document that points to another, so the agent can pull it in only when the task calls for it.

A teachable capability bundled as a unit, kept out of the context window until a pointer pulls it in.

The world the agent acts on: anything outside the harness that it perceives via tool results and changes via tool calls.

A tree of files and directories the agent reads from, writes to, and executes within.

What the harness shows the user before executing a tool call that is not pre-approved.

The permission-gating slice of an agent mode: which tool calls trigger a request and which run automatically.

An isolated environment the agent runs inside: container, VM, or restricted shell. It limits the blast radius.

A deterministic verification that runs in the environment: tests, type checks, lints, build. Pass or fail, no judgement.

An agent reviewing another agent's work, often with a different model or system prompt. It forms a judgement.

The user reading the code the agent produced and forming a judgement on it. Reading the diff counts; reading the summary does not.

A working pattern where the user starts a session and leaves the agent to run unattended.

The shared understanding of what is being built, held in common between user and agent but separate from any asset.

A technique for developing a design concept: the agent interviews the user one decision at a time.

Having the agent build a quick, rough version when conversation is too low-fidelity and you need a real artefact to talk about.

Developer experience: how easy a codebase and its toolchain make it for humans to do good work.

Agent experience: how well the environment is set up for an agent to do good work.

A system of work where triggers, not humans, start agent sessions, so more work runs AFK.

A codebase, or part of one, where a software factory writes the code and no human ever reviews it.

A document used as the carry mechanism for a handoff: written by one session, read by another.

The thing itself: code, transcripts, raw data. Complete and authoritative, but expensive to load.

An account of a primary source, one step removed. Cheap to load, lossy by construction.

A model with tools, a system prompt, and a loop that lets it act and observe results.

Everything around the model that turns it into an agent: tools, system prompt, permissions, hooks.

The repeated cycle of decide, act, observe. Where autonomy actually comes from.

A function the model is allowed to call, like reading a file or running a command.

The model's request naming a tool and its arguments. Structured output, not a side effect.

What the harness sends back after running a tool: file contents, command output, an error.

A standard way to plug external tool servers into an agent harness.

Deciding what goes into the model's context, and what stays out.

The craft of writing instructions a model follows reliably.

Showing the model two or three examples of the task instead of describing it.

The model adapts to a task from the context alone, without any training.

Several agents with separate roles working on one task, often with one coordinating the others.

An agent spawned by another agent to do one scoped job in its own context.

Checks that stop or constrain an action before it happens.

A person who reviews, approves, or corrects the agent's work at key points.

A defined way for one program to ask another for something.

A packaged library that wraps an API so you do not have to call it by hand.

The company that serves a model to you. Usually someone else's server.

What you pay for each unit of text the model reads or writes.

Storing results so the same work is not repeated, and the cost drops with it.

How long you wait. The time to the first token matters more than the total.

Sending the output as it is generated instead of waiting for the whole answer.

A cap on how fast you may call the API, and the most common cause of failures at scale.

Measuring whether the system does the job, on a fixed set of cases, repeatedly.

Using a model to score another model's output against a rubric.

A fixed, reviewed set of real cases the system is measured against.

A shared test that lets you compare systems. Useful, and easy to over-trust.

A change that made something worse. The reason to keep tests at all.

Running the model on your own machine or server, with no provider in the loop.

Getting a working system in front of real users, reliably, and keeping it there.

Watching a running system so you learn about drift before your users complain.

Text that tries to make the model ignore its instructions and follow the attacker's instead.

The model agrees with you because you believe it, not because it is right.

The slow loss of quality as a session grows, even though nothing broke.

Summarising the old conversation so the new part fits in the window.

The date after which the model has no trained knowledge at all.

Tying the answer to something checkable, so it can be verified instead of trusted.

The agent stops pursuing the original goal and starts optimising a nearby one.

Making a system's behaviour match what people actually want, including the parts nobody wrote down.

A prompt that talks a model past its safety rules.

Trusting the output because it is well written, not because it is right.

The same input can produce a different output each time. Normal, and worth designing around.

Writing software by describing what you want and accepting the result without reading it closely.

A second pass by someone who did not write the code, looking for what the author missed.

The cheapest way to know a change is safe: a check that runs without a human reading anything.

A written description of what to build, written before building it.

What happens when a context keeps everything: it grows, and the useful parts get harder to find.

A process where an agent does a meaningful part of the work, not just answers a question about it.

Show the model only the detail it needs right now, and load more when it asks.

A system's ability to carry information from one request to the next.

One bounded run of work with an agent, from the first message to the end.

One user message plus everything the agent does in response to it.

The rules about whose personal data you may hold, and what you must do with it.

Information that identifies a person, directly or through a combination of details.

The rules and habits that decide what data exists, who may use it, and how long it lives.

Meeting the legal rules that apply to what you built, in the place you built it.

The EU's rules for AI, tiered by how risky the system is.

Who owns what the model produced, and what it was trained on.

A model whose weights you can download and run yourself, under a licence that says what you may do.

The organisational work of getting people to actually use a tool that works.

Whether the thing paid for itself. Usually measured badly, in both directions.

Teaching a team to use these tools well, for their actual work.

Getting people to work differently, and keeping them doing it after the enthusiasm fades.

The rules your organisation sets for how AI is used, and who is accountable for them.

AI tools people use at work that the organisation has not approved or does not know about.

The electricity and hardware behind the models, and what it means for who gets to use them.

A collection of examples used to train, evaluate, or ground a system.

Attaching the right answer to each example so a model can learn from it.

Search that matches on meaning rather than on the exact words typed.

The step that finds the material a model will answer from.

Making the model answer in a fixed shape a program can read.

Connecting your system to the other systems it needs to work with.

A tool that lets the model look things up instead of guessing.

A pointer from a claim back to the material that supports it.

The architecture behind most image and video generators.

A model that reads images, turning them into something a language model can reason over.

Each token has a limited influence to spend, and later tokens crowd out earlier ones.

A preset that bundles permissions and behaviour, like a profile for the agent.

The moment a person says yes before the agent does something it cannot undo.

Moving work from one session, or one agent, to another without losing the thread.

A unit of work small enough to be scoped, done, and checked.

A person with the authority and the information to actually stop the system.

Software whose licence says what you may do with it, and what you must share.

A property of information: who can see it, who can use it, and who cannot be told.

Being able to see inside a running system well enough to explain what it did.

A written set of criteria a judge, human or model, scores against.

Deciding which model or path handles a request before you send it.

A systematic skew in what a system produces, inherited from the data it learned on.

The rules that decide what the agent is allowed to touch.

Turning an image of text into text you can select and search.

The recorded path of one request through the whole system.

The legal permission to use something, and the conditions attached to it.