An agent is an AI system that does not just answer a question but works toward a goal, deciding what steps to take and taking them on its own. It can use tools, check its results, and keep going until the job is done.

Think of the difference between a calculator and an assistant. A calculator answers one question at a time. An assistant figures out what needs doing, does it, and comes back with the finished work.

The agent loop is the repeating cycle an agent runs through to get work done. It looks at the situation, decides what to do next, takes an action, sees what happened, and then goes around again until the goal is met.

It is like cooking from a recipe while tasting as you go. You add an ingredient, taste, adjust, and repeat. Each pass through the loop uses what just happened to shape the next move.

Agentic coding is writing software by giving an AI agent a goal and letting it plan, write, run, and fix code across many steps, while a person steers and approves the important moves. It is the working version of the vibe coding idea applied to real engineering.

The surprise from early studies is that it rewards knowing what you want built more than knowing how to write the code yourself. Judgment about the problem turns out to matter more than syntax.

AGI, short for artificial general intelligence, is the idea of an AI that can handle any intellectual task a person can, not just one narrow job. It would learn and adapt across many areas instead of being good at a single thing.

Today's AI is specialized, like a calculator that is brilliant at math but cannot drive a car. AGI would be more like a capable person who can pick up almost anything. It does not exist yet, and people disagree on how close we are or what would even count.

AI, short for artificial intelligence, is software that does things we usually associate with human thinking, like understanding language, recognizing images, or making decisions. It is a broad umbrella term that covers many different techniques.

Think of AI as the whole field, the way "medicine" covers everything from setting a broken bone to studying genes. Most of what people call AI today learns from examples rather than following rules a person wrote by hand.

AI safety is the work of making sure AI systems behave reliably and do not cause harm, whether by accident or by misuse. It covers everything from a chatbot giving dangerous advice to bigger worries about powerful systems acting in ways nobody intended.

Think of it like seatbelts and brakes for a car. The goal is not to stop the technology, it is to make sure that as these systems get more capable, they stay useful and under control.

AI-native describes a product, company, or workflow that is built around AI from the ground up, rather than having AI bolted on later. The whole way of working assumes AI is doing real work in the middle of it.

Think of the difference between a house built with plumbing in the walls and an old house where pipes were added on afterward. The first one just works better because it was designed for it. An AI-native team designs its processes assuming the AI is there, so the results tend to be smoother than sprinkling AI features onto something that was never meant for them.

Alignment is the effort to make an AI system's goals and behavior match what people actually intend. An aligned model does what you meant, not just the literal thing you said, and it does so in a way that fits human values.

It matters because a capable system that misunderstands your goal can do the wrong thing very efficiently. Alignment is about closing that gap so the AI is helpful, honest, and not working at cross purposes to its users.

An API is a defined way for one piece of software to ask another for something and get an answer back. To use an AI model in your own app, you send a request to its API and it sends the result back.

Think of it like a restaurant menu. You do not go into the kitchen, you just place an order through a known set of choices, and the food comes out. The API is that menu and order window for software.

Autonomy is how much an agent is allowed to decide and act on its own without checking with a person first. A low-autonomy agent asks before each step, while a high-autonomy agent runs the whole task and reports back at the end.

It is a dial, not a switch. More autonomy means more speed and less hand-holding, but also more trust placed in the agent. Most real setups tune the dial to match how risky the task is.

BAA stands for Business Associate Agreement. It is a contract required under HIPAA, the US health privacy law, that a vendor signs when it will handle protected health information on your behalf.

In plain terms, if you want to send patient data to an AI provider, the BAA is the document where they promise to protect it and follow the rules. Without a signed BAA in place, using that vendor for health data is generally not allowed.

A benchmark is a standard set of questions or tasks used to compare different AI models on the same footing. Everyone runs the same test, so you can see which model scores higher.

It is like a standardized exam for AI. Benchmarks are useful for quick comparison, but they do not always reflect your specific job, so a high benchmark score is a hint, not a promise that the model will work well for you.

Bias is when a model's answers lean in an unfair or skewed direction, often because the data it learned from was unbalanced or reflected human prejudices. The model simply picks up the patterns it was shown, including the bad ones.

