GitHub Certified: Agentic AI Developer key terms

A software process that uses a language model to plan and carry out multi-step work in a repository - reading files, editing code, running commands, and opening pull requests - with limited direct human supervision.

One bounded execution of an agent against a task, from the triggering event to final output or termination, capturing every step taken and every artifact produced along the way.

The event that starts an agent run, such as an issue assignment, a pull request comment, a scheduled job, or a manual dispatch from a workflow.

The end-to-end cycle in which an agent reads an issue, plans changes, edits the codebase, runs tests, and opens a pull request that humans review before merge.

A version-controlled document in the repository that gives the agent its role, project conventions, build commands, and constraints, loaded into context at the start of each run.

A declarative configuration setting an agent's name, description, model, available tools, and instructions so it can be selected and invoked consistently across workflows.

A single invocation by the agent of an external capability such as file read or write, shell execution, code search, or an API request, whose result feeds back into its reasoning loop.

An explicit set of tools and resources an agent may use, with everything else denied by default, so capabilities are limited to what the task actually requires.

A service exposing tools, resources, and prompts over the Model Context Protocol so an agent can reach external systems through a standard, discoverable interface instead of bespoke integrations.

The bounded amount of text, code, and tool output a model can consider at once; managing it means selecting, summarizing, or discarding information as a run progresses.

The process of choosing which repository files, search results, and history to place in an agent's prompt so the model has the most relevant evidence within its context budget.

Information an agent persists across runs or turns, such as prior decisions, learned conventions, or task state, stored outside the model's transient context so it can be reused later.

A model setting controlling how much randomness is used when generating output; lowering it makes agent behavior more repeatable, which matters when the same task must yield stable results.

A checkpoint where an agent must stop and wait for a named human to approve, edit, or reject an action before it continues, typically before merging, deploying, or changing protected settings.

The configured degree of independence granted to an agent, ranging from suggest-only output through draft pull requests to fully automated merge, matched to the risk of the task.

A hard constraint enforced outside the model, such as blocked paths, prohibited commands, or required checks, that stops an agent from taking an action even when it decides to.

An isolated, disposable execution environment with restricted network and filesystem access where an agent runs code, so mistakes or malicious actions cannot reach production systems.

A credential scoped to the minimum permissions and repositories needed for one agent run, with a short lifetime, so a compromised or misbehaving agent cannot exceed its intended reach.

The practice of keeping credentials out of prompts, logs, and repository content, injecting them only at runtime and redacting them from any agent output that might be recorded.

An attack in which untrusted content the agent reads - an issue body, a file comment, a web page - contains instructions that hijack its behavior and redirect its actions.

A design rule treating all externally supplied text as data rather than instructions, keeping it out of privileged prompt positions and requiring human approval before acting on it.

Predefined rules deciding when an agent should stop and hand a task to a human or higher-authority agent, such as repeated failures, ambiguous requirements, or high-risk changes.

The transfer of a task, together with its accumulated context and state, from one agent or human to another when the work exceeds the current owner's scope or authority.

An agent whose job is to decompose a goal, assign subtasks to specialist agents, track their progress, and combine or reject their outputs rather than performing the work itself.

Coordinating several agents with distinct roles and tools on one problem, including routing, sequencing, conflict resolution, and shared state, so their combined output stays coherent.

A cap on how many agent runs or tool calls may execute at once, protecting rate limits, shared resources, and cost while keeping queued work fairly ordered.

A retry strategy that waits progressively longer after a throttled or failed call, often with randomized jitter, so an agent recovers from transient limits instead of hammering the API.

Designing agent actions so that repeating them produces the same end state, preventing duplicate pull requests, comments, or deployments when a step is retried after failure.

A per-run or per-project ceiling on model usage and spend that halts or downgrades an agent's work when exceeded, keeping autonomous activity economically bounded and predictable.

A structured record of every step in an agent run - prompts, tool calls, outputs, timings, and costs - used to debug behavior and reconstruct what happened after the fact.

An append-only record of who or what triggered each agent action, what changed, and which approvals were granted, kept for compliance review and incident investigation.

A repeatable test setup that runs an agent against a fixed set of tasks and scores the results, so changes to prompts, models, or tools can be compared objectively.

A curated collection of representative tasks with known-good expected outcomes, used as a stable benchmark against which successive agent versions are measured over time.

Written criteria describing what a good agent output looks like across dimensions such as correctness, completeness, and adherence to convention, used to score results consistently.

Using a separate model to grade an agent's output against a rubric, which scales qualitative review but requires calibration against human ratings before it can be trusted.

The set of evaluation tasks re-run whenever an agent's model, prompt, or tools change, catching cases where previously working behavior has degraded.

A gradual change in an agent's outputs or success rate over time caused by model updates, tool changes, or shifting inputs, detected by comparing against established baselines.

Concrete, checkable conditions defining when a task is complete, giving the agent a clear target and giving reviewers an objective basis for accepting its work.

Restoring a repository or deployment to a known-good prior state when an agent-produced change causes failures, ideally through a tested, automated path rather than manual repair.