Recently, an arXiv paper titled Why is AI generated language so hard to understand? reached the front page of Hacker News. Its discussion thread received 118 points and 109 comments.
The paper asks a simple question: Why can AI-generated text be grammatically correct and information-rich, yet harder for people to understand? The answer matters for anyone evaluating AI Agent output.
Paper: https://arxiv.org/abs/2610.29162
Hacker News discussion: https://news.ycombinator.com/item?id=50223647
The Real Problem Behind 118 Points of Discussion
When evaluating LLM output, teams have traditionally focused on two questions:
- Are the facts correct?
- Is the information complete?
This paper pushes the evaluation one step further: Even when a response is grammatically sound, factually accurate, and comprehensive, why can it still be difficult to read?
The goal is not to make AI write less. It is to make AI organize information in a form people can process quickly. Understandability should not remain a secondary metric attached to factual accuracy.
A research summary with entirely wrong answers is relatively easy to spot. A mostly accurate report that makes users read it three times to find the action items may cause more subtle damage.
Difficult to Understand Does Not Mean Short on Information
A common problem with AI-generated text is not a lack of content, but too much content packed together.
Consider this typical example:
In today’s rapidly evolving technological landscape, generative AI is profoundly reshaping content creation and knowledge work. To fully unlock its potential, organizations must establish systematic workflows while paying close attention to key areas such as data governance, model evaluation, and ethical security.
There are no obvious errors in this passage, and it covers every relevant theme. Yet after reading it, users still cannot answer:
- What is the main conclusion?
- Which recommendation should come first?
- What specifically qualifies as a “key area”?
- Who is responsible for the next step?
Each sentence carries too many preliminary clauses. Abstract nouns follow one another in quick succession. The conclusion is buried beneath the setup. Users end up responsible for reconstructing the structure of the text themselves.
Cognitively, reading involves more than receiving information. It requires allocating working memory, organizing causal relationships, and extracting decision-relevant cues. Every additional qualifier, disclaimer, or historical aside in an AI response creates another object for the reader to track.
As a result, “more information” often means:
- The main conclusion is not prominent enough.
- The relative importance of different levels is unclear.
- Readers must supply the relationships between sentences themselves.
- Next steps are mixed together with background information.
Low content density does not mean readers receive less information. It simply transfers the cost of organizing that information to the user.
What Models Are Optimizing
The primary training objective for an LLM is to predict the next token, not to organize action priorities for the user.
Different training stages further reward stable, predictable text distributions. Formal articles, documentation, question-and-answer pages, and summaries in common corpora already exhibit strong formatting habits:
- Open with background context.
- Try to make each point fully qualified.
- Use transitions to connect sections.
- Avoid sharp trade-offs in favor of cautious coverage.
During generation, the model also completes sentences that “look like answers” based on the surrounding context. This can produce a peculiar result: every sentence is reasonable, but the entire response lacks a clear direction.
This is where fluency evaluations miss the mark.
Coherence, completeness, and broad coverage are all signs of generation quality. They do not guarantee that a response can be understood quickly, much less acted on.
For an everyday chat user, readability may mean little more than “willing to keep reading.” An AI Agent faces a stricter standard: Another program or person must be able to use the output to check status, locate a failure, and choose the next step.
Understandability can be assessed at three levels:
| Level | Common Problem | Better Check |
|---|---|---|
| Generation mechanics | The model favors responses that are statistically natural and complete | Does it lead with the conclusion and surface anomalies clearly? |
| Text organization | Background, process, and conclusion receive similar weight | Is the response layered so the main thread can be restated after skimming? |
| Human cognition | Readers must reconstruct the structure themselves | Does it reduce memory burden and support judgment and action? |
All three levels are necessary.
Rewording alone may reduce surface-level reading difficulty while preserving structural problems. Simply asking the model to say less may remove necessary conditions. A real fix has to happen at the level of information architecture.
A Better Acceptance Checklist for AI Agents
In AI Agent systems, “understandability” should not remain a copywriting score. It can become an engineering acceptance criterion.
1. Does the First Screen State the Conclusion?
Users should not have to read an entire Agent response before learning what happened.
For example, after a troubleshooting task, an ideal first screen would read:
Failure cause:
DATABASE_URLpoints to the wrong host. Two retries failed. Switch toDATABASE_URL_PRODand rerun the task; this variable is not configured yet.
There is no need to begin with “This task involved multiple stages, including database connectivity, DNS resolution, and permission checks.”
Evaluation can check whether:
- The status appears within the first three lines.
- Success or failure is stated explicitly.
- An actionable next step is provided.
2. Can the Steps Be Traced?
Agents call search engines, browsers, databases, code executors, and other tools. Users need to know what the Agent did, not just see its final answer.
Traceability does not require exposing every internal thought. A more useful mechanism is an external log of verifiable events:
- Which tool was called.
- Which key parameters were supplied.
- What result was returned.
- Which step caused the plan to change.
Like a Git commit history or CI log, Agent output should let users locate where a failure occurred.
3. Can Tool Calls Be Explained?
A tool call can succeed technically while failing the business task.
For example:
result = search_orders(customer_id="C-1042")This shows only that the call occurred. A more useful explanation would be:
result = search_orders(customer_id="C-1042")
# Purpose: Confirm whether the order has shipped
# Limitation: The API returns only orders from the past 30 days and does not include 2025 historyThe explanation should support review, not turn into a long tutorial for the user.
4. Adjust Information Density by Role
Developers, on-call engineers, and managers each need different information from the same result.
- Developers care about stack traces, parameter differences, and reproduction steps.
- On-call engineers care about the scope of impact, current status, and recovery actions.
- Managers care about risk, cost, and decision points.
A checklist therefore cannot rely on a single “conciseness” score. A more practical approach is to define required fields for each task role, then verify that those fields appear in priority order.
Agent output acceptance is better divided into four hard metrics:
- Conclusion latency: How much content appears before the final conclusion?
- Trace completeness: Can key steps be traced to their inputs, outputs, and branch changes?
- Actionability: Can the user execute the next step without asking a follow-up question?
- Role fit: Does the response include the information needed for the intended role to make a decision?
These metrics are still imperfect, but they reflect real-world use more closely than “3 out of 5 for concision and 5 out of 5 for completeness.”
Editorial Perspective
Understandability may be more closely tied to users’ subjective experience than factual accuracy. People usually question a factual error, but verbosity and poor hierarchy merely slow them down. They may not be able to identify exactly what is wrong; their conclusion may simply be, “I didn’t understand it.”
This discussion differs from earlier approaches to evaluating generated text. Past evaluations focused on whether the model had the right answer and whether the response covered the question. This one treats the reading process itself as the object under test. Understandability is not about shortening answers; it is about determining whether the model has organized the information on the user’s behalf.
That shift matters especially for AI Agents. An Agent’s value lies not only in calling the right tools, but also in making its status, evidence, and next actions understandable to people and downstream programs. The paper may not offer a universal method that works for every task. Front-loaded conclusions, traceable steps, explained tool calls, and role-specific density, however, already provide a practical acceptance checklist.