Skip to main content
This domain is for sale. Contact Snagged to learn more.
Maps

Inside agentic AI: who decides what in real open-source agents

12 agents mapped · last updated Nov 15, 2026

An agentic AI takes a goal and decides its own next steps. These maps show what that looks like inside real open-source agents.

The maps read specific parts of open-source repositories at pinned commits. Each one lists recurring judgments found in that code, who holds each one, and three problems the map found. A repository can be narrower than the product of the same name. None of this is a score, and none of it changes a tool's rank here.

Make a map of an agent you work on · Compare coding agents →

How OpenHands/software-agent-sdk decides

What it decides by itself, and when it asks you

Mapped from the code in OpenHands/software-agent-sdk.

This card covers the OpenHands agent SDK, the library that the OpenHands command-line tool and OpenHands Cloud are built on, and not the OpenHands app or its screens. On its default settings the SDK never stops to ask for your approval, even after an app gives the agent tools to run commands and edit files. An app built on it can turn approvals on, but deciding when the work is done and what to remember stays with plain code and AI models.

Three problems the map found

  1. A new message can count as approval

    Fix proposed

    When the approval policy calls for it, the agent pauses before an action until the app approves or rejects it. If you send a new message instead, and the app then runs the conversation again without rejecting, the waiting action is attempted as if you had approved it. A message saying "wait, not that" does not by itself cancel the action.

  2. The goal judge can read "false" as done

    Fix proposed

    With the goal feature, a judge model is asked for a short structured reply that includes a "complete" field. The code turns that field into yes or no with a Python conversion (bool) that counts any non-empty text as yes, including the word "false". So if the judge writes "false" as text in that field, the goal is marked complete.

  3. A secret inside a tool request is recorded unmasked

    Reported

    You can register secrets, such as service access keys, so they are masked in text replies that contain no request to use a tool. When the model puts a registered secret into a request to use a tool, such as a shell command, the details of that request are written to the conversation record without masking, and when the model gives no summary of the request, the automatic summary repeats them. Anyone who can read that record can read the key.

Not checked: This card was taken from the published map of the OpenHands agent SDK at one commit; it did not look at the OpenHands app or its screens, at the hosted services the SDK can call, or at code outside the map's folders, and no OpenHands code was run to make it.

Mapped by agent-ops-patterns (open source) from OpenHands/software-agent-sdk at commit aae9c43. Mapped Oct 6, 2026. Last updated Nov 10, 2026.

How cline/cline decides

What it decides by itself, and when it asks you

Mapped from the code in cline/cline.

In an ordinary Cline session, plain code runs the work and sets its limits, and the AI model decides when the task is done. By default the model also writes the summary that replaces older history, and in interactive command-line plan mode it decides when to start acting on the plan.

  • On the command line, do tool calls run without asking you?

    Decided by: Plain code

    By default, yes. At startup code sets one policy for all tools from the --auto-approve or --yolo flag if given, else your saved setting, else on, so out of the box tool calls run without asking, in ordinary sessions as well as yolo mode.

  • In VS Code, may this shell command run?

    Decided by: You

    When a command reaches the approval step and neither its policy nor the auto-approve toggle for commands (off by default) approves it, code shows an Approve or Reject row and waits for the person. Only Approve lets that command run; a typed message leaves the question open.

  • In plan mode on the interactive command line, who decides you have approved the plan and the work can start?

    Decided by: The AI model

    The model, by calling a switch-to-act tool; the tool does not look at what you wrote. When that turn completes, the command-line tool rebuilds the session in act mode and starts on the plan. The call itself follows the command line's approval setting.

  • How does it decide the task is finished?

    Decided by: The AI model

    In an ordinary session, the model replies without asking to use a tool and code ends the run as completed; nothing checks that the work was done.

Three problems the map found

  1. Shell commands are cut off at 30 seconds

    Already tracked

    On the command line, a shell command the agent runs gets 30 seconds by default; then code tries to kill it and the agent is told it timed out, so a long build, test run or install can be stopped partway. Cline's tracker has two open reports about this limit.

  2. A file edit that timed out can still be written

    Already tracked

    File edits are given a time limit, but reaching it only tells the model the edit failed; the edit itself is not stopped. So the model can be told an edit timed out while the change still lands in the file. An open report in Cline's tracker describes the same outcome in VS Code: a timeout reported after the write had landed.

  3. A cut-off summary is used as if it were complete

    Fix proposed

    When the default strategy shortens the history, the model's summary replaces the older messages. If the summary was cut off before the model finished it, code still puts it in place; only an empty reply is skipped.

