Skip to content

// Engineering - October 22, 2026 - Updated Nov 4, 2026

Context engineering for AI agents on a task board.

Context engineering is the practice of choosing what an AI model sees at each step of a task: its instructions, its tools, the data it fetches and the history so far. The aim is the smallest set of information that gets the job done. For an agent working from a board, the task card is the part you control most.

What is context engineering?

Context engineering is the work of deciding what goes into a model's context window at each step: the instructions, the tool definitions, the data it fetches and the history so far. A model can only use what is in that window, so what you put there, and what you keep out, shapes the result.

Anthropic's Applied AI team described it in a September 2025 engineering post. Context engineering "refers to the set of strategies for curating and maintaining the optimal set of tokens (information) during LLM inference, including all the other information that may land there outside of the prompts." Their guiding rule is to find "the smallest possible set of high-signal tokens that maximize the likelihood of some desired outcome" (Effective context engineering for AI agents).

For a chat, that mostly means a good prompt. For an agent that runs for an hour, calls tools and reads files, it means much more: which tools it has, what each call returns, what it writes down for later, and what it rereads after its history is summarized.

What does Anthropic's "Effective context engineering for AI agents" say?

Anthropic's Applied AI team published Effective context engineering for AI agents on September 29, 2025. Its core advice: treat context as a finite resource, because a model recalls information less accurately as its context window fills, an effect known as context rot. Write system prompts at the "right altitude", neither brittle rules nor vague guidance. Keep tools few and non-overlapping, and use a small set of diverse, canonical examples. Load data just in time through lightweight identifiers such as file paths. On long tasks, use compaction, structured notes kept outside the context window, and sub-agents that return short summaries.

That is our summary, not Anthropic's wording; the post itself, by Prithvi Rajasekaran, Ethan Dixon, Carly Ryan and Jeremy Hadfield, has the detail and examples. Three of its techniques map straight onto an agent working a Flux board:

Anthropic's technique On a Flux board
Just-in-time retrieval: keep identifiers, load the data when needed get_board gives card titles and UUIDs; get_card loads one card's description and comments when the agent starts it. More below
Structured note-taking outside the context window A short, signed hand-off comment on the card, which the next session reads back through get_card. More below
Compaction: summarize the history when the window fills The post warns that overly aggressive compaction can lose subtle but critical context. Our advice: have the agent call get_card again after its history is summarized. More below

The rest of the advice, on system prompts, tool design and sub-agents, is about how you build or configure the agent itself, so it applies to any setup, board or not.

How is context engineering different from prompt engineering?

Prompt engineering is about writing the instructions. Context engineering is about everything the model sees, and it happens again on every turn. Anthropic calls it "the natural progression of prompt engineering" and says that, unlike writing a prompt, "the curation phase happens each time we decide what to pass to the model."

Point Prompt engineering Context engineering
Main question How should I word the instructions? What should the model see right now?
When it happens Once, before the run Every turn of the run
What it covers The system prompt and the user prompt Instructions, tools, fetched data, notes, message history
Typical failure Vague or contradictory instructions Too much, stale or missing information

Why can more context make an agent worse?

Models don't use a long context evenly. As the input grows, they get less reliable at finding and using what matters, and text that looks relevant but isn't pulls them off course. This effect is often called context rot.

Chroma's July 2025 technical report, Context Rot, tested 18 language models, including GPT-4.1, Claude 4, Gemini 2.5 and Qwen3, on deliberately simple tasks. It found that "their performance grows increasingly unreliable as input length grows", and that "the impact of distractors and their non-uniformity amplifies as input length grows." Anthropic puts it as an "attention budget": every new token uses some of it.

A bigger window does not remove the problem. Anthropic expects that "context windows of all sizes will be subject to context pollution and information relevance concerns." On a task board, the distractors are familiar: a stack trace pasted three days ago, a question that was answered later in the thread, a description that still lists an approach you dropped.

What is in an agent's context when it works on a task?

Several layers, loaded at different times: the instruction file at the start, tool definitions when tools are needed, tool results each time the agent calls a tool, and the growing conversation. Each layer has a natural home in a board setup.