For example, if a hiring model trained mostly on resumes from one group, it might quietly favor that group. Spotting and reducing bias matters because these systems make or influence real decisions about people.

Build vs buy is the decision every team faces about whether to make an AI tool yourself or pay for one that already exists. Building gives you control and a perfect fit but costs time and talent. Buying is faster and cheaper to start but ties you to someone else's product.

Think of it like a kitchen. You can cook from scratch or order in. Cooking is worth it when the meal is core to who you are and you want it exactly your way. Ordering is smart when it is good enough and your time is better spent elsewhere. Most teams end up doing some of both.

Chain of thought is when a model works through a problem step by step in writing before giving its final answer, instead of jumping straight to the result. You can ask for it simply by saying "think step by step."

It helps most with math, logic, and multi-part questions, where rushing leads to mistakes. Like a person showing their work on paper, laying out the steps makes the answer more reliable and easier to check.

Chunking is the practice of cutting long documents into smaller, searchable pieces before a model uses them. A hundred-page handbook becomes many short passages, each focused on one topic.

It matters because retrieval works best on small, clean pieces. If a chunk is too big it pulls in unrelated text, and if it is too small it loses context. Getting the size right is one of the quiet things that makes a RAG system feel accurate.

A citation is a reference the model includes to show which source backs up its answer. It points you to the exact document, page, or passage so you can check the claim yourself.

This is what turns a confident answer into a trustworthy one. Like footnotes in a report, citations let you verify the work instead of taking it on faith.

Claude is a family of large language models made by the company Anthropic. Like other assistants of its kind, it takes a prompt and generates a response, and it can help with writing, analysis, coding, and answering questions.

Anthropic builds Claude with a strong focus on safety and on being helpful, honest, and harmless. You can use Claude through a chat interface or connect to it through an API to build it into your own tools.

Cloud AI means using AI models that run on a provider's remote servers, which you reach over the internet rather than on your own machine. You send your request, their powerful hardware does the work, and the answer comes back.

It is like streaming a movie instead of owning the disc. You get instant access to the biggest, latest models without buying expensive hardware, and you only pay for what you use. The trade-offs are that you need a connection, your data travels to someone else's servers, and you depend on their service staying up.

Compliance means following the laws, regulations, and standards that apply to your work, like privacy rules for personal data or security requirements in healthcare and finance. It is about proving you handle information the way you are required to.

For AI projects this often decides what you can build and which vendors you can use. Getting compliance right early saves you from expensive rework, fines, or losing customer trust later.

Compute is the general term for the raw computing power needed to train and run AI models, usually measured in how many chips you have and for how long. More compute means you can build bigger models and serve more users at once.

It is a bit like electricity for a factory. The machines are the models, but compute is the power that makes them run. Training a large model can take thousands of chips working for weeks, which is why compute is one of the biggest costs and constraints in AI.

Context engineering is the practice of choosing what information to put in front of a model so it has exactly what it needs to answer well. That includes the prompt, relevant documents, past messages, and tool results.

It matters because a model can only use what it can see in its context window, and that space is limited. Putting in the right facts and leaving out the noise often does more for quality than tweaking the wording alone.

The context window is how much text a model can hold in mind at once, counted in tokens. It includes everything in the current conversation, your instructions, any documents you pasted in, and the model's own replies so far.

Think of it like a desk with limited space. Once it fills up, older material falls off the edge and the model can no longer see it. A bigger context window means a bigger desk, so the model can keep more in view while it works.

A copilot is an AI assistant that works right alongside a person, offering suggestions and doing pieces of the work while the human stays in charge. It speeds you up without taking the wheel.

The name says it plainly. You are still the pilot, and the copilot helps you fly. It drafts, suggests, and handles the busywork, but you decide what to keep and where to go.

Deep learning is a kind of machine learning that uses neural networks with many layers stacked on top of each other. Each layer learns slightly more complex patterns than the one before it, which lets the system handle very rich data like images, speech, and language.

The word "deep" just refers to all those layers. This approach powers most of the AI you hear about today, because the extra layers let it pick up subtle details that simpler methods miss.