Not checked: This card was taken from the published map of Cline at one commit and covers only decisions shown there. It did not look at Cline's hosted services or at code outside the parts the map covers (its SDK, command line, hub and VS Code extension). One problem was also tested by running it: a file edit that timed out. On 2026-11-12, at this commit, Cline's editor tool was given a 50 ms limit around its real file editor. The test delayed that editor on purpose before it started. The tool reported that the edit had timed out while the file was still unchanged, and the file changed once the editor finished. In separate cases of the same test, a normal edit landed and reported success, and an edit made to fail before writing left the file unchanged. No model was used, and the test does not show how often a real edit is that slow. The reproduction covers only the three cases described here.

Mapped by agent-ops-patterns (open source) from cline/cline at commit d19f176. Mapped Nov 2, 2026. Last updated Nov 13, 2026.

How browser-use/browser-use decides

What it decides by itself, and when it asks you

Mapped from the code in browser-use/browser-use.

In browser-use, the AI model chooses the actions on each of its steps (code may first open a web address named in the task) and decides the task is finished by calling done. Among the decisions this map shows, nobody is asked before an action runs, so a form submit or a script the model writes goes ahead on its own, and code clicks OK on alerts and confirm dialogs. The built-in limits on how long a run goes are counts, not judgments (by default 500 steps, or 5 failed steps in a row and then one last step that may only report the result), and the run's success flag is the model's value when it gives one and true when it does not; a second model call grades the run without changing that flag.

  • Before the agent submits, buys, sends, deletes or runs page JavaScript, does anyone approve it?

    Decided by: Plain code

    Nobody is asked: the model's actions run as soon as they are parsed. An integrator can add a check in their own code through the step callback, which sees the proposed actions before they run.

  • Which actions is the model offered this step?

    Decided by: Plain code

    Every built-in action on every page, including evaluate, which runs JavaScript the model writes, except screenshot at the default vision setting and any the integrator excluded, plus custom actions whose site filter matches. On the last step or after repeated failures, only done.

  • When a page opens a JavaScript dialog, who decides OK or Cancel?

    Decided by: Plain code

    Code clicks OK on every alert, confirm and leave-page dialog the moment it opens, and Cancel on every text prompt, before the model sees it; the model is told afterwards.

  • Which browser permissions are granted to the sites the agent visits?

    Decided by: Plain code

    When the browser connects, code by default grants clipboard read/write and notifications to every site (the integrator can change or empty that list); any other permission a page asks for is left to Chrome.

Three problems the map found

  1. A run can be reported successful when the model never said so

    Fix proposed

    A program reads the success flag in the model's done call at the end of a run. If the model leaves the flag out, code records success. When the developer asks for a structured result, that field is hidden from the model, so such a run normally reads as successful unless the model sets it anyway. An open pull request in browser-use's tracker proposes a fix.

  2. After a step times out, the model is not told which of its actions already ran

    No tracker issue found

    A whole step gets 180 seconds by default. If it runs over, it is cut off, the record of which of the step's actions finished is dropped, and the step's result is only a timeout error. If the run takes another step, the model sees the page as it now is, which may show some effects, but it is not told which of its actions already ran. We found no report of this in browser-use's tracker.

  3. Pressing Enter does not resume a paused run, though the message says it will

    No tracker issue found

    On Mac and Linux, pressing Ctrl+C pauses the run and prints "Press [Enter] to resume or [Ctrl+C] again to quit". Pressing Enter does not resume it; only code that calls agent.resume() does, so a person at the terminal can quit with a second Ctrl+C but cannot continue the run from there. In tracker searches on 2026-11-08 we found no issue tracking this; a 2025 pull request comment reported the same symptom.

Not checked: This card was taken from the published map of browser-use at one commit and covers only decisions shown there; it did not look at the beta agent, the sandbox runner, the MCP server, the command line, Browser Use's cloud browsers or features that are off until a setting turns them on, and no browser-use code was run to make it.

Mapped by agent-ops-patterns (open source) from browser-use/browser-use at commit b49a68e. Mapped Oct 29, 2026. Last updated Nov 15, 2026.

How aaif-goose/goose decides

What it decides by itself, and when it asks you

Mapped from the code in aaif-goose/goose.

