Task Guard is Maetra's control layer for AI agents working across coding, operations, support, research, workflow automation, and MCP-connected environments. It records the user's objective, watches proposed tool calls and changes, and checks whether each action still supports the task the user actually asked for.
The core idea is simple: an AI agent should not treat every plausible next step as authorized. Reading files, modifying source code, running commands, opening pull requests, contacting services, or changing production data can all be useful when they support the goal. The same actions can become risky when the agent has lost context, expanded scope silently, or followed a path the user never approved.
Why task alignment matters
AI agents are powerful because they can plan, inspect, decide, coordinate, communicate, and act across tools. That power also creates a new governance problem. A human reviewer can ask whether the final result is good, but the organization also needs to know whether the agent stayed aligned while it worked.
Misalignment is not always dramatic. It can look like an agent refactoring unrelated files, reading unnecessary data, creating follow-up work outside the request, changing permissions, publishing an artifact too early, or continuing after the user changed direction. These are not classic security failures. They are task-control failures.
Task Guard gives teams a way to govern that behavior directly. It treats the user's goal as a live contract and compares agent actions against that contract as work unfolds.
How Task Guard works
A Task Guard session starts with task context: objective, success criteria, in-scope work, out-of-scope work, constraints, current milestone, and open questions. As the agent proposes or takes actions, Task Guard evaluates whether those actions are directly aligned, supporting, explainable, or outside the accepted task.
For low-risk supporting work, the guard can record the reasoning and let the agent continue. For unclear work, it can require an explanation. For material scope expansion, sensitive actions, or actions with broader effects, it can require user confirmation before the agent proceeds.
This matters because autonomous work is not a single decision. It is a sequence of small decisions. Task Guard makes those decisions inspectable.
What Task Guard checks
Task Guard evaluates the relationship between the action and the task. Is the action required for the objective? Is it a verification step? Is it compatibility repair? Is it supporting research? Is it optional improvement? Or is it unrelated to the user's goal?
It also looks at effect. Reading documentation is different from modifying files. Modifying a local test is different from changing production configuration. Sending a message, granting access, deleting data, purchasing something, scheduling work, or publishing output may require stronger confirmation than ordinary inspection.
The point is not to block useful agents. The point is to make intent, scope, and effect explicit enough that the agent can move quickly without silently changing the assignment.
Task Guard vs ordinary audit logs
Audit logs show what happened after the fact. Task Guard is more specific: it records the task contract, the action's claimed relationship to the task, the guard verdict, confirmations, scope expansions, and the actual effects reported by tools or adapters.
That evidence is useful for engineering managers, security teams, compliance teams, and customers. It can answer questions such as: Why did the agent touch this file? Did the user approve the expanded scope? Was the tool call related to the milestone? Did the reported effect match the predicted effect?
Where Task Guard fits
Task Guard is most useful around agents that can do real work: software delivery agents, repository automation, support automation, operations copilots, custom MCP agents, and internal workflow agents. The higher the autonomy and the more meaningful the tool access, the more valuable task alignment becomes.
It can run in an advisory mode for visibility, a coaching mode for explanations and refocusing, or an enforced mode for confirmation and fail-closed behavior on sensitive actions. Teams can tune the balance based on the agent, environment, and risk.
Best use cases for Task Guard
Task Guard is a strong fit when agents can modify source code, run migrations, call deployment tools, change customer records, communicate externally, move data, grant access, or execute multi-step tasks where scope can drift. It is also useful during audits because it shows not only what changed, but why the agent believed the change belonged to the task.
The outcome is a clearer operating model for autonomous work. Users can delegate more confidently, and organizations can prove that agent actions were tied to approved objectives, confirmations, and evidence instead of loose conversational context.
Task Guard makes agent alignment operational. It turns the question from did the agent do something useful into did the agent stay within the job it was given.