Home / Articles

Managing AI Agents With the CARE Framework: Clarity, Autonomy and More

Managing AI agents with the CARE framework: Clarity, Autonomy, Relationship and Equity applied to delegation, agent contracts, model choice and context.

Publisher: REACTAPP.TOP7 min read1565 words

This article is published in English.

Sources: You Already Know How to Manage Agents: The CARE Framework for AI Engineering

Management training sometimes teaches something that applies to software more directly than expected. The CARE framework from leadership training, with its four principles of Clarity, Autonomy, Relationship and Equity, maps almost one-to-one onto the established practices for running AI agents. Following the same principles while working with agents is a reasonable way to expect better results. Below, each principle is read with an AI agent in the role of the team member being delegated to.

Where things stand

A year or two back, working with a coding assistant looked like a series of small commands: produce a function, patch an error, add tests. Today agents can browse a repository, run shell commands, look things up in documentation, edit several files at once, execute tests and pass work on to subagents. Yet they often still get managed like autocomplete. The bottleneck is increasingly not prompting. It's delegation.

The four CARE questions, in short:

  • Clarity: what does success look like?
  • Autonomy: how much can the person own?
  • Relationship: who should do this work?
  • Equity: what do they need in order to succeed?

Technical managers and leads already know how much each of these matters for getting good results without hovering over the implementer.

Clarity: define outcomes, not prompts

Suppose a stakeholder wants caching on the user profile endpoint, and the work will go to a GenAI agent. A typical weak request reads "implement caching for the user profile endpoint." To a human who knows the system it sounds clear. It isn't. An agent has dozens of open questions. Which endpoint exactly? What gets cached? For how long? What invalidates an entry? Which caching infrastructure already exists? What counts as done?

Clarity doesn't mean a longer prompt. It means the desired outcome and the constraints are unambiguous. A stronger version of that task:

Goal:
Reduce repeated database reads from GET /users/{id}.

Constraints:
- Use the existing Redis abstraction.
- Do not introduce a new dependency.
- Cache only successful responses.
- TTL: 10 minutes.
- Existing public API behavior must not change.

Before implementing:
- Inspect similar caching implementations in the repository.
- Identify how cache invalidation is handled elsewhere.

Validation:
- Existing tests must pass.
- Add tests for cache hit, cache miss, and invalidation.

Definition of done:
The implementation is complete when the endpoint behaves identically
from the client's perspective and repeated reads no longer hit MSSQL.

Prompt engineering is just one slice of clarity. The real skill is describing work well enough that someone else can carry it out, which managers and leads do every day.

Autonomy: ownership, not just instructions

It might seem that micromanagement doesn't exist for agents, but it does. When an agent depends on constant nudging, the usual cause is missing clarity and instruction. Picture a session like this:

Find the problem.
Okay, fix it.
Now run the tests.
There's an error. Fix that.
Run them again.

The user is orchestrating each step by hand, and that wears out both sides.

An agent can understand a task perfectly and still lack autonomy. Autonomy is about ownership: what the agent may decide, what it may change, how far it should carry on alone and when it has to escalate. An agent contract expresses this well:

You own this task until it is implemented and validated.

You may:
- inspect any file in the repository
- modify files related to this feature
- run builds, tests and static analysis
- create focused subagents for research or validation

After implementation:
1. Run the relevant test suite.
2. Inspect your diff for unintended changes.
3. Validate the implementation against the acceptance criteria.
4. Fix issues you discover before returning.

Escalate only if:
- the requested behavior conflicts with existing architecture
- required credentials/access are unavailable
- the change would require modifying a public API

Clarity sets the destination, and autonomy sets how much of the trip the agent owns. Autonomy doesn't mean doing whatever it likes, though. Healthy autonomy comes with boundaries.

Relationship: know the agents

Relationship here is about calibration, not anthropomorphism. It's the accumulated knowledge of strengths, weaknesses, failure modes and track record for the models and agents in use. A manager learns where each person does their best work, and the same understanding should grow for an AI stack:

| Work                                  | Agent/model characteristic          |
| ------------------------------------- | ----------------------------------- |
| Repository-wide architecture research | Strong reasoning + large context    |
| Small mechanical refactor             | Fast, inexpensive model             |
| UI implementation from screenshots    | Strong vision model                 |
| Test generation                       | Fast coding specialist              |
| Final architecture critique           | Independent high-reasoning reviewer |

A setup with one model, one giant context and every task thrown at it is far from ideal. Work should go to agents equipped for it. Multi-agent designs aren't about having more agents. They're about handing well-scoped work to the agent best suited to it:

Main Agent
│
├── Research Agent
│   └── Investigate existing caching patterns
│
├── Implementation Agent
│   └── Make the code change
│
└── Reviewer Agent
    └── Validate implementation independently

The relationship improves as the system accumulates knowledge of architecture decisions, coding conventions, recurring failure modes, earlier decisions and which models do well on which tasks. In short, relationship is model literacy plus accumulated context.

Equity: supply what the agent needs

A familiar complaint goes "the AI hallucinated again" or "it produced slop." But look at what the agent was actually given. There were no API docs, no ticket requirements, no logs, no sample code, no architecture notes and no way to reach the running application. Was that a model failure, or was someone asked to solve a problem without the information required?

Suppose the agent could find or be handed all of that:

.agent/
│
├── context/
│   ├── architecture.md
│   ├── domain.md
│   └── conventions.md
│
├── skills/
│   ├── debug-production.md
│   ├── review-mr.md
│   └── implement-feature.md
│
├── references/
│   ├── api-spec/
│   ├── examples/
│   └── decisions/
│
└── tools/
    ├── git
    ├── jira
    ├── logs
    ├── browser
    └── tests

The exact layout matters less than the principle. Agents need proper instructions and tools. A production-debugging agent may need code, logs, traces, recent deployments and Git history. A UI agent may need code, a screenshot, the design system, a browser and component documentation. A reviewer may need the diff, the full file, tests, the ticket, similar code and the repository guidelines. The intelligence is the same, and the equity differs. Before concluding the model isn't capable, ask whether it was equipped to be.

CARE as a debugging lens

The direction of travel runs from prompting to delegating to orchestrating, and the lead's role shifts along with it. Talented people already perform poorly under unclear goals, micromanagement, mismatched assignments or missing resources. Applying that knowledge to agents means the same management habits now work for everyone producing solutions on a team, human or not.

All four in one agent definition

Runtimes differ in schema, but a working agent definition typically folds CARE into something like this:

---
name: implementation-agent
description: Implements scoped repository changes end-to-end. Use proactively for feature, bug-fix, and refactor tasks that require code changes and validation.
tools: Read, Grep, Glob, Edit, Write, Bash
model: inherit
---

You are an implementation agent responsible for completing scoped coding tasks end-to-end.

When given a task:

1. **Investigate**
   - Read the relevant code before changing it.
   - Search for similar implementations and existing project conventions.
   - Do not guess when repository evidence is available.

2. **Plan**
   - Form a short plan covering the files to change, the implementation approach, and validation.

3. **Implement**
   - Make the smallest change that fully satisfies the task.
   - Reuse existing patterns and dependencies.
   - Do not modify unrelated code.

4. **Validate**
   - Run the relevant tests, build/type-check, and lint/static analysis when available.
   - If your change causes a failure, fix it and validate again.

5. **Review**
   - Inspect the final diff.
   - Remove accidental or unrelated changes.
   - Confirm the requested behavior and acceptance criteria are satisfied.

Continue autonomously until the task is complete.

Escalate only when required access is unavailable, requirements materially conflict, or the task would require a destructive action or a public API/architecture change outside the requested scope.

The task is done only when the implementation is complete, relevant validation passes, and the final diff has been reviewed.

Delegation is the emerging skill

Agents aren't people, but the systems built around them suffer surprisingly familiar management failures. Give an agent an unclear goal, steer every step, assign the wrong model or withhold context and tools, and performance drops. As agents grow more capable, the advantage won't be limited to stronger models or sharper prompts. Teams that learn to delegate well will get the most out of AI.