In an ordinary goose session, plain code runs a fixed list of steps around the AI model's calls, and a plain text reply with no tool request ends the turn when nothing else is set up. A goal (/goal or /grind), a recipe's checks or required output, or a plugin's stop hook can each cause more work before the turn ends.

  • The model stopped; has it delivered the recipe's final output, or must it be told to?

    Decided by: Plain code

    Only for a recipe with a response schema: code looks since your kickoff message for a final-output call that succeeded. If there is one the turn may end; otherwise it adds a model-only message saying to call that tool now, and the agent continues.

  • If a review pass or check crashed or returned garbage, does the review say so?

    Decided by: Plain code

    On goose review's default path, a failed check or per-file pass adds no findings and a warning on stderr. If the review otherwise completes, it prints the findings that pass the severity floor and exits successfully.

  • When a subagent stops, did it complete, fail or get cancelled?

    Decided by: Plain code

    After reloading its session, code checks in a fixed order: a successful final-output call means Completed, even if the run was cancelled or errored afterwards; else a cancelled run is Cancelled; anything else is Failed.

  • Has the agent taken as many steps as it may without coming back to you?

    Decided by: Plain code

    When this step is reached, code counts the assistant turns kept since your kickoff message; at the budget it ends the turn with a fixed "Would you like me to continue?" message. In an ordinary session the budget is the session's max_turns, else GOOSE_MAX_TURNS, else 1000.

Three problems the map found

  1. The --max-tool-repetitions flag has no effect

    Already tracked

    goose's help says this flag limits consecutive identical tool calls. At this commit it does not: the command line accepts the value but never passes it to the repetition check, and the agent's standard setup gives that check no limit, so it never refuses a repeated call. goose's tracker has an open issue about how this limit should work, where contributors discuss wiring it up or removing it.

  2. By default, a failed review check still exits successfully

    No tracker issue found

    On goose review's default path, a check or per-file pass that fails, panics or returns output that cannot be parsed adds no findings and prints a warning on stderr. If the review otherwise completes it exits successfully, with nothing on stdout or in the exit status to mark the failed check.

  3. No code reads a verdict on a /goal

    No tracker issue found

    After /goal, goose says the agent will verify the goal before finishing. That check is left to the model: when code later clears the goal, it reads no verdict from the reply.

Not checked: This card was taken from the published map of goose at one commit and covers only decisions shown there; it did not look at code outside the map's scope (goose's core crates, command line, built-in extensions and desktop app) or at the 15 decisions left out of that edition, and no goose code was run to make it.

Mapped by agent-ops-patterns (open source) from aaif-goose/goose at commit cfb67d7. Mapped Nov 2, 2026. Last updated Nov 8, 2026.

How langchain-ai/langchain decides

What gets decided in an agent built with LangChain's create_agent

Mapped from the code in langchain-ai/langchain.

In the ordinary tool loop of an agent built with LangChain's create_agent, the model decides when it is finished: a reply that asks for no tool ends the run, and nothing checks that reply. By default nothing trims the conversation; call limits and summarization are middleware the developer adds.

  • Is the agent finished with the task?

    Decided by: The AI model

    The model decides: in the ordinary tool loop, a reply that asks for no tool ends the run and is the answer, unchecked. Structured output adds its own exits.

  • Does a tool's result end the run without the model reading it?

    Decided by: Plain code

    When every client-side tool in that batch is marked return_direct by the developer, the run ends on the tool output and the model does not see it; the tool's status is not looked at.

  • When the provider's native structured answer fails to parse, is the model asked again?

    Decided by: Plain code

    No: a native structured answer that is not valid JSON or does not match the schema raises straight away, and the run fails unless a middleware around the model call catches it.

  • How many steps may one agent run take before it is stopped?

    Decided by: Plain code

    create_agent sets a limit of 9,999 agent steps; the run is then stopped with a GraphRecursionError and no answer, even if it finished exactly on the last step. The caller can change the number per run with config={"recursion_limit": n}.

Three problems the map found

  1. In an agent with tools, a reply with only invalid_tool_calls ends the run

    Already tracked

    In an agent with a tools step, if a reply's calls are all recorded as invalid_tool_calls (on ChatOpenAI's chat-completions path, arguments that are not valid JSON) and its tool_calls list is empty, the run ends there, without retrying them and without an exception. On that route, the model is told about such a call only on a later invocation that carries that history, and only if the call has an ID.

  2. An invalid structured answer beside another tool call can end the run without a structured response

    Already tracked

    With a tool-based response format and the default error handling, one reply can hold a structured answer that fails to parse and also an ordinary tool call. The ordinary tool can then run and the run can end with no structured response and no exception, before the model reads the retry message.

  3. A long tool loop can turn summarized history into a fixed placeholder

    Already tracked

    By default, summarization middleware tries to trim the older messages to a 4,000-token window that starts at a human message. If nothing is left, as can happen in a long run of tool calls after one request, the summary model is not called and the older messages are replaced by the text "Previous conversation was too long to summarize."