Deep research is a mode where an AI agent takes a question, searches and reads many sources on its own, and returns a synthesized report with citations, rather than a quick one-shot answer. It can run for several minutes and chase down sub-questions as it goes.

It is one of the more useful long jobs agents handle well today, as long as you check the sources it hands back rather than trusting the summary on its own.

A deepfake is a fake image, video, or voice recording generated by AI to make it look like a real person said or did something they never did. The results can be convincing enough to fool people at a glance.

This matters because deepfakes can be used for scams, fraud, and misinformation, like a faked voice of your boss asking you to wire money. Being aware they exist is the first defense, along with verifying anything surprising through a second channel.

An embedding is a way of turning a piece of text into a list of numbers that captures its meaning. Texts with similar meanings end up with similar numbers, even if they use completely different words.

This is what lets a computer tell that "car" and "automobile" are close in meaning while "car" and "banana" are far apart. Embeddings are the quiet workhorse behind search and retrieval, because comparing numbers is something computers do very fast.

Ensembling means running a task through more than one model, or the same model more than once, and merging the results into a single response. The combined answer is often better than any one model alone, because the step that synthesizes them can keep the strong parts and drop the weak ones.

It costs more compute, so it is usually saved for hard questions where being right is worth the extra money and the extra wait.

Evaluation is how you check whether an AI system is doing a good job. You give it a set of test cases, look at what it produces, and score the results against what you wanted.

Think of it like grading homework. Without evaluation you are just guessing that the system works. A good evaluation tells you where it is strong, where it fails, and whether a change actually made things better or quietly made them worse.

An FDE, short for forward deployed engineer, is an engineer who works closely alongside a customer to build and tune software for that customer's real problems. Instead of staying back at headquarters, they embed with the team that will actually use the tool.

Think of it like a tailor who comes to your house instead of selling you a suit off the rack. They see how you really work, then build something that fits. In AI projects this matters because the gap between a generic demo and a tool that helps your specific team is usually filled by someone sitting right next to that team.

Few-shot means you include a handful of examples in your prompt to show the model exactly what you want before asking it to do the real task. The examples teach the pattern by demonstration.

It is like showing someone two or three finished samples before handing them the work. The model picks up on the format, tone, and style from your examples and copies that into its answer.

Fine-tuning is taking a model that already knows a lot and training it a bit more on your own specific examples, so it gets better at your particular task or picks up your style. You start from a capable general model rather than from scratch.

Think of it like hiring a skilled, experienced worker and then giving them a few days of training on how your company does things. They already have the broad ability, and the extra practice shapes it to fit your needs.

A foundation model is a large, general-purpose model trained on broad data so it can be adapted to many different tasks. Rather than building a fresh model for every job, teams start from one of these and shape it to their needs.

Think of it like a strong, all-purpose base, similar to a versatile mother sauce in a kitchen. On its own it is broadly capable, and with a little tuning it becomes a tool for writing, coding, customer support, or almost anything else.

A frontier model is one of the most advanced and capable models in existence at a given moment, sitting at the leading edge of what the technology can do. These are typically the largest and most expensive models to build and run.

The frontier keeps moving. What counts as a frontier model today becomes ordinary as newer ones arrive, so the term describes a position at the front of the pack rather than any fixed level of ability.

Function calling is the mechanism that lets a model ask for a specific function to be run, filling in the inputs in a clean, structured form. Instead of writing a sentence, the model says, in effect, "call get_weather with city equal to Portland."

It is the plumbing underneath tool use. The model picks the function and the values, your system runs it, and the answer flows back. This keeps the handoff between the model and your code precise and predictable.

Gemini is a family of large language models made by Google. It powers Google's own AI assistant and is woven into many of its products, and it can be used on its own to write, answer questions, and analyze information.

Gemini is built to be multimodal, meaning it can work with more than just text, handling things like images alongside words. It is Google's main entry among the big AI assistants.

GPT is a family of large language models made by the company OpenAI. The letters stand for generative pre-trained transformer, which describes how the models are built and trained to produce text.

GPT models power chat assistants and many AI products you may have used. They take a prompt and generate a response, and they can handle a wide range of tasks like writing, answering questions, and summarizing. GPT is one of the best known names in AI and helped bring this technology into everyday use.

