Back

How-to6 min read

When your panel and agent disagree

Guide card: When your panel and agent disagree

Rebuild the model under a CRUD admin panel when the panel and an agent stop agreeing on what a record is, who may change it, and which change is allowed. A chatbot or a generic update endpoint works while the screens still hold the rules and the agent only reads. People and agents need the same entities, relations and permissions, and you can get there one workflow at a time. Leave the old screens up until they are thin views of that model.

Signals the bolt-on has hit its limit

Watch the daily work. Another prompt on the same tables will keep drifting once these show up.

  • The screen and the assistant disagree. A button stays disabled because an invoice is still open. The assistant, given a generic update, closes the order. The rule lived in the frontend, so the agent never saw it.
  • One noun, several tables. The CRM screen says customer, billing says account, the service desk says company. The assistant joins them by guessing. A spreadsheet beside the panel uses a fourth name, and the assistant either misses it or mixes it in.
  • A new relation stays invisible until someone rewrites a prompt. A visit belongs to a request, and a request belongs to a machine. The panel shows that only after a new screen. The agent uses it only after a new prompt. Nothing in the system learned the relation once.
  • Permissions hang off screens. “Who may open this page” does not say who may read this record. The assistant runs as one service account and sees rows the person at the panel cannot. OWASP calls this excessive agency (LLM06:2025): too much functionality, too much permission, or too much autonomy. One of their examples is an extension that only needs to read, yet connects with permission to update, insert and delete. Another is a task done for one user that runs on a high-privilege account and can see every user’s files. They also ask for the check to live in the system that holds the data, so the model is not the thing deciding what an action is allowed to do.
  • Status is a free string. The moves the business allows live in the UI. An import, a nightly job and the assistant write states the panel never offers, and later nobody can tell a real “done” from a value that slipped in.
  • The audit trail is the last person who saved the row. You cannot say which action ran, on which entity, under whose authority. Once an agent writes as well as a person, that is the question an audit asks first.

When several of these show up together, the bolt-on has used up the panel.

What the semantic model holds

The semantic model is the shared description of the work, kept where the panel and the agent both read it.

Entities. The nouns the team uses, each with a stable name and id: a request, a machine, a visit, an invoice. Microsoft’s Common Data Model publishes schemas of entities, attributes, semantic metadata and relationships so applications can share data and its meaning. The same Account then has one shape everywhere, and a further app can use it without inventing a near-copy. In your own platform, keep one name per noun and use that name in every screen and every tool.

Relations. Explicit links. A visit belongs to one request. A request belongs to one machine. The join is a fact in the model, so a prompt does not have to guess it. Model-driven apps in Power Apps are built this way: relationships connect tables so people move between related records, and there is no such app without the data model. Keep that order on your own stack: the model first, the screens after.

Actions and the lifecycle. The states a record can be in, and the named operations that move it: schedule a visit, close a request, mark an invoice paid. Those operations are the tools an agent may call. Anthropic’s note on tools for agents (11 September 2025) describes a common error: tools that merely wrap existing software functionality or API endpoints, whether or not those tools suit an agent. A schedule_event tool finds a time and books it in one call. Separate list and create tools leave that chaining to the agent, which is where a generic “update this row” tool also fails.

Permissions on the entity and the action. The same check for a person and for an agent. NIST SP 800-162 defines attribute-based access control as deciding an operation from attributes of the subject, the object, the requested operation and, in some cases, the surrounding conditions. A role that only opens a screen records none of that.

One more fact belongs in the model: which version is current. A draft, a cancelled row and the live record are different answers. The panel and the agent should treat only the current one as true.

A staged way to rebuild it

  1. Pick one workflow the panel and the agent both touch. Write the nouns in the words the people who do the work already use. Leave the rest of the panel alone. If you still need to choose the workflow, score it as in how to choose the first process for an AI agent.
  2. Write the entities, the attributes that matter, and the relations on one page. Skip a pass that adds columns to every table. A service desk, as walked through in how to choose a stack for a service platform, starts from the request lifecycle: the machine, the issue, the visit, and the states a request can end in. Screens wait until that page exists.
  3. Put each allowed change in a named action on the server. The screen calls the action. The rule sits beside the model, so the agent can call the same action. When the assistant books a visit, it uses the dispatcher’s action, and a second visit on an open request is refused for both of them.
  4. Set who may read each entity and who may run each action, then run the agent as that user. A shared admin token brings the bolt-on back, because people and the agent then see different rows. Read tools return entities that the user may see. Each write is a named action, checked again on the server, which is the mediation OWASP describes for extensions.
  5. Hand the agent only those tools, and try real cases. A database login or a generic CRUD route keeps the old gap. Take a handful of questions a person already answers from the panel. Where the agent and the person disagree, change the model or the action. Adjust the prompt only after the facts match.
  6. Point new screens at the model, and drop the duplicates after a full cycle. Old screens stay until they only display the model. When people and the agent have run the workflow on the same entities for a full cycle, remove the extra names and the spreadsheet beside the panel. Then take the next workflow.

Common mistakes

  • Renaming tables and calling that a model. The rules still live in the screens, so the agent and the panel still disagree.
  • A longer prompt on the same generic update. The assistant is still guessing at joins and writing states the screen would have blocked.
  • One service account for every assistant. People and agents see different rows, and an audit cannot tell who an action was for.
  • Drawing the whole database before one workflow ships. The page of nouns never meets a real case, and the panel keeps adding screens beside it.
  • A second store for the agent. It drifts from the panel, and you then have two descriptions of the same work.

Next step

Take one workflow. On a single page, write the nouns, the relations, the states and the named actions. That page is what you point both the panel and the agent at.

If you want to walk through one of your panels and see where that page should sit, we can look at it together.

  • Platforms
  • Semantic model
  • Admin panel