Not checked: This card was taken from the published map of LangChain, which read langchain-ai/langchain and langchain-ai/langgraph at one commit each; its code pointers cover the langchain repository only, it covers only decisions shown there, it did not look at code outside the map's scope (an agent built with create_agent, its opt-in middleware and the LangGraph runtime) or at the 3 decisions left out of that edition, and no LangChain code was run to make it.

Mapped by agent-ops-patterns (open source) from langchain-ai/langchain at commit efebcf5. Mapped Nov 2, 2026. Last updated Nov 8, 2026.

How anomalyco/opencode decides

What it decides by itself, and when it asks you

Mapped from the code in anomalyco/opencode.

In opencode, the AI model chooses each next step, and a step normally ends the turn when it calls no local tool; plain code checks its tool calls, decides when older history is summarised, and decides from the agent's and session's rules whether an action runs, waits for you, or is refused. Nothing reads the final answer to check the work, and unless an agent sets a step limit, nothing caps how many steps a run takes.

  • Does an action run, wait for a person, or get refused?

    Decided by: Plain code

    Code merges the agent's rules with the session's rules; if the last matching rule for any resource is a deny, the action is refused. Otherwise the project's saved approvals are added, anything no rule matches waits for a person, and plugin hooks may still change the result.

  • In the terminal interface, who answers a request that waits for a person?

    Decided by: You

    You do: Allow once, Always allow (when the request offers it) or Reject. If the interface was started with --auto, --yolo or --dangerously-skip-permissions, or set to auto-accept, code answers "once" for you and no prompt is shown.

  • In a headless opencode run, what happens to a request that would ask a person?

    Decided by: Plain code

    Code answers every such request in the run's own sessions. Without --auto it refuses with a message telling the model nobody can approve, and the model carries on (in the older compatibility mode the run stops instead); with --auto it allows each one once.

  • How does it decide the turn is finished?

    Decided by: The AI model

    Normally, a step that calls no local tool ends the turn, and code then ends the run when no further input is waiting. Nothing reads the final text.

Three problems the map found

  1. An agent's chosen model can be swapped for another without a warning from the selection code

    Already tracked

    When a session has no model of its own and the model its agent is set up with is not among the available models, code falls back to a default or another available model. That selection code gives no warning that the agent's configured model was bypassed, though the name of the model that ran may still be shown elsewhere. Two closed issues report an agent's configured model being swapped for another: the linked one, on an older version that showed a warning, and #53060, which the maintainers disputed and closed for lack of a trace. Neither issue describes this exact code path.

  2. A patch change goes to the first lines that match

    No tracker issue found

    For the models that edit files through patches (some GPT models), an ordinary change goes to the first place its lines match, searching forward and trying looser matches if there is no exact one. So if the same lines appear more than once, the change can land on the wrong one. The edit tool that other models use instead reports an error when it finds several matches, unless it was asked to replace them all.

  3. No default limit on a run that keeps repeating itself

    Fix proposed

    By default an agent has no step limit, and the map found no check in the current core for a model that keeps making the same tool calls, so a run whose repeated calls keep succeeding has no built-in limit and can go on until you stop it. opencode's tracker has an open discussion of this (#59339) and an open pull request that proposes loop detection.

Not checked: This card was taken from the published map of opencode at one commit and covers only decisions shown there; it did not look at opencode's hosted services or at code outside the parts the map covers (its core, command line, server and terminal interface), and no opencode code was run to make it.

Mapped by agent-ops-patterns (open source) from anomalyco/opencode at commit 0093fe5. Mapped Oct 24, 2026. Last updated Nov 15, 2026.

How earendil-works/pi decides

What it decides by itself, and when it asks you

Mapped from the code in earendil-works/pi.