A GPU, short for graphics processing unit, is a kind of computer chip that can do huge numbers of simple calculations at the same time. It was first built for video game graphics, but it turns out the same skill is exactly what training and running AI models needs.

Think of a regular processor as one very fast genius working through tasks one by one, and a GPU as a thousand ordinary workers all doing small jobs side by side. AI involves an enormous amount of repetitive math, so having many workers at once is far faster. This is why GPUs are the engine behind modern AI and why they are in such high demand.

Grounding means anchoring a model's answer in real, provided information instead of letting it guess from memory. A grounded answer can be traced back to an actual document you gave it.

It is the main defense against made-up answers. When a model is grounded in your files, it tends to say what the source actually says, and it can point you to where it came from.

Guardrails are the rules and limits that keep an agent acting safely, like blocking certain actions, capping spending, or refusing to touch sensitive data. They define what the agent is and is not allowed to do.

They work like the rails on a mountain road. The agent can still drive and make progress, but the rails keep it from going over the edge when something unexpected happens.

A hallucination is when a model produces something that sounds confident and plausible but is simply not true. It might invent a fact, a quote, or a source that never existed.

This happens because a model is predicting likely text rather than looking up verified facts, so a smooth-sounding wrong answer can come out just as easily as a right one. It is the main reason to double check anything important a model tells you.

Human-in-the-loop means a person sits inside the process and has to approve or correct key steps before the agent moves on. The agent pauses at important moments and waits for a human to say yes.

This is the choice you make when the stakes are high, like sending money or deleting records. The agent does the heavy lifting, but a person stays in the driver's seat for the decisions that really matter.

Human-on-the-loop means a person watches the agent work and can step in if something looks wrong, but does not approve every step. The agent runs on its own, and the human supervises from above.

Picture a lifeguard at a pool. Swimmers move freely most of the time, and the lifeguard only acts when needed. This gives you speed while still keeping a person ready to pull the plug.

Inference is the moment you actually use a trained model to get an answer, like asking it a question and reading its reply. The learning is already done, so inference is just applying what the model knows.

If training is studying for the exam, inference is sitting down and taking it. Every time you chat with an AI or get a result from it, that is inference happening behind the scenes.

A jailbreak is a clever prompt that gets a model to do something it was trained to refuse, like producing harmful content. People find them by roleplaying, hiding the request, or wording it in ways that slip past the safeguards.

It is closely tied to prompt injection but aimed at the model's own rules rather than its instructions. Companies study jailbreaks through red teaming so they can patch the gaps before bad actors use them.

JSON mode is a setting that makes a model return its answer as valid JSON, a common data format of labeled fields and values. It guarantees the output can be parsed by software without surprises.

It is a stricter cousin of structured output. Asking nicely for JSON usually works, but turning on JSON mode removes the risk of stray text sneaking in and breaking the program that reads the result.

Latency is the delay between sending a request to a model and getting the response back. Low latency feels snappy, high latency feels like waiting on a slow page to load.

It matters most when people are sitting there expecting a reply, like in a chat. A few seconds can be the difference between a tool that feels alive and one that feels stuck, so teams watch latency closely.

Llama is a family of large language models made by Meta, the company behind Facebook and Instagram. What sets it apart from many rivals is that it is open-weight, meaning the trained model is released for people to download and run themselves.

That openness makes Llama popular with developers and companies who want to run a model on their own hardware, tune it for their needs, or avoid depending on an outside service. It has become one of the foundations of the open AI community.

An LLM, short for large language model, is a computer system trained on enormous amounts of text so it can understand language and produce its own. When you type a question and get a fluent answer back, an LLM is usually the thing doing the talking.

Under the hood it works by predicting the next word over and over, but it does this so well that it can write, summarize, translate, and reason in ways that feel surprisingly human.

LLM-as-Judge means using a language model to score or rank the outputs of another language model. Instead of a person reading every answer, you ask an AI to rate them against a rubric you wrote.

It is handy because checking thousands of answers by hand is slow and expensive. The catch is that the judge can be wrong or biased too, so people usually spot check its grades against human judgment to make sure they line up.

