An experienced engineer knows which documents to trust, which service owns a behavior, and whom to ask when the code doesn't explain a decision. Much of that knowledge is absent from an agent's starting context. Giving it repository access can still leave it unable to make the choices the task requires.
The opportunity is to make relevant understanding easier to find and maintain for everyone. That begins with the work and the questions it raises, rather than a project to connect every organizational system at once.
Start with the questions the work requires
A recent task can reveal which information made the difference. An implementation may depend on a compatibility decision, a customer commitment, a deployment constraint, or experience from an incident. Asking the people who completed it what they had to find is a practical way to identify missing context.
The next question is where that information should be maintained. Repository conventions fit near the code; product priorities may live with planning; operational decisions may be maintained by the service team. Moving everything into an agent prompt can make it available temporarily while making it harder to keep current.
Some questions expose a disagreement rather than a missing document. If two teams have different expectations for an interface, retrieval alone won't resolve it. The agent needs a route to ask for a decision instead of selecting whichever statement appears first.
Provide a short route into the project
A project instruction file can orient an agent: where the code and tests are, how to run relevant checks, and where important decisions are recorded. It works best as an introduction to maintained information rather than a copy of everything the team knows. Exact commands and paths matter here because they connect the explanation to an action.
GitLab supports AGENTS.md in supported agent experiences, with differences by interface and Flow.1 Confirming how the intended experience receives instructions avoids a common gap: a file that looks complete to its author but never reaches the agent doing the work.
Task-specific context can then stay with the task. A defect report needs the observed behavior and enough information to investigate; a migration needs the compatibility and rollout decisions. Project-wide instructions shouldn't have to grow every time someone requests a different change.
Connect information where relationships matter
A file search can locate a function without explaining which projects depend on it. Likewise, a deployment record may show what changed without explaining why the change was chosen. Links between decisions, changes, dependencies, and operating results help a participant follow those questions.
The connection can be as simple as linking the relevant work item and merge request. Where the question spans projects or systems, search, knowledge graphs, and tool integrations can help gather information the agent couldn't otherwise reach. GitLab Orbit and MCP are options to investigate where their documented coverage fits the task; neither is a prerequisite for every use of AI.
The integration's response should make its limits understandable. No result could mean no relationship, but it could also mean missing access, stale information, or a system that wasn't searched. Trying a known example helps establish which interpretation is reasonable before someone relies on the integration for a consequential decision.
The source and timing of an answer matter when the next action depends on it. An agent may correctly identify a dependency from an older index while missing a consumer added yesterday. Keeping a route back to the underlying record lets the next participant check the current situation. When work waits for approval or moves to another agent, a changed source should prompt reconsideration rather than being hidden by a confident summary.
Preserve access and distinguish facts from instructions
Connecting a source also creates a path through which information reaches a model or tool. The team's access and data-handling decisions need to cover that path, including what the integration retrieves and where it sends the result. A broadly privileged connector can disclose information that the person starting the work couldn't access directly.
Documents, issue comments, and logs can contain instructions written by someone who doesn't control the task. Treating retrieved text as authoritative direction can therefore change more than the agent's understanding. Permissions and tool controls help limit the actions it can take; clear instructions help it distinguish information to inspect from permission to act.
More access isn't always the answer to an incomplete result. Sometimes the right response is a person supplying an approved extract, confirming a missing fact, or limiting the conclusion. The team should be able to tell which information was unavailable without receiving a confident answer that conceals the gap.
Review context through the work it supports
Recurring errors provide a starting point for maintenance. A wrong build command suggests stale project instructions. A mistaken dependency assumption may reveal a missing relationship or an index that no longer reflects the projects involved. Adding a longer prompt won't necessarily address either cause.
A small collection of representative questions can help the team assess changes to retrieval, permissions, and instructions. Include cases where the correct response is to ask for clarification or report missing access. Answers that sound convincing are less informative than whether the agent found the right information and used it appropriately.
Ownership keeps that improvement going. The team maintaining a source should know when its changes affect agent use, and the team operating the integration should know how to report gaps. Keeping the feedback close to those responsibilities lets context improve with the organization instead of becoming another neglected copy of its documentation.
Further Reading
Notes
-
GitLab's
AGENTS.mdsupport is available in Premium and Ultimate. The documentation explains supported interfaces and the Code Review Flow exception. ↩
- GitLab Orbit describes the context capabilities and their availability to consider for connected project information.
- Model Context Protocol explains the integration options for connecting agents and external tools.
- Security threats in agentic systems helps review how retrieved content and tool permissions interact.