In pi, the AI model chooses each next step and ends the run by replying without asking to use a tool; plain code checks and runs the tool calls but adds no check of its own that the work was done. By pi's stated design nobody is asked before a tool call runs unless an installed extension blocks it, and a shell command has no time limit unless the model sets one.

  • Is a person asked before a tool call the model issued runs?

    Decided by: Plain code

    No, by pi's stated design. A call runs once its tool is found and its arguments are valid, unless an installed extension blocks it.

  • Can anything block a tool call?

    Decided by: Plain code

    Apart from code's own refusals (an unknown tool, invalid arguments, a cancelled run), only an installed extension that handles tool calls: the first one that says block stops the call, and the model gets its reason as an error. pi ships no blocking policy; the ones in its repository are examples.

  • Should this project folder be trusted to load its own settings, extensions, skills and MCP servers?

    Decided by: You

    When nothing earlier answered, the person chooses at startup in the terminal: trust, trust the parent folder, do not trust, or either answer for this session only. A lasting choice is saved.

  • Is the work finished, so the run may stop?

    Decided by: The AI model

    The model decides implicitly: a reply with no tool call normally ends the run unless messages are queued or an extension asks for more; a reply cut off at its length limit may first get one compact-and-retry. Code adds no check of its own.

Three problems the map found

  1. Piped input and your message are joined with nothing between them

    Already tracked

    In a one-shot run, pi joins piped input, the text of @file arguments and the first message into one prompt with no separator between them, so the end of one part runs straight into the start of the next. pi's tracker has a report about this, filed by someone else, that a bot closed automatically under the project's policy for new contributors; it is marked not planned and had not been reopened when we checked on 2026-11-15.

  2. Cut-down output from your own shell command can be marked as not cut

    Fixed upstream

    When you run a command yourself with !, pi keeps only the tail of a long output. After older output has been dropped, the flag that says the output was cut can still read false. A pull request merged on 2026-11-04, after the commit this card read, tracks the discarded output and includes that in the flag it returns.

  3. A "too long" error in unfamiliar wording is not recognized

    Already tracked

    When a request fails, pi recognizes that it overflowed the model's context by matching the error text against a list of known provider messages. Wording the list does not know is treated as an ordinary error, so pi does not compact the history and retry. pi's tracker has an open report about one such message.

Not checked: This card was taken from the published map of pi at one commit and covers only decisions shown there. It did not look at code outside the map's scope (the command-line agent, agent loop, model layer, code mode and MCP client). One judgment was also tested by running it: G4 (did the run end completed, in error, or aborted?). On 2026-11-12, at this commit, in pi's own test harness, a stand-in for the model sent a reply marked as cut off at its length limit. The turn-end event handed to extensions said completed, while the stored message kept the stop reason "length". In separate cases of the same test, a normal reply ended completed and a provider error ended as error. The test did not use pi's text print mode, which reports a final reply cut off this way and exits with an error. The reproduction covers only the three cases described here.

Mapped by agent-ops-patterns (open source) from earendil-works/pi at commit 1ce44be. Mapped Oct 28, 2026. Last updated Nov 15, 2026.

How agno-agi/agno decides

What it decides by itself, and when it asks you

Mapped from the code in agno-agi/agno.

In an ordinary agno agent, the AI model decides at every turn whether to call tools or answer, and plain code by default runs each valid tool call it asks for without asking a person, unless the developer marked that tool or set a tool-call limit. The run normally ends when the model replies without asking for a tool, and by default nothing checks that answer, so even a reply cut off by the token limit is reported as completed.

  • When an agent is built without a model, which model answers its requests?

    Decided by: Plain code

    OpenAI's gpt-5.4 through the Responses API; any model the developer passes wins.

  • May a tool call the model issued run, without a person being asked?

    Decided by: Plain code

    Yes, by default. Code runs each valid tool call the model makes, except calls past a tool-call limit the developer set; it pauses for a person only on tools the developer marked for confirmation, user input or external execution, or on the ask-the-person tools when those are added.

  • Approve or reject this paused tool call?

    Decided by: You

    Only for a tool marked for confirmation: the run pauses and returns, the developer's code collects the person's yes or no and continues the run, and a missing answer counts as a no.

  • Should the agent stop and ask the person?

    Decided by: The AI model

    When the developer adds agno's ask-the-person toolkits, or a tool marked as needing the person's input; then the model decides when to stop and ask by calling it, and the run pauses for the person.