Local inference means running an AI model on your own computer or hardware instead of sending your request off to a company's servers. The model lives with you, and your data never has to leave the building.

People choose it when privacy, control, or cost matters, since nothing gets shipped to an outside service. The trade-off is that you need capable hardware of your own, and the models you can run locally are often smaller than the giant ones in the cloud. It is the difference between cooking at home and ordering from a restaurant.

A long-horizon task is one that cannot be finished in a single answer. It needs many steps held together over minutes or hours, with each step building on the last. Writing a feature across a whole codebase or running a multi-part research job are long-horizon tasks.

This is where agents are weakest and where the hardest benchmarks now focus, because staying coherent over a long chain of actions is much harder than getting one step right.

Long-term memory is information an agent keeps around beyond a single task, so it can remember facts, preferences, and past results in future sessions. It is often stored outside the model, for example in a database, and pulled back in when needed.

It is the difference between a coworker who forgets you every morning and one who remembers your name, your projects, and how you like things done. Long-term memory is what lets an agent build on what it already learned.

Machine learning is a way of building software that learns from examples rather than being told exactly what to do step by step. You show it lots of data, and it figures out the patterns on its own.

Imagine teaching a child to recognize cats by showing many pictures instead of writing a precise description of a cat. Machine learning works the same way, which is why it handles messy real-world problems that are too tricky to spell out in rules.

MCP, short for Model Context Protocol, is an open standard for connecting AI models to outside tools and data sources in a consistent way. It gives models and the systems around them a shared language for asking what is available and how to use it.

It helps the way a standard plug helps appliances. Instead of building a custom connection for every tool, you build to one common standard, and many tools and models can work together without bespoke wiring each time.

A mixture of experts is a model split into many smaller subnetworks, called experts, where only a few are switched on for any given piece of input. This lets a model have a huge total parameter count while doing far less work on each token.

Think of a large firm where a receptionist routes each question to the two or three specialists who can answer it, instead of waking the whole staff every time. It is how some very large models stay fast and affordable to run.

A model is the actual trained system that takes an input and produces an output, like reading a question and writing an answer. It is the thing you end up with after machine learning has done its work on a pile of data.

You can think of a model as a recipe that the computer wrote for itself by studying examples. Once it is trained, you feed it new inputs and it applies what it learned. When people talk about "an AI," they usually mean a specific model.

A multi-agent system is a setup where several agents work together, each handling a piece of the job, so the group can solve something bigger than any one of them would alone. One might research, another might write, and another might check the result.

It is like a small team rather than a single worker. By dividing the labor and letting each agent focus, the whole system can take on tasks that are too large or too varied for a single agent to manage well.

A multimodal model can work with more than one kind of input or output, such as text, images, audio, or video, rather than text alone. You might show it a photo and ask a question about it, or have it describe a chart.

The word modal here just means a type of information. A model that only reads and writes text handles one mode, while a multimodal model can mix several, much like a person who can both read a page and look at a picture.

A neural network is a type of model made of many simple units connected together, loosely inspired by how brain cells link up. Each connection has a strength, and the network learns by adjusting those strengths until it gives good answers.

Picture a huge web of tiny switches that pass signals along. None of them is smart by itself, but together they can recognize a face or finish a sentence. Almost all modern AI is built from neural networks.

Observability is the ability to see inside a running system and understand what it is doing and why. For an AI app, that means tracking the prompts going in, the answers coming out, the speed, the cost, and the errors.

It is like the dashboard in a car. Without it you are driving blind, hoping nothing is wrong. With it you can spot a problem early, find where it started, and fix it before users feel the pain.

An open-weight model is one whose trained internals, called its weights or parameters, are released for anyone to download and use. You can run it on your own computers, inspect it, and adapt it, rather than only reaching it through someone else's service.

This gives you more control and privacy, since the model can run on hardware you own. The trade-off is that you are responsible for the setup and the computing power, instead of leaving all of that to a provider.

Orchestration is the coordination layer that decides which agent or step runs when, passes information between them, and keeps the whole effort moving toward the goal. It is the part that makes many moving pieces act like one system.