Layer When it loads In a Flux setup
Instruction file (CLAUDE.md, AGENTS.md) At the start of each session Your board rules: which column to take work from, how to sign comments, where to stop
MCP server instructions When the client connects, if the server sends any None. The Flux MCP server sends no server instructions
Tool definitions Up front, or on demand if the client defers them The 12 Flux tools, from list_workspaces to reorder_cards
Tool results Each time the agent calls a tool The board map from get_board, one card from get_card
Notes kept outside the window When the agent reads them back Card comments
Conversation history Grows every turn; summarized when it gets too long Your prompts and the agent's own work

The MCP server instructions row matters more than it looks. The MCP specification lets a server send instructions when a client connects, "like a 'hint' to the model", which a client "MAY" add to the system prompt (MCP schema, 2025-11-25). In Claude Code they matter even more. With its MCP tool search, which is on by default, "only tool names and server instructions load at session start", and the full tool definitions load when Claude needs them (Claude Code MCP docs). Flux sends no instructions, so the rules for how to use your board have to live in the agent's instruction file. Our AGENTS.md vs CLAUDE.md guide covers which agents read which file.

What does an agent get from a Flux card?

It depends on which tool the agent calls. get_board returns a light map of every active card, list_cards returns full descriptions for a whole column, and get_card returns one card in full with all its comments. The table below comes from the Flux MCP server code, checked on October 22, 2026:

Tool What it returns about cards Context cost
get_board For each active card: UUID, card ID, title, column, position, due date Small per card; no descriptions
search_cards Up to 20 cards whose titles match: UUID, card ID, title, board ID, column ID Small; matches titles only
list_cards Every active card in one column, with description, priority, due date and whether the due date is marked complete Grows with the column; every description at once
get_card One card's full record, plus every comment's text and time, oldest first One card, but the whole thread

Three things are missing from all four: checklist items, labels and assignees. Flux stores them in separate tables, and none of the MCP tools return them. The REST endpoint GET /api/cards/{id} does, along with attachments, linked cards and comment author names. Also, call get_card with the card's UUID, which get_board gives you. Our post on how the Flux MCP server works lists all 12 tools and their permissions.

Should an agent load cards up front or just in time?

Just in time. Give the agent a light map and the IDs, and let it fetch the one card it is about to work on. Load the rules up front, and the work on demand.

Anthropic describes this "just in time" approach: agents "maintain lightweight identifiers (file paths, stored queries, web links, etc.) and use these references to dynamically load data into context at runtime using tools." They point to Claude Code as a hybrid: CLAUDE.md files go into context up front, while search tools find files when they are needed. A card UUID is that kind of identifier. This sequence keeps context small:

1. get_board  board_id: "<short ID from list_boards>"
   -> columns with their UUIDs, and each card's UUID, card ID,
      title, position and due date. No descriptions yet.

2. Pick one card, for example the top card in Backlog.

3. get_card  card_id: "<that card's UUID>"
   -> the full card: description, priority, dates,
      and every comment, oldest first.

4. Open only the files and links the description names.

The call to avoid is list_cards on a long Backlog column. It returns the full description of every card in it, so a 60-card backlog puts 60 descriptions into context when the agent needs one. Save list_cards for short columns, such as a triage pass over Needs review.

Reread after a reset. Claude Code summarizes the conversation as the context window fills up. Its context window docs list what comes back after that: the project-root CLAUDE.md is "Re-injected from disk", and up to five of the files it read or edited are read again. MCP tool results are not on that list, so a card read before compaction survives only as part of the summary. If the details matter, call get_card again. Put these habits in the instruction file:

Flux board rules
- Start with get_board for titles and IDs. Don't list_cards a long Backlog.
- Call get_card on one card before you start it, and again after
  your context is compacted or cleared.
- Open only the files the card names. Ask in a comment if they're not enough.
- Before you stop, post one hand-off comment that starts with your name:
  Done, Next, Open questions. Keep it under 5 lines.

What should a task card carry for an AI agent?

The goal, pointers to what to read, how to tell it's done, and what is out of scope. Pointers beat payloads: a file path or a link costs a few words and lets the agent load the content only if it needs it.

  • A one-line goal. The outcome, not the steps.
  • What to read first. File paths, a decision record, the spec. Link them; don't paste them.
  • Done when. Checks the agent can run or see. Our acceptance criteria guide covers how to write them.
  • Out of scope. One line stops the agent fixing things nobody asked for.
  • How to check. The command or page that proves it works.