Three problems the map found

  1. A reply cut off by the token limit is reported as completed

    Fix proposed

    The run ends as soon as the model replies without asking for a tool, and the shared run loop does not look at why the model stopped (some provider adapters only log a warning). So an answer cut short by the output-token limit, or refused, comes back as the answer with the run marked completed, and the caller cannot tell it from a finished one. An open pull request proposes reporting the provider's stop reason.

  2. A structured answer that does not parse still counts as success

    Fix proposed

    When the developer asks for a structured answer and the model's text cannot be turned into it, agno keeps the raw text, logs a warning, and still marks the run completed. Code that expects the structured object gets plain text instead unless it checks the type itself. An open pull request proposes an opt-in way to report the failure.

  3. Later workflow steps can lose the user's original request

    No tracker issue found

    From the second step of a workflow on, an agent or team step receives only the previous step's output, not what the user first asked; the original request reaches it only when the previous step produced nothing. The function's own description says it combines the two, so a step can end up working without the user's question in front of it.

Not checked: This card was taken from the published map of agno at one commit and covers only decisions shown there. It did not look at AgentOS, the server that runs agents, or at provider adapters beyond those the map names. One problem was also tested by running it: a reply cut off by the token limit. On 2026-11-10, at this commit, an agent on agno's OpenAI Responses adapter got a scripted reply from a stand-in for the model, marked as cut off at the output-token limit. The run came back marked completed, with the partial answer and one logged warning. In separate cases of the same test, a normal reply ended completed and a provider failure ended in error, so the test could tell them apart. The reproduction covers only the three cases described here.

Mapped by agent-ops-patterns (open source) from agno-agi/agno at commit 9153aac. Mapped Oct 29, 2026. Last updated Nov 15, 2026.

How Mintplex-Labs/anything-llm decides

What it decides by itself, and when it asks you

Mapped from the code in Mintplex-Labs/anything-llm.

In AnythingLLM, plain code routes each message, gathers what the model sees and cuts it down to fit, while the AI model picks the agent's tools and decides when the agent is done: its first reply without a tool call is the answer. In web chat a person is asked before some tool actions, but MCP tool calls run without asking anyone.

  • Does this message go to the agent instead of plain chat?

    Decided by: Plain code

    It goes to the agent when it starts with @agent, or when the workspace is in automatic mode and its model can call tools natively, provided the agent run can be set up; otherwise it is answered as plain chat.

  • In web chat, should this tool action run right now?

    Decided by: You

    The person sees a card with the skill name, the tool's description and the request, and clicks approve or reject.

  • May this MCP tool call run?

    Decided by: Plain code

    Yes: once a server's tools are loaded, each call goes straight to the server with the model's arguments; nothing asks a person.

  • Has the agent finished, so its text goes back as the answer?

    Decided by: The AI model

    The agent model decides: its first reply without a tool call ends the loop and becomes the answer. A reply that is exactly TERMINATE ends the whole session.

Three problems the map found

  1. When the model asks for several tools at once, only the first runs

    No tracker issue found

    On the shared OpenAI-compatible tool-calling path, if the model asks for more than one tool in a single reply, only the first is run and the others are dropped without the model being told. A request that needs several lookups or actions can come back with part of the work left undone unless the model notices and asks again.

  2. The agent does not use the workspace's chat history setting

    No tracker issue found

    A workspace's chat history setting decides how much earlier conversation plain chat sends (at the commit this card read, 20 when it is unset or zero; a pull request merged on 2026-11-04 changed how a limit of 0 is handled in chat). The agent does not read it: it always starts with the newest 20 saved exchanges, so a workspace set to send less, or more, gets 20 in agent mode.

  3. Chats are marked as processed for memory even when the memory pass did not run

    No tracker issue found

    Every 3 hours by default, a background job reads a person's recent chats to pick out facts worth remembering. Once a group of chats passes the first two checks it is marked processed whatever happened, so if the model call fails or no model is set up, the job does not come back to those chats on its next run. Only the latest 20 are read, so in a larger group the older chats are marked processed without being read.

Not checked: This card was taken from the published AnythingLLM map at one commit and covers only decisions shown there; it did not look at the web frontend or the document collector except where they reach the server, or at the 7 decisions left out of that edition, and no AnythingLLM code was run to make it.

Mapped by agent-ops-patterns (open source) from Mintplex-Labs/anything-llm at commit d7d68e7. Mapped Oct 15, 2026. Last updated Nov 8, 2026.

How NousResearch/hermes-agent decides

What it decides by itself, and when it asks you

Mapped from the code in NousResearch/hermes-agent.