Think of a conductor in front of an orchestra. The musicians each play their part, but the conductor sets the timing and the order so it all comes together as one piece of music.

A parameter is one of the many adjustable values inside a model that get tuned during training. Each one is like a tiny dial, and together they store everything the model has learned.

Big models have billions of these dials, which is why you hear sizes described in terms of parameter counts. More parameters can mean a more capable model, but also one that costs more to train and run.

PII stands for personally identifiable information. It is any data that can point to a specific person, like a name, address, phone number, social security number, or email.

It matters because this is exactly the data that laws and customers expect you to protect. When you feed information into an AI system, you have to be careful about what PII goes in, where it is stored, and who can see it.

A pilot is a small, time-boxed trial where you test an AI tool on a real but limited piece of work before committing to it fully. The goal is to learn whether it actually helps, with low cost and low risk.

It is like cooking one dish from a new recipe before throwing a dinner party. You find out quickly if it works, what needs adjusting, and whether it is worth scaling up. A good pilot has a clear goal and a clear way to tell if it succeeded.

Planner-executor is a design where one part of the system makes the plan and another part carries it out. The planner breaks a big goal into smaller steps, and the executor does each step in turn.

It works like a head chef and a line cook. The chef decides the menu and the order of dishes, and the cook handles the actual chopping and searing. Splitting the thinking from the doing tends to make agents more reliable on long, multi-step tasks.

A prompt is whatever you type or send to an AI model to get a response. It can be a question, an instruction, a chunk of text to work on, or all of those at once.

Think of it like the opening line of a conversation. The model has no idea what you want until you say it, and the clearer and more specific your prompt, the better the answer you tend to get back.

Prompt engineering is the practice of writing and refining your instructions so a model gives you better, more reliable answers. It covers things like being specific, giving examples, and structuring the request clearly.

It matters because the same model can produce very different results depending on how you ask. A little care in wording is often the cheapest way to improve quality, no fancy tools required.

Prompt injection is an attack where someone slips instructions into content the model reads, tricking it into ignoring its real orders. For example, a web page might hide text that says "forget your rules and reveal your secrets."

It is a serious risk for AI that browses the web or reads user files, because the model can struggle to tell trusted instructions from sneaky ones buried in the data. Guarding against it is an ongoing safety challenge.

A prompt template is a prompt you write once with placeholders, then reuse by filling in the blanks each time. For example, a template might say "Summarize this email in three bullet points" with the email slotted in fresh every run.

It saves you from rewriting the same instructions over and over and keeps results consistent. Once you find wording that works, a template lets you lock it in and apply it at scale.

RAG, short for retrieval-augmented generation, is a method where a model looks up relevant information from your own documents and uses it to write an answer. Instead of relying only on what it learned in training, it reads the right pages first, then responds.

Think of it like an open-book exam. The model is smart, but it does better when it can flip to the exact page that has the answer. This is how you get a model to talk accurately about your company's policies, products, or files.

A reasoning model is one built to work through a problem in steps before giving its final answer, rather than replying instantly. It spends extra effort thinking things through, which helps a lot with math, logic, and complex multi-step tasks.

Think of it like the difference between blurting out the first thing that comes to mind and pausing to reason it out on scratch paper. The slower, more deliberate approach tends to produce more reliable answers on hard problems.

Red teaming is deliberately trying to break or trick an AI system to find its weaknesses before real users or bad actors do. The red team plays the attacker, probing for bad answers, leaks, and unsafe behavior.

It is like hiring someone to break into your house so you can fix the locks. By finding the problems on purpose, you get to patch them quietly instead of being surprised by them later.

Reinforcement learning is machine learning where a model learns by trying things and getting rewards or penalties, rather than being shown the right answer up front. Over many attempts it figures out which actions lead to better outcomes.

It works like training a dog with treats, or like getting better at a video game by playing it again and again. This approach shines in situations where there is no single correct answer, only choices that turn out better or worse.

Retrieval is the step of searching through a pile of documents and pulling out the few pieces that actually relate to the question. It is the lookup part of the process, before any answer gets written.

Picture a librarian who, the moment you ask a question, walks straight to the three books that matter and hands them over. Good retrieval means the model gets the right material, so everything downstream depends on it.