An example description:

Goal: Limit POST /api/login to 10 attempts per IP per minute.

Read first:
- src/app/api/login/route.ts
- docs/adr/0007-rate-limits.md (why per IP, not per account)

Done when:
- The 11th attempt from one IP within 60 seconds gets a 429.
- Existing login tests pass, and a new test covers the 429.

Out of scope: account lockout, CAPTCHA.
Check with: pnpm test login

Put all of this in the description, not in the checklist, so an agent connected over MCP can read it. Leave out anything that adds tokens without adding signal: whole log files (paste the three lines that matter and name the file), copies of a spec that lives in the repo, and chat transcripts. Never put secrets on a card. Whatever an agent reads becomes part of its context, so a key on a card ends up in every session that opens it.

How do card comments carry context between sessions?

They are the agent's notes, kept outside its context window, where the next session, another agent or a person can read them back. That is the pattern Anthropic calls structured note-taking, with the card as the notebook.

Anthropic describes it as "a technique where the agent regularly writes notes persisted to memory outside of the context window", like Claude Code's to-do list or a NOTES.md file. A card thread does the same job, with one difference: other people can see it. The Flux MCP server keeps nothing between requests, so the board itself is where state lives. When a new session calls get_card, the comments are how it learns what happened.

Two details shape how agents should write them. First, over MCP an agent can add a comment but not edit or delete one, and get_card returns the whole thread every time, so every chatty progress update is something the next session has to read. Second, get_card returns each comment's text and time but not its author, while the app shows API-key comments under the name of the person who owns the key, so each agent should sign its comments. One short hand-off per session works well:

[claude-code-1] Session end.
Done: 429 after 10 attempts per IP per minute (src/lib/rate-limit.ts).
Next: a test for the counter reset after 60 seconds.
Open question: should localhost be exempt? Not decided.

Write decisions and next steps, not a transcript. For the rest of the setup, a review column and an API key per agent, see our kanban board for AI agents guide.

// FAQ
06 questions
01

What is context engineering in simple terms?

+

Context engineering means deciding what an AI model gets to see each time it works: the instructions, the tools, the documents it reads and the conversation so far. Because a model can only work with what is in its context window, choosing that content well matters as much as how you phrase the prompt. Anthropic calls the goal the smallest set of high-signal information that gets the result you want.

02

What is the difference between context engineering and prompt engineering?

+

Prompt engineering is about writing the instructions. Context engineering covers everything else the model sees as well: tool definitions, retrieved data, memory and message history. Anthropic describes context engineering as "the natural progression of prompt engineering", and notes that it is iterative: the choice of what to pass to the model happens again on every turn, not once.

03

What is context rot?

+

Context rot is the drop in a model's accuracy as its input gets longer. Chroma's July 2025 report tested 18 language models and found that "their performance grows increasingly unreliable as input length grows", even on simple tasks, and that distracting, nearly relevant text hurts more as the input grows. It is why trimming context helps even when everything fits in the window.

04

Does a bigger context window make context engineering unnecessary?

+

No. A bigger window lets more fit, but it does not make the model use all of it equally well. Anthropic's engineering team wrote in September 2025 that "context windows of all sizes will be subject to context pollution and information relevance concerns" for the foreseeable future. A short, relevant context still beats a long, noisy one.

05

Can an agent read a Flux card's checklist over MCP?

+

Not today. The Flux MCP get_card tool returns the card record and its comments, but not checklist items, labels or assignees, which are stored separately. The REST endpoint GET /api/cards/{id} returns those too. If an agent connected over MCP needs to see the done criteria, put them in the card description.

06

Does Flux decide what goes into my agent's context?

+

No. Flux returns data when your agent calls one of its tools, and your agent's client decides what to keep in context. Flux shapes context in two ways only: what each tool returns, and what your team writes on the card. The Flux MCP server sends no server instructions, so board rules belong in your agent's instruction file.

// Context on the card

Small cards. Clear context.

Give your agents a board where each card carries the goal, the pointers and the hand-off notes. Free to start, and agents connected with a member's API key never take a seat.