In Hermes Agent, on a normal step the configured main model proposes tool calls or a text answer; code checks an answer before accepting it and can send the model back, for example up to twice for a short reply that only announces a next step. Code applies the limits, among them a step allowance per turn, automatic compression as the prompt nears the window, and an optional time budget that can warn near the end but does not itself stop the run.

  • May this sender's message dispatch agent work?

    Decided by: Plain code

    Code walks a fixed order of grants on every incoming gateway message. On a fresh install with no allowlist, an unknown sender on an ordinary messaging platform is normally refused unless an operator approved their pairing code; local sessions, webhooks and adapters with their own access policy follow separate rules.

  • The reply ends by announcing a next action but makes no tool call: is the model stalled?

    Decided by: Plain code

    On by default when tools are offered. A reply of at most 400 characters with no tool call that ends on an announced next step ("I'll now", "next, I") is treated as a stall and the model is nudged to act, at most twice per turn, a limit shared with two similar checks.

  • Has this turn used up its step allowance?

    Decided by: Plain code

    Code normally takes one step from the turn's allowance as each loop iteration starts. The cap is agent.max_turns: 500 in the config.yaml the installers seed, 150 after the recommended hermes setup, 90 after Blank Slate setup, and no cap with no finite value; a delegated child defaults to 250. At the cap the turn ends, apart from one granted grace call.

  • Should the model be told to wrap up because the wall-clock budget is 80% gone?

    Decided by: Plain code

    Off by default. With a run budget set, after 80% of the time has passed code adds a one-time wrap-up notice to a tool result when it can. The setting does not itself stop the run when the time is up.

Three problems the map found

  1. A run budget can warn near the end but does not enforce a deadline

    Fix proposed

    With --run-budget or agent.run_budget_seconds set, once 80% of the time has passed Hermes adds a one-time wrap-up notice to a tool result when it can, and it can shorten a default wait on a silent model call. The setting does not itself stop the run when the time is up, although the option's help text says it is intended for runs with a hard ceiling. An open pull request proposes stopping the model at the deadline.

  2. Subagent calls over the limit in one reply are dropped without telling the model

    Already tracked

    When a model reply has passed Hermes' tool-call checks and asks for more delegate_task calls than delegation.max_concurrent_children (10 by default), Hermes drops the calls over the limit before the reply goes into the conversation. The cap itself only logs a warning, and the model gets no result for the dropped calls. An open report in Hermes' tracker describes this.

  3. A /loop ends when its finishing line appears anywhere in a reply

    No tracker issue found

    A /loop ends as done when a reply has a line that is only LOOP_COMPLETE. The check matches such a line anywhere in the reply, not only at the end as the function's own description says, so a reply with that line in the middle also ends the loop.

Not checked: This card was taken from the published map of Hermes Agent at one commit and covers only decisions shown there; that map leaves out the desktop and terminal interfaces, packaging, and optional plugins that are off by default, except where they answer a question the agent asks, and no Hermes code was run to make this card.

Mapped by agent-ops-patterns (open source) from NousResearch/hermes-agent at commit b200f5b. Mapped Nov 3, 2026. Last updated Nov 15, 2026.

How openai/codex decides

What it decides by itself, and when it asks you

Mapped from the code in openai/codex.

The main model picks each next step and plain code carries it out, and a turn can end when the model's reply holds no tool call and nothing else asks for a follow-up, unless a Stop hook you configured sends it on. When the conversation grows too long, local compaction replaces older history with a model's summary, and remote compaction uses an opaque item from the backend.

  • What does the agent do next: which tool to call, or what to say?

    Decided by: The AI model

    The main model answers it in a streamed response at each step; code handles what comes back.

  • In multi-agent V1, should part of this work go to a sub-agent?

    Decided by: The AI model

    The model decides by calling spawn_agent; code checks the arguments and starts a child thread.

  • After exec_command starts a process, how long does the tool wait before answering?

    Decided by: Plain code

    The model's wait time, 10 seconds by default, is held between 250 ms and 30 s, with a 10 s floor on Windows. If the process is still running at the deadline, the tool returns the output so far and the process keeps running.

  • How much of a command's captured output does the model read?

    Decided by: Plain code

    The budget starts from the smaller of the model's max_output_tokens, 10,000 by default, and the model catalog's truncation policy. Text over it is cut from the middle under a warning header, then trimmed again to fit.