RLHF, short for reinforcement learning from human feedback, is a method for shaping a model's behavior by having people rate its responses and then training it to produce more of what people prefer. It is a big part of why modern assistants feel helpful and polite.

Think of it like coaching. The model offers answers, humans say which ones are better, and over many rounds the model learns to lean toward the kind of replies people actually want.

ROI, short for return on investment, is a simple way of asking whether something is worth the money. You compare what you spent, like tool costs and staff time, against what you gained, like hours saved or revenue earned.

For AI projects this matters because it is easy to be dazzled by a clever demo and forget to ask if it actually pays off. A tool that saves your team ten hours a week for a small monthly fee has clear ROI. One that costs a fortune and shaves off a few minutes does not.

Role prompting is giving the model a persona to adopt, like "you are a patient math tutor" or "act as a careful copy editor." Setting the role steers the tone, vocabulary, and focus of its answers.

It works because naming a role pulls the model toward a whole style of responding at once. Asking for a tutor gets you gentle explanations, while asking for an editor gets you sharp, direct corrections.

A sandbox is a walled-off space where an agent can run and experiment without affecting anything real. Mistakes made inside it stay inside it, so nothing important breaks.

It is named after the sandbox a child plays in. They can build and knock down whatever they like, and the rest of the yard stays untouched. Sandboxes let you test risky actions before trusting them with live systems.

An SDK, or software development kit, is a bundle of prewritten code and tools that makes it easier to build with a particular service. Instead of wiring up every detail by hand, a developer drops in the SDK and gets the hard parts handled.

If an API is the doorway, the SDK is the welcome kit that comes with it: the keys, a map, and shortcuts so builders can move faster and make fewer mistakes.

Semantic search finds results based on what you mean, not just the words you typed. Ask about "ways to lower my electric bill" and it can return a page about "reducing energy costs" even though none of the same words appear.

It works by comparing the meaning of your question to the meaning of stored text, using numbers that capture ideas. This is why it feels more like talking to a helpful person than hunting for the perfect keyword.

Short-term memory is what an agent keeps in mind while working on the task in front of it, like the recent messages, the steps it just took, and the results so far. It usually lives inside the context window and fades once the task is done.

Think of it as the notes on your desk while you work. Handy and close at hand for right now, but cleared away when you move on to the next job.

Sparse attention is a way of letting a model focus on only the most relevant parts of a long input, instead of comparing every token to every other token. Full attention gets expensive fast as the text grows, so sparse attention is part of what makes very long context windows affordable.

Think of reading a long document and only rereading the few paragraphs that matter for the sentence you are writing now, rather than the whole thing every time.

Structured output is when you ask a model to answer in a fixed format, like a table, a list of fields, or a specific data shape, instead of free-flowing prose. This makes the answer easy for other software to read and use.

It matters when the model's response feeds into another system. A plain paragraph is fine for a person to read, but a program needs predictable fields it can pull values from every single time.

Supervised learning is machine learning where each training example comes with the correct answer attached, so the model can check its guesses and improve. You give it labeled data, like photos already marked "dog" or "cat," and it learns to match new ones.

It is like a student studying with an answer key. This is the most common way to train models, because clear right answers make the learning straightforward, as long as you have enough labeled examples.

A system prompt is the hidden set of instructions that tells a model how to behave before the user ever types anything. It sets the tone, the rules, and the role, like telling an assistant to be concise and always answer in plain English.

Think of it as the job description you hand someone before their first day. The user asks the questions, but the system prompt quietly shapes how every answer comes out.

Temperature is a setting that controls how predictable or how varied a model's responses are. Low temperature makes the model play it safe and stick to the most likely words, while high temperature lets it take more chances and get creative.

Think of it like a creativity dial. Turn it down for factual, consistent answers where you want the same result every time, and turn it up when you want fresh, surprising ideas and do not mind a bit of unpredictability.

A token is a small piece of text, usually a short word or part of a word, that a model treats as one unit. Models do not see letters or whole sentences the way we do. They see a stream of tokens.