Three problems the map found

  1. A long AGENTS.md near the root can crowd out the ones nearer your work

    Already tracked

    Codex shares one budget, 32 KiB by default, across a project's AGENTS.md files, reading from the project root down to your working directory. So a long file near the root can use it up. When the budget is used up, later files, nearer your work, are not read; a file larger than what remains is cut. A pull request merged on 2026-11-04, after the commit this card read, adds warnings for files cut or skipped this way; the cut is still there.

  2. An interrupted command's output can be missing from the model's result

    Already tracked

    If you interrupt and a running exec_command call is aborted, its result for the model holds the elapsed time and 'aborted by user', with no command output. An open report in Codex's tracker describes output visible on screen but missing from the tool result returned to the model.

  3. A /review reply that cannot be parsed comes back with no structured findings

    Already tracked

    Code tries to parse the review model's reply as JSON, whole and then from its first { to its last }. If both fail, the whole reply becomes the overall explanation, with zero findings and an empty correctness verdict. Codex tests this fallback on purpose. An open issue reports a /review that returned "continue?" instead of a review; a comment there names this fallback as a plausible cause, not a confirmed one.

Not checked: This card was taken from the published map of OpenAI Codex at one commit and covers only decisions shown there; it did not look at code outside the Rust agent in codex-rs/, at OpenAI's hosted services, or at the 8 decisions left out of that edition, and no Codex code was run to make it.

Mapped by agent-ops-patterns (open source) from openai/codex at commit a5c4092. Mapped Nov 2, 2026. Last updated Nov 15, 2026.

How bytedance/deer-flow decides

What it decides by itself, and when it asks you

Mapped from the code in bytedance/deer-flow.

In DeerFlow, a lead AI model does the work through tool calls and, when sub-agents are switched on (the web app does this only in its Ultra mode), can hand tasks to them; a run normally ends when that model replies without asking for a tool, and plain code can also remove tool calls to bring it to a close. When a thread has an active /goal, a separate model call can judge whether the conversation shows the goal was met, though some conditions stand the goal down without that call.

  • Do the receipt ids a sub-agent cites in its report point to real, successful tool calls?

    Decided by: Plain code

    When a task sub-agent completes and receipts were harvested, code checks its report's citations against them. Any verdict shown to the lead does not change the task status.

  • Did the run actually hand over the output files it produced?

    Decided by: Plain code

    On normal completion, worker code uses available before and after snapshots to detect changed output files. If some are detected and none is covered by a recorded present_files path, the delivery check returns an error.

  • How many graph steps may one run take before it is stopped?

    Decided by: Plain code

    The Gateway takes the request's recursion_limit if it is a positive integer, otherwise the configured default, and caps it at max_recursion_limit.

  • Is the agent stuck repeating the same tool calls, and should it be warned or stopped?

    Decided by: Plain code

    After a model response with tool calls, code counts repeated call sets per run. With defaults, a repeated set can trigger a warning at 3 and a stop at 5; a separate window counting tool names has thresholds of 30 and 50. A stop removes that response's calls and adds a stop message.

Three problems the map found

  1. web_fetch cuts page content at 4,096 characters, with no notice of the cut

    Fix proposed

    Each web_fetch tool the map cites keeps at most the first 4,096 characters of the content it selects and adds no notice of that cut, so a long page can reach the model incomplete with nothing from the tool saying so. The example config uses the Jina tool, which does this. An open pull request proposes making the limit a setting.

  2. One matching presented file is enough to pass the delivery check

    No tracker issue found

    On a normal completion, when changed output files are detected, the delivery check compares them with the paths recorded as presented. One presented path that covers a detected change satisfies the check, even if the run's other changed output files were not presented. The check is written to catch runs that present none of them.

  3. Fifty proposed calls to one tool can force a stop, even when each call differs

    Already tracked

    Besides counting repeated sets of tool calls, the loop check counts calls by tool name in a sliding window. At the default threshold, reaching 50 proposed calls to one tool in that window triggers a stop whatever their arguments: all calls in that response are removed and a stop message is added. A setting can raise the limit per tool. An open issue reports this limit interrupting batch scientific work, and a contributor there points to that setting.

Not checked: This card was taken from the published map of DeerFlow at one commit and covers only decisions shown there; it did not look at code outside the map's scope (the Python harness package and the gateway, channel and scheduler code that answers the harness's requests) or at the 17 decisions left out of that edition, and no DeerFlow code was run to make it.

Mapped by agent-ops-patterns (open source) from bytedance/deer-flow at commit 14abd9a. Mapped Nov 2, 2026. Last updated Nov 10, 2026.