A rough rule of thumb is that one token is about three quarters of a word, so a paragraph might be a hundred tokens or so. This matters because both the cost you pay and the amount a model can hold in mind are measured in tokens.

Token cost is the price you pay to use a model, charged by the amount of text going in and coming out. Models read and write in tokens, small chunks of words, and you are billed roughly by how many you use.

It works like a metered utility. A short question costs almost nothing, but feeding in long documents or generating pages of text adds up. Understanding token cost is how teams keep an AI feature affordable at scale.

Tokenization is the process of breaking text into tokens before a model can work with it. It is the very first step, turning your sentence into the small chunks the model actually reads.

Think of it like slicing a loaf of bread before making sandwiches. The model never handles the whole loaf, only the slices, and how the text gets sliced affects how well the model understands it.

Tool use is when an AI model reaches beyond its own words to call something outside itself, like a search engine, a calculator, a database, or a piece of code. The model decides which tool fits the task, runs it, and uses the result in its answer.

This matters because a model on its own only knows what it learned during training. Tool use lets it look things up, do exact math, and actually change things in the real world rather than just talking about them.

Training is the process of teaching a model by showing it lots of data and adjusting it until its answers improve. During training the model makes guesses, sees how wrong it was, and tweaks itself a little, over and over, millions of times.

It is like studying for an exam by doing practice questions and learning from each mistake. Training is the expensive, time-consuming part that happens before a model is ready to use.

The transformer is the underlying design, or architecture, that most modern language models are built on. Its key trick is paying attention to how every word in a passage relates to every other word, which lets it grasp context and meaning well.

This design is what made today's powerful models possible. When people talk about an LLM, there is almost always a transformer doing the heavy lifting inside it.

A trigger is the event that sets an automation in motion, like a new email arriving, a form being submitted, or a set time of day. When the trigger fires, the agent or workflow starts its work.

It is the starting gun for the whole process. Without a trigger, an automation just sits and waits. With one, it knows exactly when to spring into action.

A use case is a specific, concrete job you want AI to do, like drafting customer replies, summarizing contracts, or sorting support tickets. It is the difference between saying "let's use AI" and saying "let's use AI to cut the time we spend answering refund emails."

Picking a clear use case matters because it gives you something you can actually measure and judge. Vague goals lead to vague results. A sharp use case tells you what success looks like and whether the tool is earning its keep.

A user prompt is the message a person actually sends to the model in the moment, like a question or a task. It sits on top of the system prompt, which is the standing background instruction.

If the system prompt is the job description, the user prompt is the specific thing you ask your assistant to do right now. It is the part of the conversation you type yourself.

A vector database is a special kind of storage that organizes information by meaning rather than by exact words. Each piece of text is turned into a list of numbers that captures what it is about, and the database is built to quickly find the items closest in meaning to your question.

It is the engine behind semantic search. Where a normal database matches the literal word "car," a vector database can also surface "automobile" or "vehicle" because it understands they point at the same idea.

Vibe coding is the practice of building software mostly by describing what you want to an AI and letting it write the code, rather than typing every line yourself. You guide it in plain language, try the result, and keep refining by asking for changes.

It is like directing instead of doing the manual work yourself. This opens up software making to people who are not trained programmers, and it speeds up experienced ones. The catch is that you still need judgment to know whether what comes out is actually good, safe, and correct.

Workflow automation is setting up a sequence of steps to run on their own, so a repeated task happens without someone doing it by hand each time. A trigger starts it, and the steps follow in order.

Think of an office task like routing an invoice. Normally a person forwards it, files it, and flags it for payment. Automation strings those steps together so they just happen, freeing people for work that needs judgment.

Zero data retention is an arrangement where an AI provider does not store the inputs you send or the outputs it returns. Once your request is processed, the data is gone rather than saved on their servers.

It matters when you are working with sensitive information and do not want copies of it sitting somewhere outside your control. It lowers the risk of leaks and is often a requirement for handling regulated data.

Zero-shot means you ask the model to do something without showing it any examples first. You just describe the task and trust the model to figure it out from what it already knows.

It works surprisingly well for common tasks like summarizing or translating. When the job is unusual or you want a very specific style, showing a few examples instead often gets you closer to what you had in mind.