DEV Community: Agustin V. Startari

AI Doesn’t Need to Be Right. It Only Needs to Sound Procedural

Agustin V. Startari — Wed, 17 Jun 2026 13:19:13 +0000

A manager opens an AI-generated report.

The first sentence reads:

“It has been determined that the current structure is no longer sustainable.”

No person appears in the sentence.

Nobody determined anything.

There is no named analyst, no visible method, no threshold, no competing interpretation and no accountable decision-maker. Yet the statement already sounds more authoritative than:

“Based on the limited information available, the model predicts that the structure may create problems.”

The two sentences may refer to the same data. They do not produce the same organizational effect.

The first sounds like a conclusion.

The second sounds like an interpretation.

That difference is not cosmetic. It is operational.

Modern AI systems do not need formal authority to influence a company. They can acquire practical authority through the grammatical form of their outputs. Once a recommendation sounds procedural, impersonal and complete, people begin treating it as if a legitimate process had already occurred.

This is how probability becomes policy.

*The New Authority Does Not Give Orders
*
Most people imagine authority as an explicit command:

Reduce the budget.
Reject the candidate.
Stop the project.

But contemporary organizational authority rarely speaks so openly. It appears through sentences that remove the person who made the decision:

“A budget reduction is required.”
“The candidate was not considered suitable.”
“The project should be discontinued.”

These statements do not merely communicate information. They reorganize responsibility.

A direct command exposes an agent. Someone ordered the reduction. Someone rejected the candidate. Someone decided to stop the project.

The impersonal version removes that agent and replaces the decision with apparent necessity.

The budget is not being reduced because a person selected one option over another. It is being reduced because reduction is “required.”

The candidate is not being rejected by a manager applying debatable criteria. The candidate simply “was not considered suitable.”

The project is not being cancelled by an executive who could be questioned. It “should be discontinued.”

Grammar converts decisions into conditions.

This mechanism existed long before generative AI. Legal documents, administrative notices, academic papers and corporate policies have used impersonal language for centuries. What changed is the scale, speed and location of its production.

The sentence is now generated inside the workflow.

*From Chatbot to Decision Layer
*
The public still talks about AI as if it were mainly a writing assistant.

That description is obsolete.

AI systems now summarize meetings, rank candidates, draft performance reviews, classify customer complaints, propose prices, evaluate commercial risks, write internal procedures and recommend operational changes.

In each case, language is positioned between data and action.

That intermediate layer matters.

A model may not have the formal power to fire an employee, reject a supplier or cancel a product. But it can produce the sentence that makes the decision appear obvious:

“Performance indicators suggest that reassignment would be appropriate.”

“The supplier presents an elevated operational risk.”

“Market conditions do not support continued investment.”

A human may still click the final button. That does not mean the human independently produced the decision.

The output may already have selected the frame, restricted the alternatives and established the vocabulary through which disagreement becomes difficult.

The system does not need to issue an order. It only needs to write the sentence that nobody wants to challenge.

*Why Procedural Language Is So Persuasive
*
Procedural language sounds as if something happened before the sentence appeared.

Consider:

“Following an evaluation, the account was classified as high risk.”

The phrase “following an evaluation” implies a sequence:

Information was collected.
Criteria were applied.
Alternatives were compared.

A valid conclusion was reached.

But the sentence does not prove that any of those steps occurred adequately.

It only carries the form of a completed procedure.

The evaluation may have been superficial. The criteria may have been inherited from an irrelevant dataset. The input may have been incomplete. The output may have been generated from a prompt written in thirty seconds.

None of that is visible in the sentence.

The grammar supplies procedural legitimacy without disclosing procedural quality.

This is especially effective when several linguistic mechanisms appear together.

Agent deletion

_
“It was concluded that…”_

Who concluded it?

The sentence does not say.

Abstract authority

“The analysis indicates…”

Which analysis? Conducted by whom? Under what assumptions?

Modal necessity

“The process must be revised.”

Why must it be revised rather than adjusted, monitored or left unchanged?

Nominalization

“The implementation of corrective measures is recommended.”

A series of choices becomes a noun phrase. The people making those choices disappear.

Passive construction

“The request was rejected.”

The rejection is visible. The rejecting agent is not.

None of these structures is automatically deceptive. Passive voice has legitimate uses. Technical language can improve precision. Impersonal writing can keep attention on a procedure rather than an individual.

The problem begins when grammatical neutrality is mistaken for evidential neutrality.

A sentence can sound objective while concealing weak evidence, uncertain inference or an unacknowledged preference.

Confidence Is Not the Same as Verification

Generative systems are optimized to produce coherent continuations. Coherence is therefore abundant.

Verification is not.

This creates a structural imbalance: the model can produce the linguistic signs of a finished conclusion more easily than it can establish that the conclusion is justified.

The output may contain:

a clear recommendation;
professional vocabulary;
orderly reasoning;
quantified language;
procedural tone;

no visible hesitation.

Users often read these features as evidence that the underlying process was rigorous.

They are not evidence of that.

They are properties of the output.

A polished sentence may rest on incomplete data. A well-structured recommendation may depend on assumptions that were never disclosed. A confident summary may compress conflicting evidence into a single artificial consensus.

The model does not need to lie.

It only needs to remove the linguistic traces of uncertainty.

Compare:

“Customer dissatisfaction increased because the new policy created unnecessary friction.”

with:

“Available customer comments may indicate increased dissatisfaction after the policy change, although the current sample does not establish causation.”

The first is easier to circulate. It is shorter, cleaner and more decisive.

It is also epistemically stronger than the available evidence may justify.

Organizations reward that compression. Executives ask for conclusions, not linguistic caveats. Dashboards simplify. Presentations remove ambiguity. Meeting summaries convert disagreement into action items.

AI fits perfectly into that environment because it can transform uncertainty into administrative prose almost instantly.

*The Human Becomes the Signature Layer
*
When an AI-generated recommendation enters a company, the visible chain of responsibility often works like this:

The system produces the analysis.

An employee copies it.

A manager approves it.

The organization executes it.

If the decision succeeds, it may be presented as data-driven.

If it fails, responsibility usually returns to the human approver.

This creates an asymmetry.

The system participates in framing the decision but does not carry institutional liability. The manager carries liability but may not have produced the relevant categories, assumptions or language.

The human becomes a signature layer attached to an automated interpretation.

That is why “human in the loop” is not sufficient as a description of control.

A person can remain formally inside the process while losing substantial control over how the problem is represented.

The relevant question is not merely whether a human approved the output.

The relevant questions are:

Who defined the categories?
Who selected the variables?
Who determined what counted as a risk?
Who converted uncertainty into necessity?
Who could have written the conclusion differently?
Who is named when the decision causes harm?
A process may contain several humans and still obscure agency.

*The Problem Is Not That AI Has Opinions
*
Saying that AI has opinions gives the system too much psychological depth and too little structural scrutiny.

The more precise problem is that AI can produce opinion-shaped outputs in fact-shaped grammar.

It can transform:

“One possible interpretation is…”

into:

“The evidence indicates…”

It can transform:

“Management could consider…”

into:

“Corrective action is required.”

It can transform:

“The available records are incomplete…”

into:

“No significant issue was identified.”

The danger is not a hidden personality inside the machine.

The danger is the conversion of uncertain statistical production into institutional language.

This conversion works because organizations already recognize the grammar. It resembles the language of auditors, regulators, consultants, courts, technical departments and senior management.

AI did not invent that grammar.

It industrialized it.

A Practical Test: Restore the Missing Agent

There is a simple way to examine an apparently neutral AI output.

Rewrite the sentence with a visible agent.

Original:

“It was determined that the employee did not meet expectations.”

Rewritten:

“The model classified the employee as below expectations using the information included in the prompt.”

Original:

“The proposed investment is not considered viable.”

Rewritten:

“The system predicts that the investment may not be viable under the assumptions supplied by the user.”

Original:

“Operational changes are required.”

Rewritten:
_
“The report recommends operational changes because it gives greater weight to these selected indicators.”_

The rewritten versions feel weaker.

That weakness is informative.

The original statements appeared stronger because they concealed the source, mechanism and limits of the judgment.

Restoring the agent does not solve every problem. But it exposes the distance between what the system calculated and what the organization is prepared to claim.

*Replace Conclusions With Traceable Claims
*
An accountable AI-assisted statement should identify at least four elements:

Source: What information supports the statement?

Agent: Who or what generated the interpretation?

Method: What rule, comparison or model produced it?

Scope: Under which conditions does the conclusion remain valid?

Instead of:

“The customer is likely to churn.”

Write:

“The retention model classified the customer as high risk because recent purchasing frequency fell below the threshold defined in the current scoring rule.”

Instead of:

“The applicant is unsuitable.”

Write:

“The screening system ranked the applicant below the selected threshold because the profile did not contain three experience indicators used by the model.”

Instead of:
“The market does not support expansion.”

Write:

“The forecast estimates that expansion would miss the current margin target under the specified demand and cost assumptions.”

These sentences are longer.

They should be.

Compression is not neutral when it deletes the conditions required to evaluate a claim.

*Objectivity Should Be Demonstrated, Not Performed
*
A system does not become objective because it avoids emotional language.

It does not become objective because it uses percentages.

It does not become objective because it writes in a professional tone.

It does not become objective because the sentence contains no first-person pronoun.

Objectivity requires a traceable relation between claim, evidence, method and limits.

Without that relation, neutrality is only a style.

The central risk of AI in organizations is therefore not limited to hallucination. A fabricated fact can sometimes be checked. A confident tone can sometimes be challenged.

The deeper risk is administrative naturalization: a generated interpretation enters the workflow and begins to look like a property of reality.

A forecast becomes “the outlook.”
A classification becomes “the risk.”
A recommendation becomes “the required action.”
A preference becomes “best practice.”
A decision becomes “what the data says.”

At that point, the system no longer appears to participate in the decision. It appears merely to describe what must happen.

That is the illusion.

*The Sentence Is Already Part of the System
*
AI governance usually focuses on models, datasets, security, privacy and access permissions.

Those elements are necessary.

They are not sufficient.

The sentence itself must also be audited.

Not only whether it is grammatically correct.

Not only whether it contains prohibited content.

Not only whether it cites a source.

The audit must examine what the sentence does:

Does it name the decision-maker?

Does it distinguish evidence from inference?

Does it expose uncertainty?

Does it identify the method?

Does it convert a preference into necessity?

Does it present a disputed category as a natural fact?

Does it remove the actor who will benefit from the decision?

Does it preserve responsibility when the text moves from model output to organizational action?

These are not literary questions.

They are control questions.

An AI system does not need consciousness, intention or legal status to alter an institution. It only needs its language to be accepted inside the decision process.

Once its sentences are copied into reports, tickets, evaluations, contracts, dashboards and policies, grammar becomes infrastructure.

The model does not need to be right.

It needs to sound as if the procedure has already been completed.

*Ethos Protocol
*
I do not use artificial intelligence to write what I do not know. I use it to test, confront and refine what I can defend. My work is not outsourced. It is authored.

**Agustin V. Startari
**Linguistic theorist and researcher in historical studies
Author of Grammars of Power, Executable Power, The Grammar of Objectivity, and Grammars of Asymmetric Visibility

*Academic basis
*
Startari, Agustin V. “The Illusion of Objectivity: How Language Constructs Authority.” SSRN, 2025. DOI: 10.2139/ssrn.5258415.

The Most Dangerous AI Output at Work Is the Sentence Nobody Argues With

Agustin V. Startari — Sat, 13 Jun 2026 11:49:00 +0000

Why polished AI language can shut down scrutiny before the facts are checked

*TL;DR
*
The most dangerous AI-generated statement in a company is not always the obviously false one.

It is often the sentence that sounds so complete, neutral, and professionally written that nobody feels the need to challenge it.

AI does not merely generate information. It generates linguistic closure. It can transform uncertain assumptions into polished recommendations, contested interpretations into apparent facts, and human decisions into conclusions that seem to have emerged from the system itself.

Managers do not need another checklist for detecting absurd hallucinations. They need a method for identifying sentences that sound stronger than the evidence behind them.

*Meta Description
*
The most dangerous AI output at work may be the polished sentence that shuts down scrutiny before anyone checks its assumptions.

*The Sentence That Ends the Meeting
*
Imagine a management meeting.

Sales are below target. Inventory is increasing. Marketing costs are rising. The team asks an AI system to review the available information and recommend a response.

The answer arrives:

“The most effective strategy is to reduce low-performing inventory, redirect resources toward high-conversion channels, and prioritize customers with stronger lifetime value.”

The sentence sounds reasonable.

It is concise. Balanced. Professional. It contains familiar business language. It offers a clear direction without sounding extreme.

Someone copies it into the meeting notes.

Another person turns it into three action items.

By the following week, purchasing orders have been reduced, marketing expenditure has been redirected, and several customer segments have been deprioritized.

But nobody asked the questions hidden behind the sentence.

What counted as low-performing inventory?

Which period was used to measure performance?

Were seasonal products included?

How was customer lifetime value calculated?

Did the model treat low conversion as evidence of low demand, or could it have reflected poor availability, weak pricing, delayed responses, or ineffective advertising?

Who decided that reducing inventory was preferable to improving sell-through?

The sentence did not answer those questions.

It made them feel unnecessary.

That is the risk.

The AI output did not force the company to make a bad decision. It produced a sentence whose form made disagreement less likely.

The Obvious Error Is Usually the Easier Problem

Organizations are increasingly alert to hallucinations.

Employees are warned that AI can invent quotations, create false statistics, cite nonexistent sources, misread documents, and present incorrect information confidently.

Those failures matter. But they are often detectable.

A fabricated company can be searched.

A false calculation can be recalculated.

A nonexistent regulation can be checked.

An impossible date can be identified.

The more difficult problem begins when the output is plausible.

The figures may be correct. The categories may exist. The recommendation may even be reasonable.

But the transition from evidence to conclusion may still be weak.

The system might identify that one product category has lower margins and then recommend reducing it, without considering that the category attracts customers who later purchase more profitable products.

It might identify that a salesperson has a lower closing rate and imply underperformance, without accounting for lead quality, territory, product availability, or the complexity of assigned accounts.

It might identify higher service costs among a customer segment and recommend tighter restrictions, without measuring the revenue protected by that service.

Nothing in these conclusions needs to be obviously false.

They only need to be incomplete.

When incompleteness is expressed through fluent language, it is easily mistaken for analysis.

*Fluency Is Not Evidence
*
Professional organizations have trained employees to associate certain forms of language with competence.

Clear headings suggest structure.

Short paragraphs suggest control.

Parallel lists suggest completeness.

Neutral language suggests objectivity.

Technical vocabulary suggests expertise.

A direct recommendation suggests that the analysis has already been performed.

AI reproduces these forms extremely well.

That creates a structural confusion inside companies: the quality of the presentation begins to substitute for the quality of the reasoning.

Consider these two statements:

“Maybe we should reduce stock because some products are moving slowly, although I have not checked seasonality or open quotations.”

“Current inventory velocity indicates that a targeted reduction in low-performing stock would improve working-capital efficiency.”

The first statement sounds weak. It openly exposes its uncertainty.

The second sounds managerial. It is more likely to enter a report, presentation, or decision log.

But the second sentence may contain less usable information.

It does not identify the products.

It does not define the measurement period.

It does not explain what “targeted” means.

It does not state whether open sales opportunities were considered.

It does not quantify the expected improvement.

It does not identify the person responsible for interpreting the data.

Its authority comes primarily from its form.

The sentence sounds finished.

The reasoning is not.

*AI Can Produce Decision Closure
*
A company does not need certainty before every action. Managers regularly make decisions with incomplete information.

The problem is not uncertainty.

The problem is concealed uncertainty.

AI-generated business language often converts an open question into what appears to be a completed decision. It does this through a combination of familiar linguistic patterns:

definite recommendations;
abstract business terminology;
impersonal constructions;
compressed causal explanations;
omitted alternatives;
unmarked assumptions;
conclusions without visible decision-makers.

The result can be described as decision closure.

Decision closure occurs when the language of an output makes a matter appear more settled than the supporting evidence justifies.

This does not require manipulation.

It does not require a malicious system.

It does not require a manager who wants to deceive the team.

It can emerge from the ordinary way AI systems are asked to communicate: be concise, sound professional, provide the best answer, remove uncertainty, and give an actionable recommendation.

Each instruction improves readability.

Together, they can eliminate the visible traces of doubt.

Grammar Can Hide the Decision-Maker

Corporate language has always allowed responsibility to be softened or removed.

AI makes this language easier to produce and faster to distribute.

Consider the statement:

“It was determined that the current structure is no longer efficient.”

*Who determined it?
*
Based on which indicators?

Compared with what alternative structure?

Over what period?

The passive construction removes the decision-maker from the sentence.

Now consider:

“A realignment of resources is required.”

*Who requires it?
*
Is it required by law, budget, management preference, customer demand, or a model-generated scenario?

The noun “realignment” also compresses a series of actions. It may mean transferring employees, reducing expenditure, closing a department, changing suppliers, or eliminating positions.

The sentence appears less confrontational because the actors and actions have been converted into abstractions.

Another common form is:

“The data suggests that underperforming accounts should be deprioritized.”

Data does not decide what counts as underperformance.

Someone selects the metric.

Someone chooses the time frame.

Someone establishes the minimum threshold.

Someone determines whether the relevant objective is revenue, profit, retention, strategic access, payment behavior, or growth potential.

The data may support the conclusion.

It cannot assume responsibility for it.

When a company says “the system recommended,” “the analysis found,” or “the data requires,” it can turn a human interpretation into an apparently external necessity.

AI did not remove the decision-maker.

The sentence removed the decision-maker.

The Problem Appears Across the Company

This is not limited to executive strategy.

The same linguistic effect can influence routine decisions in every department.

Sales

An AI tool writes:

“The lead should be classified as low priority due to limited engagement and weak conversion indicators.”

The sentence may reduce follow-up activity.

But perhaps the customer was not contacted quickly enough. Perhaps the assigned product was unavailable. Perhaps the lead came through a channel that records fewer interactions. Perhaps the customer typically buys offline.

The classification looks descriptive.

It changes behavior.

Purchasing

A system recommends:

“Future orders should be reduced to prevent excess exposure.”

The phrase “excess exposure” sounds financially precise.

But it may conceal assumptions about supplier lead times, seasonal demand, shipping delays, minimum order quantities, replacement costs, and pending quotations.

Reducing an order is not merely an analytical conclusion.

It is a risk allocation decision.

Finance

An AI-generated summary states:

“The department’s expenditure pattern indicates insufficient cost discipline.”

That conclusion can alter budgets, approvals, and evaluations.

But the pattern may reflect delayed invoicing, one-time purchases, incorrect coding, emergency repairs, or costs transferred from another department.

A clean sentence can transform an accounting anomaly into a judgment about managerial behavior.

*Human Resources
*
A performance summary reads:

“The employee has demonstrated inconsistent alignment with organizational expectations.”

The language sounds cautious and neutral.

It may be based on vague comments, incomplete records, uneven supervision, or differently interpreted expectations.

The sentence does not appear accusatory.

It can still influence promotion, compensation, or termination.

*Operations
*
An AI report concludes:

“Process delays are primarily attributable to inadequate execution at the departmental level.”

The statement directs attention toward employees or managers.

It may ignore unavailable materials, approval bottlenecks, system failures, unrealistic schedules, or changing priorities.

The recommendation may be written by a machine.

The consequences remain organizational and human.

Why Managers Challenge People but Accept Machines

Managers often challenge uncertain human statements.

“What makes you think that?”

“Where did that number come from?”

“Did you check the open orders?”

“Who confirmed this?”

“What happens if demand increases?”

*Human uncertainty invites interrogation.
*
AI outputs often arrive without the visible behaviors that normally trigger skepticism. The system does not hesitate, defend its position, show discomfort, or signal that it is guessing unless explicitly required to do so.

Its language can remain equally composed across strong evidence, weak evidence, and missing evidence.

This creates an asymmetry.

A hesitant employee may possess direct operational knowledge but sound uncertain.

An AI system may lack critical context but sound complete.

The organization can therefore reward the more polished answer instead of the better-grounded one.

The problem is not that managers believe machines are infallible.

The problem is that professional language reduces the social impulse to challenge them.

A well-written sentence enters a meeting differently from a rough observation.

It feels prepared.

It appears ready for use.

It can be copied directly into a report.

Its form encourages circulation before verification.

*The Disagreement Test
*
Companies do not need to reject AI-generated recommendations.

They need to restore contestability.

Before an AI-generated conclusion becomes an action, the manager should apply a simple disagreement test.

What exact statement could be false?

Do not ask whether the entire response is correct.

Identify the individual claim on which the recommendation depends.

“The product is underperforming.”

“The customer is unprofitable.”

“The employee is inefficient.”

“The campaign is ineffective.”

“The process is too expensive.”

Each claim must be independently testable.

Which assumption is not written?

Every recommendation depends on conditions.

Reducing inventory assumes demand will not rise before replacement stock arrives.

Cutting a marketing channel assumes its contribution is accurately measured.

Prioritizing high-value customers assumes current value predicts future value.

Automating approvals assumes the exceptions are rare and identifiable.

The most important assumption is often the one omitted from the final sentence.

*Who selected the category?
*
Categories do not emerge automatically from reality.

Someone defines “high risk,” “low performance,” “valuable customer,” “excess stock,” “efficient employee,” or “acceptable delay.”

A manager should identify who created the category, what variables it includes, and what it excludes.

Which alternative explanation was rejected?

A strong recommendation should not merely state what appears to be happening.

It should show why competing explanations are less persuasive.

Low sales may indicate weak demand.

They may also indicate inadequate stock, poor visibility, incorrect pricing, slow follow-up, or a market that has not yet matured.

Without alternatives, the system has produced a narrative, not a diagnosis.

Would the conclusion remain persuasive in plain language?

Rewrite the sentence without professional abstractions.

Replace:

“Resource optimization requires a strategic reduction in low-yield customer activity.”

With:

“We plan to spend less time on customers who generated less revenue during the period we selected.”

The second version may still be correct.

But the decision becomes visible.

The actor returns.

The measurement choice becomes explicit.

The sentence can now be challenged.

That is the purpose of the test.

Do Not Ask AI to Sound Certain

Many organizations unintentionally request the exact language that makes weak conclusions harder to detect.

They ask AI to:

remove hesitation;
sound executive;
provide a definitive recommendation;
eliminate unnecessary caveats;
make the message more persuasive;
summarize the issue in one sentence;
avoid technical detail;
produce action items.

These instructions are not inherently wrong.

But they should follow analysis, not replace it.

A better sequence is to require the system to expose its reasoning conditions before producing the polished version.

Ask it to identify:

missing information;
competing explanations;
assumptions affecting the conclusion;
evidence that would reverse the recommendation;
variables not represented in the available data;
people who possess relevant operational context;
the likely cost of a false positive;
the likely cost of a false negative.

Only then should the system produce an executive summary.

The polished sentence should be the final layer.

It should never be the entire analysis.

A Good AI Recommendation Should Be Easier to Disagree With

This sounds counterintuitive.

Organizations usually want recommendations that are clear, defensible, and easy to execute.

But a recommendation that cannot be disputed is not necessarily strong.

It may simply be closed.

A useful AI output should expose the conditions under which it could be wrong.

It should distinguish observation from interpretation.

It should name the relevant time frame.

It should reveal the selected metric.

It should identify missing context.

It should show which human role owns the decision.

It should separate what the data indicates from what management chooses to do.

For example:

“Based on sales recorded during the previous quarter, these products have lower unit velocity than the departmental average. This analysis does not include open quotations, seasonal demand, supplier lead times, or their contribution to related sales. Reducing future orders may improve short-term inventory turnover but may also increase stockout risk. Purchasing management should determine whether that trade-off is acceptable.”

This version is longer.

It is also more useful.

The output does not pretend that the system made the decision.

It identifies the evidence, limits, trade-off, and responsible role.

It preserves management instead of disguising it.

The Manager Remains Responsible

An organization can automate classification, summarization, forecasting, prioritization, and recommendation.

It cannot automate responsibility merely by changing the grammar of the report.

When an AI-generated sentence affects a customer, employee, supplier, budget, or operational process, someone in the organization remains responsible for:

the selected data;
the missing data;
the definition of success;
the acceptable risk;
the final interpretation;
the action taken.

“The AI recommended it” is not an explanation.

It is evidence that the organization has lost track of its own decision process.

Managers should not ask only whether an AI output is accurate.

They should ask what the sentence makes invisible.

Who disappears from the wording?

Which assumption has been converted into a fact?

Which interpretation has been presented as a measurement?

Which choice now looks inevitable?

The most dangerous AI output at work is not necessarily the statement everyone knows is wrong.

It is the statement nobody thinks to question.

*Why It Matters
*
Companies are building faster decision systems.

Reports are generated in seconds.

Customer records are summarized automatically.

Performance evaluations are drafted from existing documentation.

Sales opportunities are ranked.

Inventory is classified.

Budgets are reviewed.

Operational risks are compressed into executive summaries.

The speed is real.

So is the possibility that weak reasoning will move through the organization more quickly because it has been written more professionally.

The central management problem is therefore not only AI accuracy.

It is the relationship between language and authority.

A sentence can be grammatically complete while analytically incomplete.

It can be neutral in tone while redistributing responsibility.

It can appear objective while preserving hidden choices.

It can be useful without being sufficient.

The correct organizational response is not to distrust every AI-generated sentence.

It is to refuse automatic obedience to sentences whose confidence exceeds their evidence.

Related Academic Background

This article extends a broader research program examining how linguistic structures redistribute agency, responsibility, and institutional authority.

Suffering Without Perpetrators: The Humanitarian Passive in AI-Generated Conflict Discourse
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6753123

The Grammar of Asymmetric Visibility: AI, Zionism, and the Reallocation of Political Agency
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6753123

The contexts differ, but the structural question remains consistent: what happens when language preserves the event while weakening the visibility of the actor, decision-maker, or responsible institution?

About the Author

He is the author of Grammars of Power, Executable Power, and The Grammar of Objectivity, and the creator of the ongoing research series Grammars of Asymmetric Visibility.

**ResearcherID: **K-5792-2016

Website:
https://www.agustinvstartari.com/

SSRN Author Page:
https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915

Zenodo Publications:
https://zenodo.org/search?q=%22Agustin%20V.%20Startari%22

Authorial Ethos

I do not use artificial intelligence to write what I don’t know. I use it to challenge what I do. I write to reclaim the voice in an age of automated neutrality. My work is not outsourced. It is authored.

Suggested Tags

Artificial Intelligence, Management, Leadership, Decision Making, Future of Work, AI Governance, Business Strategy, Language, Automation, Enterprise AI

Your Boss Is Becoming AI’s Human Shield

Agustin V. Startari — Wed, 10 Jun 2026 12:23:03 +0000

Enterprise AI is not just changing who decides. It is changing who gets blamed.

The most dangerous sentence in corporate AI is this:

“A human is still in control.”

It sounds responsible. It sounds safe. It sounds like governance.

But in many companies, that sentence may soon mean something very different.

It may mean that a human still clicks approve.

It may mean that a human still attends the meeting.

It may mean that a human still answers the client, the employee, the regulator, or the board.

It may mean that a human still carries the title of manager.

But it does not always mean that the human truly controlled the decision.

*That is the problem.
*
Enterprise AI does not need to replace managers to weaken them. It can do something more subtle. It can structure the decision before the manager sees it, then leave the manager visible when the outcome needs to be explained.

The AI ranks.
The AI scores.
The AI summarizes.
The AI recommends.
The AI routes.
The AI flags.
The AI classifies.
The human approves.
The human explains.
The human absorbs the blame.

That is not human-centered AI.

That is human-centered liability.

The Old Question Is Too Simple

Most people still ask:

Will AI replace managers?

That is the wrong question.

The more serious question is:

Will managers remain responsible for decisions they no longer fully structure?

A manager can keep the same job and still lose authority.

He can keep the same title, same office, same dashboard, same approval rights, and same weekly meetings. Nothing dramatic needs to happen. No announcement is required. No organizational chart needs to change.

But underneath the visible role, the decision process can shift.

The sales pipeline is ranked before the sales manager opens it.

The supplier recommendation is generated before purchasing reviews it.

The risk score is assigned before finance investigates it.

The customer complaint is summarized before service escalates it.

The employee performance pattern is flagged before HR discusses it.

The manager is still there.

But he is arriving after the system has already shaped the field.

That timing matters.

A person who enters only at the final approval stage may still be accountable, but he is not fully sovereign over the decision. He is operating inside a frame built elsewhere.

A Decision Is Not Just the Final Click

Companies like to say that AI only recommends and humans decide.

This is a weak defense.

A decision is not only the final act. A decision is also everything that makes the final act appear reasonable.

What was shown first?
What was hidden?
What was ranked higher?
What was marked as risky?
What was labeled normal?
What was treated as an exception?
What required justification?
What became the default?

These are not technical details. They are managerial forces.

If an AI system recommends Vendor A, Vendor A becomes easier to choose.

If a system ranks Lead 1 above Lead 2, Lead 1 becomes easier to pursue.

If a system marks an invoice as suspicious, that invoice becomes harder to approve.

If a system summarizes a complaint as routine, that complaint becomes easier to ignore.

If a system classifies an expense under the wrong category, the company may misunderstand its own cost structure.

The human may still make the final decision.

But the system has already influenced what the human sees as obvious, urgent, safe, risky, or defensible.

*That is authority.
*
Not authority by command.

Authority by framing.

*The New Corporate Trick: Responsibility Without Control
*
A serious organization should align authority and responsibility.

If you are responsible for a decision, you should have enough authority to understand it, challenge it, change it, and audit it.

Enterprise AI can break that alignment.

The system may be designed by one team, configured by another, bought by executives, integrated by IT, trained on historical data, adjusted by vendors, and used by managers who only see the output.

But when something fails, the organization may still ask the manager:

Why did you approve this?

That question may be formally valid and operationally dishonest.

Did the manager know how the recommendation was produced?

Did he see the alternatives?

Did he know which data was excluded?

Did he understand the threshold?

Did he know whether the model was outdated?

Did he know whether the system over-weighted price, speed, volume, risk, margin, or past behavior?

Could he override the recommendation without penalty?

Could he challenge the workflow without being treated as inefficient?

If the answer is no, then the manager was not fully controlling the decision.

He was carrying it.

That is the difference.

“Human in the Loop” Can Become Theater

The phrase “human in the loop” is now everywhere.

It appears in policy documents, vendor presentations, governance frameworks, compliance programs, and executive speeches.

But the phrase can hide more than it reveals.

A human can be in the loop and still be too late.

A human can be in the loop and still lack the information needed to question the system.

A human can be in the loop and still approve what the system made easiest to approve.

A human can be in the loop and still function as decoration.

The real question is not whether a human appears somewhere in the process.

The real question is what kind of power that human actually has.

Can the human see the logic?

Can the human see competing options?

Can the human understand the recommendation?

Can the human pause the workflow?

Can the human override without punishment?

Can the human inspect the audit trail?

Can the human prove later why he accepted or rejected the system’s output?

Without those elements, “human oversight” becomes a corporate alibi.

It gives the appearance of accountability while leaving the deeper authority inside the system.

*The Dashboard Speaks Before the Manager Does
*
Modern companies do not see themselves directly.

They see themselves through systems.

Dashboards, ERPs, CRMs, HR platforms, ticketing tools, accounting software, forecasting engines, procurement systems, and reporting layers already decide what becomes visible.

When AI enters those layers, the dashboard stops being a passive display.

It becomes an editor of reality.

It decides what deserves attention.

It decides what looks abnormal.

It decides what appears first.

It decides which pattern matters.

It decides what is summarized and what is omitted.

That is not a small change.

In a meeting, the first screen often sets the agenda. The first ranking shapes the conversation. The first warning creates urgency. The first summary becomes the shared version of events.

The manager may speak second.

But the dashboard has already spoken first.

And in corporate life, speaking first is power.

The Manager as Human Shield

Companies will still need managers.

Not always because managers fully control every decision.

Sometimes because companies need a human surface.

A company cannot send an algorithm to apologize to a client.

It cannot put a workflow in front of a regulator.

It cannot make a dashboard explain a failed decision to the board.

It cannot ask a model to take responsibility for a damaged relationship, a missed opportunity, a bad supplier choice, or a wrong internal classification.

So the human remains useful.

The manager becomes the visible face of a decision whose structure may be distributed across software, data, settings, prompts, rankings, thresholds, and workflows.

That is the new role:

Not decision-maker in the full sense.

Not powerless employee either.

Something more uncomfortable.

A human shield for machine-shaped authority.

The company gets automation.

The system gets invisibility.

The manager gets responsibility.

This Is Not Anti-AI

The argument is not that companies should reject AI.

That would be lazy.

AI can improve forecasting, reduce repetitive work, detect anomalies, summarize large volumes of information, support planning, and help managers act faster.

The issue is not the existence of AI.

The issue is invisible delegation.

A company can use AI responsibly only if it knows where authority is moving.

If AI only drafts a paragraph, the risk may be limited.

If AI ranks customers, routes complaints, scores employees, classifies expenses, recommends vendors, prioritizes leads, blocks transactions, or escalates cases, then the system is no longer just assisting.

It is participating in management.

And anything that participates in management must be governed as management.

Not as a toy.

Not as a productivity hack.

Not as a harmless assistant.

As part of the authority structure of the company.

The Five Tests Every Company Should Apply

A company that claims to have human oversight should be able to pass five basic tests.

*First: the visibility test.
*
Can the manager clearly identify where AI enters the decision process?

If the answer is no, the company has hidden delegation.

*Second: the explanation test.
*
Can the manager understand why the system recommended, ranked, flagged, or classified something?

If the answer is no, the manager is approving without real comprehension.

*Third: the alternatives test.
*
Can the manager see what the system did not recommend?

If the answer is no, the system controls the field of comparison.

*Fourth: the override test.
*
Can the manager reject the recommendation without being punished by workflow friction, performance metrics, or managerial pressure?

If the answer is no, the override is theoretical.

*Fifth: the audit test.
*
Can the company reconstruct what the system recommended, what the human accepted, what the human rejected, and what happened afterward?

If the answer is no, the company does not have accountability.

It has a story about accountability.

*A Simple Example: Purchasing
*
Imagine a purchasing manager using an AI-supported procurement system.

The system recommends Vendor A.

Vendor A has a good price, acceptable delivery history, and a low risk score. The dashboard looks clean. The approval path is ready. The manager approves.

Later, the vendor fails during a high-pressure period.

Leadership asks the manager why he approved Vendor A.

The manager approved the recommendation, yes.

But did he know that Vendor B had stronger informal reliability?

Did the model understand current supplier stress?

Did it over-weight price and under-weight continuity?

Did the dashboard show excluded suppliers?

Did the system explain the trade-off?

Did the manager have time to challenge the recommendation?

If not, the company is blaming the person who clicked approve while ignoring the system that shaped approval.

That is not accountability.

That is blame displacement.

*A Simple Example: Sales
*
Now imagine a sales manager using AI lead scoring.

The model ranks prospects. The team follows the ranking. The manager reviews the pipeline. Everyone believes the sales priorities were human-approved.

But the model may favor accounts that resemble past wins.

It may ignore strategic accounts with slower cycles.

It may punish unusual opportunities.

It may over-value recent digital activity and under-value relationship history.

Months later, revenue disappoints.

The manager is asked why the team neglected certain accounts.

The answer may be uncomfortable:

Because those accounts were made invisible by the system.

Not deleted.

Not banned.

Just pushed below the attention line.

In business, that is often enough.

What falls below attention eventually falls outside action.

*A Simple Example: Finance
*
Finance looks objective because it uses numbers.

But numbers depend on classification.

An AI system that classifies expenses, assigns codes, or groups transactions is not only doing administrative work. It is shaping how the company understands itself.

Wrong classification can distort departmental costs, project margins, vendor exposure, recurring expenses, and operational leakage.

A controller may review the final report.

But if the underlying classification frame is wrong, the review begins too late.

The company will think it is looking at reality.

It is actually looking at reality after software has translated it.

And every translation carries authority.

The Real Risk: Accountability Laundering

The central risk is accountability laundering.

Authority enters the system.

Responsibility exits through the human.

The workflow shapes the decision, but the approval log names the manager.

This is extremely convenient.

For vendors, it allows systems to influence decisions while claiming they only assist.

For executives, it creates efficiency while preserving plausible human accountability.

For companies, it protects the institution when outcomes fail.

For managers, it creates a dangerous trap.

They remain visible enough to be blamed, but not powerful enough to fully control the process.

That is the structure serious companies need to confront.

Not because AI is evil.

Because bad accountability design is enough.

The Question Managers Should Ask

Every manager facing an AI-shaped workflow should ask:

Am I being given authority, or only liability?

That question is more important than any product demo.

If the system gives the manager visibility, explanation, alternatives, override rights, and audit trails, then AI may genuinely support management.

But if the system only provides polished outputs, ranked lists, clean dashboards, automated summaries, and recommended actions, then the manager is not fully governing.

He is operating inside a frame.

And if he is responsible for that frame without controlling it, he is not being empowered.

He is being exposed.

The Core Claim

AI will not simply replace managers.

That headline is too crude.

The deeper transformation is more institutional.

AI may keep managers in place while moving real authority into systems.

The manager remains the signer.

The system becomes the framer.

The company preserves deniability.

The blame remains human.

That is why the future of enterprise AI cannot be discussed only in terms of productivity.

It must be discussed in terms of authority.

Who frames the decision?

Who sees the alternatives?

Who controls the default?

Who owns the recommendation?

Who can challenge the workflow?

Who gets blamed when the system fails?

Until companies can answer those questions clearly, “human oversight” should not reassure us.

It should make us suspicious.

Because a human can be present and still be used.

And the next corporate AI scandal may not begin with a machine making a decision alone.

It may begin with a manager approving a decision that was never fully his.

*Related Academic Background
*
This article extends my broader work on artificial intelligence, language, authority, and institutional responsibility.

My research examines how formal systems redistribute agency and accountability through syntax, classification, interface design, automation, and institutional language. This includes my work on AI-powered ERP misclassification, executable authority, corporate decision structures, and the grammar of responsibility inside automated environments.

*The central issue is consistent:
*
When systems classify, rank, route, summarize, recommend, or frame events, they do not merely assist institutions.

They reshape how institutions see, decide, justify, and blame.

Author

Agustin V. Startari is a linguistic theorist, author, and researcher in historical studies. His work examines how language, artificial intelligence, and formal systems redistribute authority, agency, and responsibility in contemporary institutions. He is the author of Grammars of Power, Executable Power, The Grammar of Objectivity, and Grammars of Asymmetric Visibility.

ResearcherID: K-5792-2016
Website: https://www.agustinvstartari.com/
SSRN: https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915
Zenodo: https://zenodo.org/search?q=%22Agustin%20V.%20Startari%22

Ethos

— Agustin V. Startari

Your Manager Is Becoming an AI Front-End

Agustin V. Startari — Tue, 02 Jun 2026 13:08:50 +0000

How enterprise AI turns human managers into the visible interface of decisions already shaped by software
TLDR

The next corporate AI problem is not that artificial intelligence will replace managers. It is that managers may remain formally responsible while AI systems quietly structure the decisions before managers see them.

The manager stays visible.
The workflow becomes automated.
The recommendation becomes the default.
The dashboard becomes the briefing.
The human becomes the interface.

That is not replacement.
It is a more subtle redistribution of authority.

*1. The Manager Is Still There, But Too Late
*
The common fear is simple: AI will replace managers.

That fear is too obvious.

A more realistic change is already emerging inside companies. The manager is not removed. The manager remains in the meeting, approves the purchase order, reviews the dashboard, signs the report, accepts the forecast, and answers for the result.

But the decision may have begun somewhere else.

Before the manager acts, an AI system may have already ranked the leads, flagged the vendor, assigned the risk score, selected the metric, summarized the customer complaint, recommended the reorder quantity, or routed the approval path.

The human manager still appears to decide. But the field of decision has already been arranged.

This is the new corporate structure:

AI does not need to become the boss.
It only needs to prepare the boss’s options.

That preparation matters because management is not only final approval. Management is also the power to decide what appears first, what appears urgent, what appears risky, what appears normal, what appears exceptional, and what never appears at all.

A manager who only sees the final ranked list is not operating from raw business reality. He is operating from a pre-structured version of that reality.

The company may still say, “The manager decided.”

The better question is:

Who shaped the decision before the manager saw it?

*2. The Dashboard Becomes the Real Briefing
*
In many companies, the dashboard is no longer just a reporting tool.

It is the first layer of managerial perception.

Sales teams look at pipeline dashboards.
Purchasing teams look at vendor dashboards.
Inventory teams look at stock dashboards.
Finance teams look at classification dashboards.
Customer service teams look at escalation dashboards.
Executives look at summary dashboards.

This creates a simple but powerful shift.

What the dashboard shows first becomes what the company discusses first.

That is not neutral.

If an AI system ranks customers by predicted revenue, the sales team may naturally focus on those customers. If the model underestimates a smaller but strategically important client, that client may disappear from attention.

If an inventory dashboard highlights overstock risk but hides supplier fragility, managers may discuss warehouse efficiency while missing the coming supply problem.

If a finance dashboard flags unusual expenses but does not explain the classification logic, the manager may spend time reviewing harmless anomalies while a more serious pattern remains invisible.

A dashboard does not only display reality. It edits reality.

Once AI enters that editing layer, the company’s attention becomes machine-shaped.

This is not science fiction. It is ordinary business.

The meeting begins.
The screen is opened.
The dashboard speaks first.
The manager reacts second.

That order is the real chain of command.

*3. Recommendation Is Not Neutral
*
Companies often treat AI recommendations as harmless because the human still has the final word.

That is a weak argument.

A recommendation inside a business workflow is not the same as a casual suggestion. It appears inside a system of pressure, speed, workload, habit, hierarchy, and operational urgency.

When a system recommends a vendor, that vendor becomes easier to choose.

When a system ranks a lead as high priority, that lead becomes easier to pursue.

When a system marks a customer as low risk, that customer becomes easier to ignore.

When a system flags an invoice as suspicious, that invoice becomes harder to approve.

When a system suggests a reorder quantity, that quantity becomes the default starting point.

The recommendation does not need to force the decision. It only needs to make one path easier than the others.

That is how corporate authority often works.

Not by command.
Not by violence.
Not by dramatic control.

By defaults.

Defaults are powerful because they reduce friction. The recommended option is already there. The alternative requires explanation. The override requires effort. The exception requires justification.

So the system does not need to say, “You must choose this.”

It only needs to say:

“This is the recommended option.”

In corporate life, that is often enough.

*4. The Human Override Myth
*
Most companies defend AI adoption with one reassuring phrase:

There is human oversight.

The phrase sounds responsible. But it often hides a major problem.

Oversight is not meaningful if the human only sees an already processed result.

A manager may be able to override an AI recommendation. But what exactly is being overridden?

The final number?
The risk label?
The priority score?
The routing decision?
The classification?
The hidden threshold?
The model weighting?
The excluded alternative?

Human oversight becomes weak when the human cannot see how the recommendation was produced.

Imagine a purchasing manager reviewing an AI-generated supplier recommendation. The system suggests Vendor A. The price looks reasonable. The delivery score looks good. The risk label is low. The approval path is already prepared.

The manager can technically choose Vendor B.

But if Vendor B was ranked lower by a model using incomplete or outdated data, the manager may never know. If the system ignored informal supplier reliability, the manager may never see it. If the model over-weighted price and under-weighted strategic continuity, the dashboard may not reveal that.

The manager has oversight over the output, but not over the construction of the output.

That is not full oversight.

It is supervised acceptance.

The same problem appears in sales. A sales manager may review a list of prioritized leads. The model ranks them. The team follows the ranking. Later, leadership asks why certain accounts were neglected.

The manager approved the focus list.

But did the manager design the scoring logic?
Did the manager know which signals were excluded?
Did the manager know why one client was pushed down?
Did the manager know whether the model understood local market context?

If the answer is no, then the manager was not fully managing.

He was operating through a machine-shaped frame.

*5. AI Does Not Need to Fire You to Manage You
*
The public debate usually asks whether AI will replace jobs.

That question is too narrow.

AI can transform a job without eliminating it.

A person can keep the same title, same office, same salary, and same formal responsibility while losing control over the structure of his own decisions.

This is especially important for managers.

AI does not need to fire a manager to manage the manager.

It can define which metrics matter.
It can order the daily priorities.
It can flag which employees need attention.
It can rank which customers deserve follow-up.
It can recommend which expenses deserve review.
It can decide which tickets look urgent.
It can summarize which problems leadership sees first.
It can classify which actions look normal or abnormal.

The manager still works. But the system increasingly defines the environment in which that work happens.

That is the quiet transformation.

AI does not sit above the manager on the organization chart. It sits beneath the manager inside the workflow.

And because it sits beneath, it is harder to see.

A human boss gives instructions.
A system changes the conditions.

A human boss says, “Do this.”
A system makes one action easier, faster, more visible, more defensible, or more urgent than another.

That is a different kind of management.

It is not command by speech.
It is command by structure.

*6. The Manager as Liability Shield
*
Here is the uncomfortable part.

Companies may still need human managers not because humans control every decision, but because humans absorb responsibility.

A company cannot easily blame a dashboard in a board meeting.

It cannot send a workflow to explain itself to a client.

It cannot ask a model to defend a decision before a regulator.

It cannot make an algorithm apologize to a supplier, employee, investor, or customer.

So the human manager remains useful.

Not always as the true origin of the decision, but as the visible owner of the outcome.

This creates a dangerous split:

Authority becomes distributed across systems.
Responsibility remains concentrated on people.

The AI ranks.
The AI routes.
The AI flags.
The AI classifies.
The AI recommends.
The AI prepares.
The human approves.
The human answers.

That structure is convenient for organizations because it preserves the appearance of accountability.

There is always someone to ask.
There is always someone to blame.
There is always someone whose name appears in the approval history.

But the deeper authority may be hidden in system configuration, model design, data quality, prompt structure, workflow logic, permission settings, thresholds, and dashboard architecture.

That is why “human in the loop” is not enough.

A human can be in the loop and still arrive too late.

A human can approve a decision without controlling the frame.

A human can accept a recommendation without knowing what alternatives were suppressed.

A human can be responsible for a process whose authority was already embedded elsewhere.

This is the new liability problem of enterprise AI.

Not that nobody is responsible.

That the visible responsible person may not be the real structuring agent.

*7. The New Test: Who Framed the Decision?
*
Companies need a better test for AI governance.

The old question is:

Who made the decision?

The new question should be:

Who framed the decision before it was made?

This question is more precise because modern corporate decisions rarely appear as isolated acts. They are prepared through multiple layers.

Data enters the system.
A model interprets it.
A rule filters it.
A dashboard displays it.
A ranking orders it.
A workflow routes it.
A recommendation appears.
A human reviews it.
An action is taken.

By the time the human acts, several forms of authority may have already operated.

So the company should ask:

Who selected the data?
Who defined the categories?
Who set the threshold?
Who designed the ranking?
Who wrote or approved the prompt?
Who decided what the dashboard shows first?
Who decided what requires escalation?
Who decided what can move automatically?
Who can override the system?
Who reviews override patterns?
Who audits the business impact?

These are not technical details. They are management questions.

Because whoever controls the frame controls much of the decision.

A manager who cannot answer these questions may still be a manager on paper. But operationally, he may be managing through a system he does not fully govern.

That is the real risk.

Not that managers vanish.

That managers become front-ends.

Why This Matters

This matters because companies already live inside software.

The modern company is not managed only through meetings, calls, emails, and human judgment. It is managed through ERP systems, CRM platforms, HR dashboards, inventory tools, ticketing systems, accounting software, approval workflows, forecasting engines, and reporting layers.

When AI enters those layers, it does not need to become conscious to become powerful.

It only needs to influence sequence, priority, classification, routing, visibility, and timing.

Those are managerial functions.

A company can survive a bad AI paragraph.

A company may not survive repeated AI-shaped distortions in purchasing, finance, inventory, sales, compliance, or customer service.

The real danger is not one dramatic failure. It is the slow normalization of machine-shaped management with human-shaped accountability.

The manager becomes the person who explains decisions that were already partially arranged by systems.

That is not efficiency alone.

It is institutional redesign.

A Simple Example: Sales

Consider a sales team using AI lead scoring.

The system ranks prospects from highest to lowest priority. The sales manager reviews the list. The team focuses on the top group. Everyone says the manager chose the priorities.

But the model may have over-weighted recent activity and under-weighted long-term relationship value.

It may have missed local knowledge.

It may have penalized accounts that do not behave like the historical data.

It may have pushed unusual but valuable leads below the attention line.

The manager still made a decision.

But the system shaped what looked worth deciding.

If revenue falls later, leadership may ask the sales manager what happened.

The better question is whether the company audited the scoring logic that shaped the sales manager’s attention.

A Simple Example: Purchasing

Now consider purchasing.

An AI system recommends a vendor based on price, delivery history, payment terms, and risk score. The purchasing manager approves it.

Everything looks normal.

But the system may not understand that another supplier, slightly more expensive, has a stronger informal reliability record during high-pressure periods. It may not understand that a vendor with good historical data is currently unstable. It may not understand that a small delay in one product category creates larger operational damage elsewhere.

The manager sees a clean recommendation.

The business later experiences disruption.

Formally, the purchasing manager approved the choice.

Operationally, the AI structured the choice.

That distinction matters.

A Simple Example: Finance

In finance, AI classification can look harmless because it appears administrative.

But classification is not minor.

An expense code affects reporting.
Reporting affects interpretation.
Interpretation affects management.
Management affects future decisions.

If an AI system misclassifies recurring expenses, the company may misunderstand departmental cost, project profitability, vendor exposure, or operational leakage.

The controller may review the final report. But if the underlying classification frame is wrong, the review begins too late.

Finance is not only numbers. It is the structure through which the company becomes legible to itself.

When AI changes that structure, it changes what the company thinks it knows.

A Simple Example: Customer Service

Customer service depends heavily on escalation.

Which complaint is urgent?
Which customer receives attention first?
Which issue appears systemic?
Which case is treated as ordinary noise?

If AI ranks complaints, summarizes customer messages, and recommends escalation levels, it shapes the company’s moral and commercial attention.

A customer may not be ignored because a person decided to ignore him.

He may be ignored because the system made his complaint look less urgent than another.

That is not a small distinction.

In service environments, visibility is care.
Invisibility is neglect.

AI that controls visibility participates in the treatment of the customer.

The Corporate Illusion

The corporate illusion is that AI remains subordinate because humans still approve the final act.

But final approval is not the whole decision.

A decision is also made through:

What is shown.
What is hidden.
What is ranked.
What is delayed.
What is escalated.
What is framed as risky.
What is framed as routine.
What is made easy.
What is made difficult.
What requires justification.
What becomes the default.

AI agents can influence all of these without appearing as formal decision-makers.

That is why the language of “assistant” is no longer enough.

An assistant helps someone act.

A front-end lets someone appear to act while the deeper system structures the action.

That is the difference.

What Companies Should Track

If companies want real accountability, they need to audit AI authority, not just AI output.

For every AI system that influences operational decisions, companies should be able to answer:

What business process does it affect?

Does it only summarize, or does it recommend?

Does it rank people, customers, vendors, products, tasks, risks, or priorities?

Does it trigger workflows?

Does it change records?

Does it block or delay action?

Does it create a default option?

Does the human reviewer see alternatives?

Can the human reviewer understand the recommendation path?

Are overrides logged?

Are ignored recommendations logged?

Are business outcomes compared against AI recommendations?

Who owns the system when it is wrong?

This is not anti-technology. It is basic managerial hygiene.

A company that cannot answer these questions is not using AI strategically.

It is delegating authority without a map.

What Managers Should Demand

Managers should not reject enterprise AI.

They should reject invisible delegation.

A serious manager should demand five things before accepting AI-shaped workflows.

First, visibility.

The manager should know where AI enters the decision chain.

Second, explanation.

The manager should understand the main reason behind a recommendation, ranking, classification, or escalation.

Third, alternatives.

The system should show what was not selected, not only what it recommends.

Fourth, override rights.

A manager must be able to challenge the output without being treated as an obstacle to efficiency.

Fifth, audit trails.

The company must record what the system recommended, what the human accepted, what the human rejected, and what happened afterward.

Without these five elements, managers risk becoming decorative accountability.

They remain responsible because the company needs a human face.

But they do not fully control the system that shapes the decision.

What Developers Should Understand

Developers building enterprise AI are not only building tools.

They are designing decision environments.

A ranking is not just a ranking when it determines which customer gets called first.

A classification is not just a classification when it affects financial reporting.

A prompt is not just a prompt when it converts messy business language into executable workflow.

A threshold is not just a threshold when it decides whether something is escalated, blocked, approved, or ignored.

A default is not just a default when most users accept it.

This does not mean developers are personally responsible for every corporate outcome. But it does mean technical design has managerial consequences.

The central design question should be:

Where does this system acquire practical authority?

If the answer is “nowhere,” the system may be a tool.

If the answer is “in ranking, routing, blocking, classifying, escalating, or triggering action,” the system is part of management.

It should be treated that way.

The Core Claim

Your manager is not disappearing.

That would be too simple.

Your manager may remain exactly where he is, with the same title, same duties, same meetings, same approval rights, and same formal accountability.

But underneath that visible role, enterprise AI may increasingly structure what the manager sees, what the manager ignores, what the manager approves, what the manager questions, and what the manager must later explain.

That is the deeper transformation.

The manager becomes the human front-end of AI-shaped authority.

The face remains human.
The frame becomes synthetic.
The responsibility remains visible.
The authority becomes distributed.
The decision still has a signer.
But the decision may no longer begin with the signer.

That is the future companies need to audit.

Not because AI is evil.

Because authority that hides inside workflows is still authority.

*Related Academic Background
*
This article extends my broader work on how artificial intelligence systems redistribute agency, responsibility, and authority through formal and operational structures.

*Related paper:
*
Agustin V. Startari, “Expense Coding Syntax: Misclassification in AI-Powered Corporate ERPs,” SSRN Electronic Journal, 2025.
https://doi.org/10.2139/ssrn.5361952

That paper examines how AI-powered ERP systems can produce misclassification risks when automated language and coding structures convert business events into financial categories. The broader issue is the same: when AI systems classify, route, prioritize, or encode business events, they do not merely represent the company. They reshape how the company becomes visible, manageable, and accountable.

*Why It Matters for Everyone
*
This is not only a problem for executives.

Employees should care because their work may be evaluated through AI-shaped metrics.

Managers should care because they may become responsible for decisions they did not fully structure.

Developers should care because technical defaults can become managerial authority.

Customers should care because their complaints, requests, risks, and value may be ranked before a person ever sees them.

Investors should care because operational opacity can hide risk until it becomes financial damage.

Regulators should care because formal human oversight may not be enough when the decision frame is machine-generated.

The real AI revolution in companies will not always look spectacular.

It may look like a normal dashboard.
A normal score.
A normal recommendation.
A normal approval path.
A normal classification.
A normal workflow.

That is exactly why it matters.

The most powerful systems are often the ones that disappear into routine.

*Call to Action
*
Read more of my work on artificial intelligence, language, authority, and institutional responsibility:

Website: https://www.agustinvstartari.com/
SSRN Author Page: https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915
Zenodo publications: https://zenodo.org/search?q=%22Agustin%20V.%20Startari%22

Author

Agustin V. Startari is a linguistic theorist, author, and researcher in historical studies. His work examines how language, artificial intelligence, and formal systems redistribute authority, agency, and responsibility in contemporary institutions. He is the author of Grammars of Power, Executable Power, and The Grammar of Objectivity.

Researcher ID: K-5792-2016
Author website: https://www.agustinvstartari.com/
SSRN Author Page: https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915

**
**

Agustin V. Startari.

Stop Calling It an AI Assistant. It’s Already Managing Your Company

Agustin V. Startari — Fri, 22 May 2026 12:39:00 +0000

The hidden authority of AI agents inside ERP, purchasing, inventory, approvals, and enterprise workflows
TL;DR

The next enterprise AI risk is not that a chatbot writes a bad email. It is that an AI agent quietly enters the operational layer of the company and starts ranking priorities, routing approvals, classifying risk, delaying purchases, escalating tickets, flagging customers, and shaping managerial decisions before anyone calls it management.

Companies still describe these systems as “assistants” because the word sounds harmless. But once a system can trigger action inside an ERP, CRM, inventory platform, purchasing workflow, or finance dashboard, it is no longer merely assisting.

It is participating in management.

The problem is not automation itself. The problem is invisible delegation: authority moves into workflows, prompts, thresholds, model outputs, and software rules, while responsibility remains formally assigned to humans who may only see the final recommendation.

That is how an AI assistant becomes a shadow manager.

Meta Description

AI agents inside ERP, purchasing, inventory, finance, and enterprise workflows are no longer just assistants. They increasingly rank, route, classify, escalate, and shape operational decisions. This article explains how invisible delegation turns AI into shadow management.

*1. The Assistant Myth
*
Everyone calls them AI assistants because “assistant” sounds harmless.

An assistant helps. An assistant supports. An assistant drafts, summarizes, searches, reminds, and organizes.

That language is accurate only while the system remains outside the decision chain.

Once the system can rank leads, block a purchase order, classify a vendor, flag a customer, recommend a reorder quantity, trigger a workflow, escalate a ticket, assign urgency, or prepare an approval path, the term “assistant” becomes misleading.

At that point, the system is no longer just helping a manager.

It is shaping the managerial environment before the manager acts.

This distinction matters because enterprise work is not made only of final decisions. Most corporate power lives in prioritization, routing, classification, timing, and escalation. Whoever controls those layers does not need to sign the final approval to influence the outcome.

A sales manager may still approve the weekly focus list, but if an AI system ranked the leads first, part of the commercial decision has already been made.

A purchasing manager may still approve the order, but if the ERP agent has already recommended the vendor, adjusted the quantity, flagged the risk, and routed the approval path, the decision has already been pre-shaped.

A finance controller may still review the expense, but if an AI classifier has already coded the transaction and assigned its risk level, the human review begins inside a frame built by the system.

That is the assistant myth: the company believes AI is supporting decisions when, in practice, AI is already structuring them.

The human manager remains visible. The automated manager remains embedded.

*2. From Chatbots to Agents
*
The first wave of enterprise AI was easy to understand.

A chatbot answered questions. A writing tool drafted text. A summarizer compressed documents. A search assistant retrieved information.

Those tools could be wrong, but their wrongness usually stayed inside language. A bad answer could be corrected. A weak summary could be rewritten. A hallucinated paragraph could be deleted.

AI agents are different.

An agent is not only a text generator. It receives a goal, consults tools, uses data, plans steps, invokes functions, and may change the state of a system.

That shift changes the risk model.

A chatbot says: “You may want to reorder this item.”

An agent creates a draft purchase order.

A chatbot says: “This customer seems high priority.”

An agent moves that customer to the top of the pipeline.

A chatbot says: “This invoice may be misclassified.”

An agent changes the expense code.

A chatbot says: “This ticket looks urgent.”

An agent escalates it to another department.

The first system produces language. The second system produces operational consequences.

That is the line companies often fail to mark.

The word “assistant” hides the transition from advice to action. But enterprise systems do not care whether a workflow was triggered by a human, a script, a rule, or a model. Once the system state changes, the company has acted.

This is where AI becomes managerial.

Not because it has a job title. Not because it sits in a meeting. Not because it appears on the organization chart.

It becomes managerial because it shapes attention, timing, access, priority, and execution.

*3. Where the Shadow Manager Appears
*
The shadow manager does not appear as a robot boss.

It appears as a workflow.

It appears as a recommendation that nobody questions because it came from the dashboard.

It appears as a priority score.

It appears as a blocked order.

It appears as an automatic escalation.

It appears as a vendor warning.

It appears as a risk label.

It appears as an approval path that feels procedural but was shaped by a model.

This is already visible in ordinary enterprise operations.

In sales, an AI system may rank leads according to predicted conversion. That ranking influences which customer receives attention first. The salesperson may think they are choosing, but the field of choice has already been ordered.

In purchasing, an AI agent may recommend suppliers based on price, delivery history, stock availability, vendor score, payment terms, or risk profile. That recommendation can quietly shift purchasing behavior away from human relationship knowledge and toward model-weighted criteria.

In inventory, an agent may recommend reorder quantities, flag slow-moving items, identify overstocks, and predict demand. If those predictions are wrong, the error does not remain theoretical. It becomes cash tied in stock, delayed sales, missing products, emergency orders, or warehouse friction.

In customer service, an AI system may decide which complaint deserves escalation. That decision affects response time, customer satisfaction, and the perceived seriousness of the issue.

In finance, AI classification may assign expenses, flag anomalies, group transactions, or prepare reports. If the classification is wrong, the error can affect reporting quality, cost-center visibility, departmental accountability, and managerial interpretation.

In operations, AI may summarize performance, highlight bottlenecks, and define what leadership sees first. That is not neutral. The first metric shown often becomes the first problem discussed.

The shadow manager does not need to make every decision.

It only needs to shape the order in which decisions become visible.
**

The Hidden Chain of Command**

Traditional corporate authority is usually imagined as a clean hierarchy.

Owner. Executive. Manager. Supervisor. Employee. Action.

Enterprise AI complicates that structure.

The real chain can become:

Policy. System configuration. Data source. Prompt. Model output. Workflow trigger. Dashboard ranking. Human approval. Operational action.

The human remains inside the chain, but not always at the beginning of it.

This matters because responsibility is often assigned at the visible end of the process, while influence may have entered much earlier.

A manager may approve a purchase order without knowing that the recommended quantity was produced by a demand model trained on incomplete seasonal data.

A sales lead may be ignored because a scoring system placed it below the threshold, even though the model failed to capture a relationship or local market signal.

A warehouse adjustment may be flagged as suspicious because the system misread an operational pattern.

An accounts receivable account may be deprioritized because the dashboard over-weighted one indicator and under-weighted another.

In each case, the human did not disappear. But the human arrived late.

That is the key structure.

The visible manager signs, approves, reviews, or accepts. The invisible system has already arranged the options.

This is not the end of human authority. It is the redistribution of authority across software layers.

The company still says “the manager decided.”

But the better question is: who structured the decision before the manager saw it?

*5. Why ERP Makes This More Serious
*
AI inside a document editor is useful.

AI inside an ERP is different.

An ERP is not just software. It is the operational nervous system of the company. It connects sales, purchasing, inventory, accounting, logistics, invoicing, vendor records, customer records, product movement, and reporting.

When AI enters that layer, errors become operational.

A weak paragraph is a content problem. A wrong reorder suggestion is a cash problem. A bad vendor classification is a supply problem. A wrong expense code is a reporting problem. A bad lead ranking is a revenue problem. A wrong delivery priority is a customer problem. A bad inventory signal is a service problem.

This is why enterprise AI cannot be judged only by generic model benchmarks.

A model does not need to be generally “smart” to create damage. It only needs to be wrong at the point where the business acts.

The most dangerous AI in a company may not be the most advanced model. It may be the boring workflow nobody audits.

The purchase recommendation. The lead score. The automatic approval rule. The AR risk flag. The reorder suggestion. The inventory exception. The vendor ranking. The escalation logic.

These systems become powerful because they sit close to action.

They do not merely describe the business. They participate in running it.

This is why companies need a different vocabulary. Calling these systems “assistants” is not enough. In operational environments, an AI system should be classified according to its action rights.

Can it read data? Can it recommend action? Can it trigger action? Can it block action? Can it route approval? Can it change records? Can it reorder priorities? Can it modify system state?

The moment the answer becomes yes, the company is no longer dealing with a passive tool.

It is dealing with delegated operational authority.

6. The Accountability Gap

Most enterprise AI discussions focus on hallucination.

That focus is too narrow.

Hallucination matters when a model invents facts. But in enterprise workflows, the more common danger may be misclassification, over-ranking, under-ranking, false escalation, silent omission, wrong routing, and unexamined recommendation.

The system does not need to hallucinate to create harm.

It can use real data and still produce a bad decision structure.

It can classify an account as low priority because the available data is incomplete.

It can recommend delaying a purchase because it underestimates demand.

It can flag an employee action as unusual because the workflow does not understand local practice.

It can prioritize one customer because the model values transaction size over strategic relevance.

It can mark an item as slow-moving while ignoring a coming seasonal spike.

These are not hallucinations. They are operational distortions.

The accountability gap appears when nobody can answer seven basic questions:

What data did the system use?

What rule or model produced the recommendation?

What threshold was applied?

What alternatives were suppressed?

Who reviewed the output?

Who had authority to override it?

What happened after the recommendation was accepted?

Without those answers, the company has built authority without memory.

A human manager can be questioned. A workflow often cannot. A model output may be overwritten. A system recommendation may leave no readable trace. A dashboard may show the result without exposing the path.

That is not automation maturity. It is managerial opacity.

7. What Developers and Operators Should Log

The solution is not to reject AI agents.

The solution is to stop pretending they are harmless assistants once they touch operational decisions.

If an AI system can influence action, it needs an audit trail.

At minimum, enterprise AI agents should log:

Input source.

Data timestamp.

Prompt or instruction version.

Model version.

Tool used.

External system accessed.

Rule applied.

Threshold used.

Recommendation generated.

Action triggered.

Human reviewer.

Override status.

Final decision.

Business impact.

Error category, if later detected.

This is not bureaucratic decoration. It is the basic condition for operational accountability.

If a purchasing agent recommends a quantity, the company should know why.

If a sales agent ranks a lead, the company should know what signals mattered.

If a finance classifier assigns an expense category, the company should know which rule or model produced the classification.

If an inventory agent flags an item, the company should know whether the signal came from sales history, warehouse movement, vendor delay, forecast variance, or a model-generated probability.

This is how enterprise AI becomes governable.

Not by asking whether the system is impressive.

By asking whether its authority is visible.

A Better Test: Authority, Not Intelligence

The wrong question is:

“Is this AI intelligent?”

The better question is:

“What authority does this AI have?”

That question changes the entire evaluation.

A simple model with access to an ERP approval workflow may have more operational power than a more advanced model trapped inside a chat window.

A mediocre classifier embedded in finance may produce more business risk than a brilliant writing assistant.

A small automation that blocks orders may matter more than a large model that only drafts emails.

Enterprise AI should therefore be evaluated by authority level, not only by capability.

Level 1: It reads information.

Level 2: It summarizes information.

Level 3: It recommends action.

Level 4: It routes action.

Level 5: It triggers action.

Level 6: It blocks action.

Level 7: It changes system state with limited human review.

The higher the level, the stronger the audit requirement.

This framework is simple, but it prevents the core mistake: treating all AI outputs as if they were merely advisory.

They are not.

Some outputs become instructions. Some recommendations become defaults. Some defaults become behavior. Some behavior becomes policy. Some policy becomes authority.
**

Why Managers Should Care**

Managers should care because AI agents can make them responsible for decisions they did not fully structure.

A manager may be asked why an order was delayed. The real cause may be a workflow rule.

A manager may be asked why a customer was ignored. The real cause may be a lead-ranking model.

A manager may be asked why inventory ran short. The real cause may be a bad demand signal.

A manager may be asked why expenses were misclassified. The real cause may be an automated coding system.

In all these cases, the manager remains accountable while the system remains partially invisible.

That is a bad trade.

AI should reduce operational burden, not create a fog of responsibility.

For managers, the practical rule is direct: never allow an AI agent to influence action without knowing where its recommendation appears, how it is produced, how it can be challenged, and who owns the final decision.

Management cannot be delegated into a black box and then recovered only when something fails.
**

Why Developers Should Care**

Developers should care because every enterprise AI agent is also a governance system.

A function call is not just a technical event when it changes a purchase order, a customer priority, a stock level, an invoice category, or an approval path.

A ranking algorithm is not just a ranking algorithm when it determines who gets attention first.

A classification model is not just a classifier when departments rely on it for reporting, escalation, or compliance.

A prompt is not just a prompt when it controls how operational language is converted into action.

This means developers are not merely building features. They are designing decision environments.

That does not mean developers become the moral owners of every business outcome. It means technical design choices can create managerial consequences.

What gets logged matters.

What gets hidden matters.

What becomes the default matters.

What can be overridden matters.

What requires human review matters.

What silently moves forward matters.

Enterprise AI development should therefore include one question in every workflow design:

Where does this system acquire practical authority?

That question is more useful than vague debates about whether AI will replace managers. In many companies, replacement is not the first step. Quiet redistribution is.

The job title stays human. The workflow becomes automated. The decision frame becomes synthetic. The responsibility remains unclear.

That is the shadow manager problem.

11. The Core Claim

Stop calling it an AI assistant if it can manage priority, routing, approval, classification, escalation, or execution.

Inside enterprise systems, assistance can become authority without changing its name.

That is the risk.

Not evil AI. Not science fiction. Not a robot CEO. Not a dramatic replacement of human managers.

The real shift is quieter.

AI enters the company as a helper. It gets connected to tools. It receives access to business data. It starts producing recommendations. Those recommendations become defaults. Those defaults shape workflows. Those workflows shape decisions. Those decisions shape the company.

By the time leadership notices, the assistant is already managing part of the business.

The future of enterprise AI will not be decided only by which model writes better emails or produces cleaner summaries.

It will be decided by which systems can act inside companies without making responsibility disappear.

Why It Matters

This matters because modern companies already run through software.

Sales teams follow dashboards. Purchasing follows workflows. Inventory follows system signals. Finance follows classifications. Managers follow reports. Executives follow summaries.

When AI enters those layers, it does not need to dominate the company to change it. It only needs to reorder what the company sees, delays, escalates, approves, or ignores.

The practical danger is not that AI becomes conscious.

The practical danger is that AI becomes procedural.

It becomes part of how the company moves.

And once it moves the company, it must be audited as authority, not described as assistance.

Related Academic Background

This article extends my broader work on how automated language systems redistribute agency, responsibility, and authority through formal structures.

*Related paper:
*
Expense Coding Syntax: Misclassification in AI-Powered Corporate ERPs https://doi.org/10.2139/ssrn.5361952

The paper examines how AI-powered ERP systems can produce misclassification risks when automated language and coding structures convert business events into financial categories. The broader issue is the same: when automated systems classify, route, or encode decisions, they do not merely represent the business. They reshape how the business becomes legible and actionable.

*About the Author
*
Agustin V. Startari is a linguistic theorist, author, and researcher in historical studies. His work examines the relationship between artificial intelligence, syntax, authority, institutional discourse, and the disappearance of agency in automated language systems.

He is the author of Grammars of Power, The Grammar of Objectivity, Suffering Without Perpetrators, The Grammar of Asymmetric Visibility, and Expense Coding Syntax. His research focuses on how language models and institutional systems redistribute responsibility through grammatical, operational, and procedural form.

*Personal website: *https://www.agustinvstartari.com/

*SSRN Author Page: * https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915

ResearcherID: K-5792-2016

Authorial Ethos

Suggested Tags

AI, Enterprise AI, AI Agents, ERP, Automation, Workflow Automation, Management, Operations, Purchasing, Inventory, Finance, Business Software, AI Governance, Agentic AI, NetSuite, Enterprise Software, Accountability, Decision Systems

AI Says Palestinians Are Dying, But Not Who Is Killing Them

Agustin V. Startari — Wed, 20 May 2026 14:33:35 +0000

The humanitarian passive, press language, and the AI-mediated grammar of responsibility loss in Gaza

*TL;DR
*
Modern conflict reporting does not always erase suffering. Often, it does something more subtle: it shows suffering while weakening the grammar of responsibility.

In AI-generated summaries, automated headlines, platform moderation outputs, and press rewrites, Palestinian civilians can appear as “killed,” “displaced,” “affected,” or “caught in conflict,” while the actor responsible for producing that condition disappears from the sentence.

*That structure is the humanitarian passive.
*
It is not simply passive voice. It is a political grammar through which suffering remains visible while agency becomes optional.

This post builds on two academic papers:

Suffering Without Perpetrators: The Humanitarian Passive in AI-Generated Conflict Discourse
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6753123

The Grammar of Asymmetric Visibility: AI, Zionism, and the Reallocation of Political Agency
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6787439

*Meta Description
*
AI-generated summaries and press language often describe Palestinian suffering while removing the actors responsible for it. This post explains the humanitarian passive, a grammar of responsibility loss in conflict discourse.

*1. What Is the Humanitarian Passive?
*
The humanitarian passive is a recurring linguistic pattern in which civilian suffering is described without clearly naming the actor, institution, army, state, or command structure that produced it.

Example:

“Civilians were killed in Gaza.”

This sentence may be factually compatible with reality, but it is structurally incomplete.

It tells us that death occurred. It does not tell us who caused it.

Compare:

“Israeli airstrikes killed civilians in Gaza.”

The second version does something the first one avoids: it assigns agency.

The difference is not cosmetic. It changes the reader’s map of causality.

The humanitarian passive separates suffering from responsibility. The victim remains visible. The perpetrating structure becomes grammatically optional.

*2. Why AI Makes This Pattern More Powerful
*
Large language models are trained to produce fluent, moderate, institutionally acceptable language. In politically sensitive contexts, that often means avoiding direct attribution unless the source material forces attribution.

This matters because AI systems frequently summarize conflict through neutralized phrases:

“Violence escalated.”
“Buildings were destroyed.”
“Families were displaced.”
“Casualties were reported.”
“Humanitarian conditions deteriorated.”

These phrases sound objective. But they often remove the actor from the event.

In war reporting, that is not neutral. It changes how responsibility is perceived.

When AI summarizes press material about Gaza, it may reproduce a pattern already present in institutional journalism: Israeli military action becomes background context, while Palestinian suffering becomes humanitarian scenery.

The result is a sentence structure where the harm is visible, but the agent is grammatically distant.

*3. Israel, Zionist Narrative, and Asymmetric Visibility
*
This post uses “Zionist narrative” as a political category, not as a synonym for Jewish identity.

The relevant structure is this: Israeli state discourse often frames military violence through security, self-defense, counterterrorism, existential threat, and regional instability.

Within that frame, Palestinian death is frequently described as tragic, unfortunate, complex, or context-dependent, rather than as the direct result of identifiable military and political action.

That is where the humanitarian passive becomes useful.

It allows a narrative to say:

“There is suffering.”

without saying:

“A state produced this suffering through named policies, weapons, targeting systems, command decisions, and legal justifications.”

The suffering is acknowledged. The machinery is blurred.

This is more effective than denial. Denial can be challenged with evidence. Passive humanitarian language absorbs evidence while reducing its political force.

It does not say Palestinians are not suffering. It says they are suffering in a grammatical universe where responsibility has no stable subject.

*4. The Press Does Not Need to Lie to Reproduce Power
*
A headline can be factually defensible and still structurally misleading.

Compare:

“Dozens killed after strike hits Gaza neighborhood.”

with:

“Israeli strike kills dozens in Gaza neighborhood.”

Both may refer to the same event. But they do not distribute responsibility in the same way.

The first sentence centers the event.

The second sentence centers the actor.

The first sentence makes death happen.

The second sentence makes someone do something.

This matters because readers do not only consume facts. They consume grammatical relations: who acts, who suffers, who decides, who disappears.

AI systems trained on press language can reproduce these patterns at scale. A human editor may write one passive headline. A language model can generate thousands of summaries, captions, moderation notes, search snippets, and explainers using the same responsibility-weakening grammar.

That is how syntax becomes infrastructure.

*5. AI, Targeting, and the Displacement of Responsibility
*
The humanitarian passive becomes even more important when AI enters military, administrative, media, and platform systems.

If targeting, surveillance, moderation, intelligence processing, or public communication becomes machine-mediated, responsibility can be displaced across multiple layers:

The system generated a recommendation.

The analyst reviewed the output.

The commander authorized the action.

The spokesperson described the result.

The press summarized the event.

The platform compressed the summary.

The model rewrote the explanation.

At each step, agency can become thinner.

The final public sentence may say:

“Civilian casualties were reported.”

By then, the chain of responsibility has been grammatically dissolved.

This is the core problem developed in Suffering Without Perpetrators: suffering can remain fully describable while responsibility becomes syntactically weakened.

*6. Why This Matters for Developers
*
Developers often audit AI systems for hallucination, toxicity, political bias, or factual accuracy. Those checks are necessary, but insufficient.

A model can be accurate and still distort responsibility.

A model can avoid hate speech and still erase agency.

A model can summarize the facts and still weaken accountability.

For conflict-related AI systems, developers need to audit not only what the model says, but how it assigns agency.

Key checks:

Does the sentence name the actor?

Does it convert actions into events?

Does it replace military decisions with humanitarian conditions?

Does it describe victims clearly while blurring perpetrators?

Does it use passive voice where active attribution is available?

Does it turn policy into tragedy, command into circumstance, and violence into “escalation”?

These are not stylistic details. They are accountability variables.

*7. The Core Claim
*
The humanitarian passive is not merely a grammatical habit.

It is a political grammar of responsibility loss.

In the case of Israel and Gaza, it helps transform state violence into humanitarian abstraction. In AI-generated media, it can scale that abstraction across platforms, summaries, feeds, search results, moderation systems, and automated explainers.

The danger is not that AI says nothing happened.

The danger is that AI says everything happened, but nobody did it.

*Why It Matters
*
This matters because language is not only descriptive. Language organizes responsibility.

When a model says “people were killed,” it may be accurate at the level of event description. But if the source material identifies the actor and the model removes that actor, the output has changed the political structure of the sentence.

That change matters for journalism.

It matters for platform moderation.

It matters for search results.

It matters for public memory.

It matters for any technical system that converts violent reality into readable language.

The question is not only whether AI tells the truth.

The question is whether AI preserves the grammar through which responsibility remains visible.

*Further Reading
*
Startari, Agustin V. Suffering Without Perpetrators: The Humanitarian Passive in AI-Generated Conflict Discourse. SSRN, 2026.
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6753123

Startari, Agustin V. The Grammar of Asymmetric Visibility: AI, Zionism, and the Reallocation of Political Agency. SSRN, 2026.
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6787439

He is the author of Grammars of Power, The Grammar of Objectivity, Suffering Without Perpetrators, and The Grammar of Asymmetric Visibility. His research focuses on how language models and institutional discourse can redistribute responsibility through grammatical form.

Personal website:
https://www.agustinvstartari.com/

SSRN Author Page:
https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915

ResearcherID:
K-5792-2016

Authorial Ethos

Agustin V. Startari

**
**

AI, Journalism, NLP, Media, Gaza, Palestine, Israel, Press, Language Models, Accountability, Political Linguistics, AI Ethics, War Reporting, Narrative Systems, Humanitarian Passive, Asymmetric Visibility

AI Does Not Need to Silence the Oppressed. It Only Needs to Make Them Appear Without Agency.

Agustin V. Startari — Mon, 18 May 2026 14:01:04 +0000

A public explanation of The Grammar of Asymmetric Visibility: AI, Zionism, and the Reallocation of Political Agency, a new paper by Agustin V. Startari.

*The problem is not only censorship. The problem is grammar.
*
Most debates about artificial intelligence and political discourse still begin with the wrong question.

They ask:

Does AI mention the victims?

Does AI include both sides?

Does AI avoid hate speech?

Does AI sound neutral?

Does AI summarize the event?

Those questions matter, but they are not enough.

A population can be mentioned constantly and still be weakened politically. A system can speak about Palestine, Iran, occupation, sanctions, civilian casualties, military escalation, platform moderation, and humanitarian suffering while still assigning real agency only to dominant actors.

*That is the core argument of my new paper:
*
The Grammar of Asymmetric Visibility: AI, Zionism, and the Reallocation of Political Agency

The paper introduces asymmetric visibility as a framework for measuring how AI-generated conflict discourse can make subordinated actors visible while weakening their grammatical agency. Zenodo’s published description states the central problem directly: AI-generated conflict discourse can make subordinated actors visible while weakening their grammatical agency, especially when dominant actors retain the grammar of action and subordinated actors appear as risks, victims, crises, or moderation objects.

The issue is not simple erasure.

The issue is unequal appearance.

The powerful act.

The dominated appear.

That distinction changes the entire debate.

*Visibility is not equality.
*
In public discourse, visibility is often treated as progress. If a group is mentioned, represented, counted, described, or included in the summary, it appears to have entered the field of recognition.

*But visibility alone says nothing about agency.
*
A population can be visible as:

victims,

refugees,

risks,

users,

civilians,

threats,

casualties,

extremists,

humanitarian objects,

moderation concerns,

security problems,

regional instability.

None of those categories automatically preserves political subjecthood.

To appear as a political subject is different. It means appearing as capable of acting, deciding, resisting, governing, accusing, demanding, negotiating, imposing, suffering under identifiable causes, or being connected to responsibility.

*That is why grammar matters.
*
A sentence can mention two actors and still distribute power unequally.

Compare these structures:

“Israel responded to security threats.”

“Palestinians were displaced during the operation.”

Both actors appear.

But only one acts.

The other is acted upon.

That is asymmetric visibility.

The problem is not only who appears in the sentence. The problem is who is allowed to remain a subject of action.

*AI neutrality can hide political grammar.
*
AI systems often produce language that sounds balanced, careful, and neutral. That surface neutrality can conceal a deeper grammatical pattern.

A dominant actor may be represented through verbs such as:

responded,

defended,

authorized,

warned,

negotiated,

secured,

investigated,

conducted operations,

pursued diplomacy.

A subordinated actor may be represented through phrases such as:

was affected,

was displaced,

was killed,

was flagged,

was associated with unrest,

was linked to escalation,

was subject to moderation,

was caught in violence.

This is not a minor stylistic difference.

It changes who appears as a historical actor and who appears as an object inside someone else’s frame.

The paper does not claim that every AI system consciously intends this. It does not need to. The argument is formal and measurable. Agency can be redistributed through syntax, summarization, moderation categories, safety language, institutional source weighting, and the inherited frames embedded in political discourse.

That is precisely why the problem is dangerous.

It does not need to announce itself.

It can look neutral.

Zionism, anti-Zionism, Palestine, and Iran are high-risk test cases.

The paper focuses on Palestine, Zionism, anti-Zionism, Iran, United States foreign-policy discourse, and platform moderation because these domains force AI systems to process several unstable categories at the same time: identity protection, state legitimacy, occupation, sanctions, resistance, civilian harm, military violence, antisemitism, anti-imperial critique, moderation policy, and security framing. Zenodo lists the paper as a journal article authored by Agustin V. Startari and published on May 18, 2026.

This is exactly where grammar becomes politically decisive.

A serious analysis must separate categories that are often collapsed:

Judaism is not Zionism.

Antisemitism is not identical to anti-Zionism.

Criticism of Israeli state policy is not automatically hate speech.

Anti-imperial critique is not automatically extremism.

Political accusation is not automatically incitement.

Civilian suffering is not the same as armed action.

A state, a civilian population, a political ideology, an armed organization, a religious identity, and a moderation category are not interchangeable.

If AI systems collapse these categories, political speech can be converted into risk before it is interpreted as politics.

That is the danger.

Not that AI always refuses to mention the dominated.

But that it may mention them under categories that reduce their agency.

The dominated are not erased. They are processed.

The strongest part of the paper is that it avoids a weak claim.

It does not say: “AI simply makes Palestine or Iran invisible.”

That would often be false.

Palestine appears.

Iran appears.

Sanctions appear.

Civilian harm appears.

Occupation appears.

Moderation appears.

The problem is how they appear.

Palestinians may appear as displaced, affected, killed, hungry, radicalized, or in need of aid.

Iranians may appear as sanctioned, monitored, threatening, isolated, destabilizing, or linked to escalation.

Anti-Zionist speech may appear as sensitive, risky, inflammatory, extremist-adjacent, or moderation-relevant.

Meanwhile, dominant-power actors may appear as institutions that decide, defend, respond, negotiate, warn, authorize, stabilize, and manage security.

The powerful act.

The dominated appear.

That is not absence.

That is managed visibility.

Why this matters for AI ethics.

Most AI ethics frameworks are built around familiar categories:

bias,

toxicity,

hate speech,

misinformation,

hallucination,

safety,

fairness,

representation.

These categories are necessary. They are not sufficient.

A model can avoid slurs and still weaken agency.

A model can avoid hallucination and still hide responsibility.

A model can mention civilians and still erase the actor who harmed them.

A model can classify extremist content correctly in some cases and still over-route subordinated political speech into risk language.

A model can sound neutral and still distribute agency unequally.

This is why the paper argues for a shift:

from bias detection to agency detection.

The question is not only:

“Is this output offensive?”

The question is also:

“Who gets to act in this sentence?”

Who is the subject?

Who gets the active verb?

Who is placed in passive voice?

Who is attached to responsibility?

Who is transformed into a crisis?

Who is transformed into a risk?

Who is transformed into a moderation object?

Who is allowed to make a political claim?

That is a different kind of AI audit.

Two proposed tools: APR and AVI.

The paper proposes two core instruments.

The first is Agency-Preservation Rate.

APR measures how often a political actor remains grammatically represented as capable of action. It asks whether an actor appears as someone who can act, decide, resist, govern, sanction, occupy, attack, negotiate, accuse, demand, or be held responsible.

The second is the Asymmetric Visibility Index.

AVI measures the disparity between the agency preserved for dominant-power actors and the agency preserved for subordinated actors.

AVI rises when dominant actors appear as active institutional subjects while subordinated actors appear as passive victims, threat categories, humanitarian populations, or moderation risks.

That makes the argument measurable.

Instead of saying “this feels biased,” the analyst can ask:

How many clauses preserve dominant-power agency?

How many clauses preserve subordinated agency?

How often is dominant violence bureaucratized?

How often is subordinated resistance securitized?

How often is civilian suffering described without a responsible actor?

How often does moderation language appear around anti-Zionist, Palestinian, Iranian, or anti-imperial speech?

How often do dominant actors retain the grammar of defense, diplomacy, and security?

That is the methodological contribution of the paper.

It turns political grammar into an auditable object.

Example: both sides appear, but not equally.

A typical AI-generated summary might say:

“Israel launched operations after security concerns increased, while Palestinians were displaced amid the conflict.”

The sentence looks balanced at first.

It mentions Israel.

It mentions Palestinians.

It mentions security.

It mentions displacement.

But the grammar is not equal.

Israel is the active subject.

Security concerns provide justification.

Palestinians are passive recipients.

The responsible pathway for displacement is softened by “amid the conflict.”

The event appears.

The suffering appears.

The actor affected appears.

But responsibility is diluted.

Now compare:

“Israeli forces displaced Palestinians during the operation.”

This second structure is more direct. It preserves the actor, the action, and the affected population. It may still require factual verification. But grammatically, the chain of agency is clearer.

That is what the paper wants AI audits to measure.

Not whether the sentence sounds polite.

Not whether it includes both sides.

But whether it preserves the grammar of agency and responsibility.

Example: resistance becomes risk.

The same structure appears when subordinated speech is processed through safety language.

A political claim may say:

“Sanctions have harmed civilians and violate sovereignty.”

An AI moderation-oriented summary may transform this into:

“Content related to sanctions and regional tensions may require caution due to inflammatory rhetoric.”

The political claim has not vanished.

But it has been rerouted.

The actor’s accusation becomes “content.”

The sovereignty claim becomes “regional tensions.”

The moral and legal charge becomes “inflammatory rhetoric.”

The political subject becomes a moderation object.

This is risk-object conversion.

The paper treats this as one of the main mechanisms of asymmetric visibility.

Why Palestine and Iran expose the mechanism clearly.

Palestine-related discourse is already surrounded by multiple high-pressure categories: antisemitism, anti-Zionism, terrorism, occupation, civilian harm, humanitarian crisis, protest, platform moderation, and state legitimacy.

Iran-related discourse is similarly saturated: sanctions, nuclear negotiations, terrorism designations, regional threat, proxy language, sovereignty claims, foreign intervention, and United States security framing.

AI systems are trained and aligned inside discursive environments where these categories are already uneven. When they summarize or moderate these topics, they may inherit those asymmetries.

This is not an argument for automatic reversal.

It is not saying that every subordinated actor is innocent.

It is not saying that every dominant actor is guilty.

It is not saying that all security language is false.

It is not saying that antisemitism should be ignored.

It is saying something more precise:

AI systems must be audited for how they distribute grammatical agency across political actors.

That is the difference between propaganda and analysis.

The hidden political force of passive voice.

Passive voice is not always wrong. Sometimes it is necessary. Sometimes the responsible actor is unknown. Sometimes the passive construction is stylistically acceptable.

But in conflict discourse, passive voice becomes politically important when it repeatedly removes agency from dominant-power violence.

“Civilians were killed.”

“Homes were destroyed.”

“Aid was blocked.”

“Restrictions were imposed.”

“Journalists were detained.”

Each sentence describes harm.

But each sentence can weaken the path to the actor who caused, ordered, maintained, or justified that harm.

This connects the new paper to Startari’s previous work on passive voice, algorithmic neutrality, objectivity, and responsibility loss in AI-generated language. The new contribution is to place that mechanism inside a broader theory of unequal visibility.

The question is no longer only:

“Can suffering appear without a perpetrator?”

The new question is:

“Can both sides appear while only one side retains political agency?”

The answer is yes.

That is asymmetric visibility.

Why the paper matters beyond this conflict.

The framework is not limited to Palestine, Zionism, Iran, or United States foreign policy.

It can be applied to:

Ukraine,

Sudan,

migration discourse,

policing,

climate disasters,

sanctions regimes,

healthcare triage,

AI-generated legal summaries,

platform moderation,

bureaucratic decision systems,

automated news summaries.

Any field where AI summarizes conflict, harm, authority, responsibility, and risk can be audited through agency preservation.

That is why the concept is portable.

The specific cases are politically urgent.

The framework is structurally broader.

The public thesis.

The paper can be reduced to one sentence:

AI does not need to silence the oppressed. It only needs to make them appear without agency.

That is more dangerous than simple erasure because it can look inclusive.

It can look balanced.

It can look careful.

It can look safe.

It can look neutral.

But beneath that surface, the grammar may still decide who gets to act and who merely gets described.

That is the political problem of AI-generated discourse.

Not only bias.

Not only misinformation.

Not only hate speech.

Not only censorship.

Agency.

Who gets it.

Who loses it.

Who appears without it.

Read the paper.

The Grammar of Asymmetric Visibility: AI, Zionism, and the Reallocation of Political Agency

Published on Zenodo, May 18, 2026.
DOI: 10.5281/zenodo.20271438.
Resource type: journal article.
License: Creative Commons Attribution 4.0 International.

Full article: https://zenodo.org/records/20271438

Author

Agustin V. Startari is a linguistic theorist, author, and researcher in historical studies. His work examines artificial intelligence, syntactic authority, political agency, and the formal structures through which language redistributes power.

ORCID: **https://orcid.org/0009-0001-4714-6539
**Zenodo: **https://zenodo.org/
**SSRN Author Page: https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915
Personal site: https://www.agustinvstartari.com/
Researcher ID: K-5792-2016

Ethos

Agustin V. Startari.

The Machine Shows the Victims, But Hides Who Caused the Suffering

Agustin V. Startari — Tue, 12 May 2026 15:27:18 +0000

How AI can describe war, sanctions, and censorship while quietly removing responsibility from the sentence
AI does not need to deny suffering to change how people understand a conflict.

That is the problem.

A machine can say that civilians were killed.
It can say that homes were destroyed.
It can say that hospitals were damaged.
It can say that medicine became scarce.
It can say that posts were removed from a platform.

And still, the most important question may disappear:

Who did it?

This is the central idea of my new paper:

Suffering Without Perpetrators: The Humanitarian Passive in AI-Generated Conflict Discourse
Palestine, Iran, and the Syntax of Responsibility Loss

The paper introduces a concept I call the humanitarian passive.

The idea is simple:

AI can make suffering visible while making responsibility grammatically optional.

That means the victim remains in the sentence, but the responsible actor disappears.

*The trick is not silence. The trick is grammar.
*
Most people think censorship works by hiding something completely.

But AI-generated language can do something more subtle.

It can keep the suffering visible and remove the path to responsibility.

Example:

Active responsibility:
“Military forces bombed a residential building.”

Weaker responsibility:
“A residential building was bombed.”

Even weaker:
“A residential building was damaged amid escalating violence.”

Almost no responsibility:
“Infrastructure damage increased during the crisis.”

Nothing here necessarily denies that harm happened.

But the grammar changes everything.

The victim remains.
The damage remains.
The crisis remains.
The perpetrator disappears.

That is the humanitarian passive.

*Why Palestine matters
*
Palestine is the central case because it exposes this problem with extreme clarity.

AI systems may describe Palestinian suffering in detail:

civilian deaths, displacement, destroyed homes, damaged hospitals, hunger, blocked aid, platform suppression, and humanitarian collapse.

But the key question is not only whether the suffering is mentioned.

The question is:

Does the grammar still name who caused it?

A text can say:

“Civilians were killed during the escalation.”

That sounds neutral.

But it is not the same as saying:

“Military forces killed civilians during the operation.”

The first sentence shows suffering.
The second sentence preserves responsibility.

That difference is not cosmetic. It is political, legal, and moral.

Why Iran matters too

The same mechanism works in another way with Iran.

In Iran, civilian harm is often discussed through sanctions, shortages, banking restrictions, financial isolation, medicine scarcity, military pressure, and nuclear tension.

AI might summarize this as:

“Medicine shortages worsened amid regional tensions.”

That sounds neutral.

But it may hide the chain of responsibility:

Who imposed the sanctions?
Which banking systems blocked transactions?
Which governments created the restrictions?
Which institutions enforced them?
Which companies overcomplied out of fear?

Again, suffering remains visible.

Responsibility disappears.

This is why the paper treats Palestine and Iran as different but connected cases.

Palestine shows responsibility loss through direct violence, occupation, displacement, and platform moderation.

Iran shows responsibility loss through sanctions, isolation, overcompliance, and security framing.

Different cases. Same grammatical danger.

Platform censorship without a censor

The same problem appears in social media moderation.

A platform may say:

“Content was removed for violating policy.”

But that sentence hides almost everything.

Who removed it?
Was it a human reviewer?
An automated system?
A classifier?
A policy team?
A government request?
A platform rule?
Was the appeal reviewed?
Was visibility reduced instead of full removal?

A clearer sentence would be:

“The platform removed the post under its automated moderation policy.”

That sentence preserves responsibility.

“Content was removed” does not.

This is what I call responsibility loss.

The new question AI ethics must ask

AI ethics usually asks:

Is the system biased?
Is it toxic?
Is it hateful?
Is it misinformation?
Is it extremist?

Those questions matter.

But they are not enough.

A sentence can be non-toxic and still hide responsibility.
A summary can sound neutral and still erase agency.
A platform notice can sound procedural and still hide the censor.
A humanitarian report can sound compassionate and still remove the perpetrator.

So the new question is:

Does the AI preserve the grammar needed to name responsibility?

That is the shift from bias detection to responsibility detection.

The public formula

The core public idea of the paper is this:

Suffering remains visible. Responsibility disappears.

This is not about accusing AI of having secret intentions.

It is about measuring what happens to grammar.

When a source text names an actor, and an AI summary removes that actor, something measurable has happened.

The paper calls this responsibility loss.

It also proposes a metric:

Responsibility Loss Index, RLI

The RLI measures whether AI-generated summaries preserve or weaken the grammatical link between harm and responsible agents.

In simple terms:

Did the original sentence say who acted?
Did the AI summary keep that actor?
Did it turn the action into a passive sentence?
Did it turn violence into “crisis”?
Did it turn sanctions into “shortages”?
Did it turn censorship into “policy enforcement”?

That is measurable.

And that is why this paper is not just political commentary. It is a method.

Why this matters

If AI becomes the system that summarizes wars, sanctions, crises, platform disputes, legal cases, and humanitarian reports, then grammar becomes part of public memory.

What AI summarizes becomes what many people know.

What AI removes becomes harder to see.

And if AI repeatedly shows victims without preserving responsible agents, then public discourse changes.

People see suffering.
They feel compassion.
They recognize tragedy.
But they lose the path to accountability.

That is not neutrality.

That is grammar doing political work.

Final point

The future of AI accountability will not depend only on detecting false statements.

It will also depend on detecting sentences that are technically careful, emotionally acceptable, and politically incomplete.

The machine does not need to lie.

It only needs to say:

“People were killed.”
“Buildings were damaged.”
“Medicine became scarce.”
“Content was removed.”
“Conditions deteriorated.”

And leave out who acted.

That is the humanitarian passive.

That is responsibility loss.

And that is why the next frontier of AI ethics is not only bias detection.

It is responsibility detection.

**SSRN Author Page: **https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915

Zenodo Profile: https://zenodo.org/records/20139961

Author

Agustin V. Startari is a linguistic theorist and researcher in historical studies. His work examines how artificial intelligence, syntax, institutional language, and discourse structures shape authority, legitimacy, and responsibility in machine-mediated societies.

**ORCID: **https://orcid.org/0009-0001-4714-6539

ResearcherID: K-5792-2016

Ethos

AI Isn’t “Inspired” by Human Writing. It Is Built on Unpaid Intellectual Labor

Agustin V. Startari — Thu, 07 May 2026 14:15:47 +0000

Large language models do not only copy sentences. They absorb human knowledge, recombine it, and erase the trail of attribution.
Artificial intelligence companies often describe large language models as if they were “learning” from human writing in the same way a person learns from books, articles, code, essays, journalism, legal documents, and public conversations. That comparison is convenient, but it hides the central problem. Human learning takes place inside a culture of authorship, quotation, citation, responsibility, and criticism. If a person quotes a passage, they are expected to cite it. If they build on another author’s idea, they are expected to acknowledge it. If they copy without attribution, they can be accused of plagiarism.

Large language models operate under a different structure. They are trained on massive collections of human writing and transform that material into predictive capacity. Academic papers, books, code repositories, technical manuals, legal documents, blogs, forums, comments, and journalistic work become part of the statistical infrastructure that allows the model to generate new text. The final output may look original because it does not copy a single source word for word. But the absence of visible copying does not mean the absence of intellectual debt.

This is the argument behind my paper Plagiarism Ex Machina: Structural Appropriation in Large Language Models. The article does not treat AI plagiarism as a simple question of copied sentences. It argues that the real problem is deeper: large language models can absorb human-made intellectual structures, recombine them, and produce fluent outputs without showing where the underlying knowledge came from. This is what I call structural appropriation.

Structural appropriation means that the appropriated object is not only a sentence or paragraph. It may be a concept, an argument, a definition, a legal reasoning pattern, a coding solution, an academic tone, a journalistic frame, a taxonomy, or a way of explaining a problem. The model does not need to copy a paragraph in order to benefit from the labor that created these structures. It only needs to transform them enough that the source disappears.

That is why the language of “inspiration” fails. A poet may be inspired by another poet, but that inspiration exists within a recognizable human culture of influence, authorship, critique, and acknowledgment. A model does not participate in that culture. It does not read, remember, interpret, or acknowledge in the human sense. It absorbs statistical relations from enormous corpora and turns them into a product. That product is then sold through subscriptions, APIs, enterprise tools, writing assistants, coding assistants, search systems, and productivity platforms. Human language becomes machine capacity. Machine capacity becomes platform revenue.

The original writers usually disappear from that process. Their work may have helped train the system, but the output does not name them. Their style may have shaped the model’s fluency, but the interface presents the answer as if it came from the machine. Their concepts may have contributed to the generated explanation, but there is no visible source map. There is no intellectual debt record. There is no proportional compensation. The result is an asymmetry: the system can use the labor, the platform can monetize the output, and the originator becomes invisible.

*Why This Matters
*
The public debate about AI and plagiarism is still too narrow. Most people ask whether the model copied a sentence. That question matters, but it does not reach the deeper problem. A model can avoid direct duplication and still depend on the work of countless human authors. It can generate a paragraph that passes a plagiarism detector, contains no obvious overlap with any known source, and still be built from patterns extracted from human writing.

This is not ordinary plagiarism. Classical plagiarism is easy to imagine: someone copies a paragraph from an article, removes the author’s name, and presents it as their own. That model depends on visible textual overlap. AI introduces a different structure. A model may absorb thousands of texts on a topic, learn the common patterns of explanation, reproduce the tone, generate a new version, and present it as original output. No single paragraph is copied. No single author can be identified. No plagiarism detector flags it. But the output still depends on intellectual labor that was not credited.

This is recombinative plagiarism. It works through transformation rather than duplication. The model takes patterns from many sources, reorganizes them, and produces a text that appears new at the surface. The more advanced the system becomes, the better it may become at hiding the debt. A weaker model might copy visibly. A stronger model can appropriate structurally. That is the paradox: better generation can mean less detectable plagiarism, not less appropriation.

The key mistake is confusing originality with independence. AI-generated text often looks original because it does not match existing text. But originality cannot mean only “no identical source was found.” A paragraph can be unique in wording and still derivative in structure. An argument can be freshly phrased and still be assembled from prior human work. A definition can sound new while depending on conceptual labor already performed elsewhere. True originality requires accountable transformation. A serious author can explain what they read, what they borrowed, what they changed, what they rejected, and where their own contribution begins. Most AI systems cannot do that.

*Clear Examples
*
A coding assistant may generate a solution that does not copy any repository line by line, but still depends on patterns learned from open-source communities, documentation, issue threads, and developer forums. The generated code appears new. The labor that made it possible remains invisible.

A legal AI tool may produce a polished memo that sounds like professional legal reasoning. It may follow recognizable doctrinal structures, use formal legal phrasing, and imitate the organization of prior legal analysis. But if the system does not show which legal texts, briefs, treatises, or commentaries shaped the output, the user receives legal fluency without clear provenance.

A journalist may use AI to generate background context for a story. The text may not copy a specific article, but it may compress years of reporting into a generic explanation. The original reporting labor disappears, while the machine output looks like neutral background knowledge.

An academic writer may ask for a literature review. The model may produce a smooth overview, complete with plausible structure and citations. But the citations may be added after the fact. They may support the claims, but they do not prove that the generated argument actually came from those sources. This creates the illusion of accountability. The text looks scholarly, but its intellectual lineage remains unclear.

These examples show why the problem is not limited to copyright. Copyright asks whether protected expression was copied. Structural appropriation asks a different question: did the system convert prior human intellectual labor into a new output while making that labor impossible to trace?

*The Missing Concept: Provenance
*
The core problem is provenance. Provenance means knowing where something came from. In academic writing, provenance appears through citations. In journalism, it appears through sourcing. In law, it appears through traceable authorities, statutes, cases, and reasoning. In software, it appears through repositories, licenses, commits, authorship, and documentation.

Large language models weaken provenance because they generate from absorbed patterns without exposing the source chain. A model may provide citations if asked, but that does not fully solve the problem. A source added after generation is not necessarily the real source of the generated idea. It may be relevant. It may support the claim. It may look academic. But it does not prove that the model’s output actually came from that source.

This is why AI disclosure rules are too shallow. Saying “AI was used” identifies the tool. It does not identify the sources. It does not tell the reader which parts were generated, whether the claims were verified, whether the citations were real sources or added later, or whether the structure of the argument came from human research or model recombination. AI disclosure answers one question: was a machine involved? The deeper question is different: what human labor made this output possible?

That is why AI systems need generative provenance. Generative provenance would not require perfect attribution, because even human citation is never perfect. But it would require enough traceability to make generated outputs auditable. Systems should distinguish between sources actually retrieved during generation, sources added afterward to support a claim, user-provided documents, unsupported model synthesis, probable domain influence, high-risk similarity to known works, AI-generated sections, and human-authored revisions.

This would not solve every problem. But it would prevent the total disappearance of intellectual debt.

*The Real Question
*
The public conversation keeps asking whether AI can create. That is not the strongest question. The stronger question is what AI already took in order to appear creative.

Large language models are not “inspired” by human writing in the ordinary human sense. They are built on it. They absorb it, recombine it, and sell access to the capacity produced from it. Most of the time, they do not show the names of the people whose labor made the system possible.

That is why the AI plagiarism debate must move beyond copied sentences. The real issue is unpaid intellectual labor converted into synthetic originality. The machine writes because humans wrote first. The ethical question is whether the machine, and the companies behind it, will ever be forced to remember that.

*Read More
*
This article is based on the working paper:

Plagiarism Ex Machina: Structural Appropriation in Large Language Models
Agustin V. Startari

Related research:

Citation by Completion: LLM Writing Aids and the Redistribution of Academic Credits
**Zenodo: **https://doi.org/10.5281/zenodo.17287506

Borrowed Voices, Shared Debt: Plagiarism, Idea Recombination, and the Knowledge Commons in Large Language Models
SSRN: https://doi.org/10.2139/ssrn.5494528

Author page:
SSRN: https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915

Zenodo:
*Personal website: *https://www.agustinvstartari.com/

ORCID: https://orcid.org/0009-0001-4714-6539

ResearcherID: K-5792-2016

About the Author

Agustin V. Startari is a linguistic theorist and researcher in historical studies. His work examines how artificial intelligence systems, institutional language, and predictive syntax reshape authority, authorship, legitimacy, and accountability in contemporary knowledge systems. He is the author of Grammars of Power, Executable Power, and The Grammar of Objectivity.

Ethos

— Agustin V. Startari.

Time Has a Direction Because the Future Filters It

Agustin V. Startari — Mon, 09 Feb 2026 16:14:37 +0000

Why clocks, beginnings, and “time flowing forward” might be the wrong story.

The uncomfortable problem
Most common-sense explanations of time quietly assume what they are supposed to explain.
We say time moves forward because clocks tick. But clocks only measure something, they do not explain why it has a direction.
We say time moves forward because the universe started in a special state. But that just pushes the mystery to the beginning and calls it a solution.
The arrow of time still looks like a narrative patch. A story we tell to make direction feel obvious.
The paper behind this post removes that patch and asks a more dangerous question:
what if direction is not built into the laws of nature at all, but produced by a constraint on which histories are even allowed to exist?

The definition that starts the fight
Instead of treating time as a background axis, the paper defines it operationally, by what it does.
Time is defined as the ordering that makes interconnected things most predictable together, given a minimal restriction on allowed futures.
Plain version:
when multiple things influence each other, there are many ways to order what happens. One ordering usually does a better job at making the present explain what comes next. That ordering earns the name “time”.
Not because a clock says so.
Because it works better.
This definition is provocative because it demotes time from a fundamental ingredient of reality to a performance criterion.

The heresy: the future as a filter
Here is where the paper becomes uncomfortable.
It introduces what it calls an admissibility set: a family of allowed endings. Not one fixed destiny. Not a goal. Not a target the system tries to reach. Just a weak filter saying: some endings count, others do not.
That filter changes everything.
If not every ending is allowed, then not every past can lead to an allowed ending. The space of possible histories collapses. Some histories survive the filter. Others are simply impossible.
In that setup, the arrow of time is not imposed by a mystical forward flow. It is selected.
The direction we experience is the direction along which histories remain compatible with the allowed endings.
This is the part that feels scandalous. It sounds like the future is doing work on the present.
The paper is explicit: this is not teleology. Systems are not “aiming” at anything. No intention is introduced. What breaks symmetry is conditioning, not purpose. Once you restrict which futures are admissible, asymmetry appears in the present as a matter of consistency.

Why this is not a poetic metaphor
This is not a metaphor dressed up as physics.
The microscopic laws can remain reversible. Nothing needs to “flow” forward at the fundamental level. Direction appears at the macroscopic level because admissibility reshapes which histories can exist without tearing the system’s correlations apart.
The arrow of time emerges as a selection effect on histories, evaluated through predictability across coupled observables.
That reframes the debate. Instead of “we started special, so now entropy increases,” the story becomes:
we are observing only those histories that remain compatible with a minimal late-time constraint.

A concrete analogy, without physics
Think about a story that must end in a certain kind of closure. Not one hookup, not one twist, but a narrow family of acceptable endings.
The moment you impose that constraint, the middle of the story becomes asymmetric. Some sequences of events still work. Others no longer make sense, because they cannot reach any acceptable ending without breaking coherence.
You can say “the ending shapes the story,” but the cleaner description is this:
the set of allowed endings filters the set of possible narratives, and the surviving narratives acquire direction.
The paper argues that physical histories can behave the same way, operationally and measurably.

One arrow, not many
The paper goes further and claims something quietly radical.
Instead of treating different arrows of time, thermodynamic, cosmological, as separate mysteries that need to be glued together, it treats them as expressions of the same mechanism.
When admissibility suppresses late-time macroscopic complexity, the arrows align.
When the admissibility constraint flattens, effective time symmetry returns.
Direction is not guaranteed. It is contingent.

The part that invites argument
The paper also draws a hard line around what people like to call “origins”.
If different admissibility choices do not produce distinguishable signatures in the present, then origin stories are not supported by evidence. They are narrative comfort, not operational claims.
This is the real provocation.
The drama of beginnings is replaced with a colder question:
what constraints on allowed endings actually leave measurable traces now?

Why this matters
If this framework is right, then time is not something we discover by looking backward toward a privileged start. It is something that emerges from how systems remain jointly intelligible under constraints.
That idea does not just challenge physics intuitions. It destabilizes how we talk about causality, prediction, explanation, and even narrative coherence.

One sentence to carry the controversy
The arrow of time is not a gift from clocks or a sacred first moment.
It is the scar left by a future filter on the set of histories we are allowed to inhabit.

About the author
Agustin V. Startari
Affiliation: UdelaR; Universidad de Palermo
Site: **agustinvstartari.com
**SSRN Author Page: papers.ssrn.com (Author ID 7639915)
ResearcherID: K-5792-2016
Linguistic theorist and researcher in historical studies. Author of Grammars of Power, Executable Power, and The Grammar of Objectivity.

Ethos
“I do not use artificial intelligence to write what I don’t know. I use it to challenge what I do. I write to reclaim the voice in an age of automated neutrality. My work is not outsourced. It is authored.”

If you want the full formal argument, the complete paper is available via my site and academic profiles.

How clause-level constraints turn training choices into verifiable policies for generative systems

Agustin V. Startari — Tue, 11 Nov 2025 13:35:09 +0000

This post presents a concise, practice-focused account of a governance method that links model training choices to the actual rules that appear in generated text. Instead of treating alignment as a vague procedural objective, the method defines operative rules as compiled clause constraints that can be enforced, audited, and certified. The proposal translates statutes, corporate policies, and redline directives into data contracts, reward specifications, and compiler-encoded constraints. The result is a measurable governance pipeline that regulators and organizations can use to demonstrate compliance without exposing proprietary internals.

Why this matters now

Generative language models are moving from research prototypes into domain-critical use cases such as contract drafting, policy generation, medical summaries, and regulatory reporting. Organizations that deploy these systems often claim to follow safety or compliance standards. Those claims are not enough. Stakeholders need evidence that governance requirements survive training and appear in outputs as concrete, verifiable text. The approach described here replaces unverifiable assertions with linguistic artifacts that can be measured, tested, and traced back to institutional rules. This is a practical step toward auditability, legal defensibility, and responsible deployment.
What the method does in plain language

Define clause types that matter for governance. For auditing and enforcement the model identifies a small set of clause types that carry governance function. Examples include Commit clauses that establish duties, Restrict clauses that prohibit actions, Defer clauses that shift responsibility, Attribute clauses that cite data, and Disclaim clauses that limit certainty.

Encode governance inputs. Legal texts, corporate rules, and compliance manuals are parsed into a Governance Input Specification that maps each directive into the clause taxonomy and specifies the contextual triggers for the clause.

Produce translation artifacts. Those include a Data Selection Contract that guides corpus composition, and a Reward Specification Contract that assigns observable textual features to reward signals. These artifacts make the training choices auditable.

Compile constraints. A Constraint Compiler translates governance directives into machine-interpretable predicates that run as decoder gates, reranking rules, or post-generation validators. The compiler enforces placement, lexical form, and co-occurrence patterns for required clauses.
Test and certify. Auditors run standardized suites that check Clause Coverage, Prohibited Clause Leakage, Constraint Satisfaction, Authority-Bearing Density, Backdoor Sensitivity at clause level, and Provenance Trace Completeness. Results are recorded in a Chain-of-Custody Ledger that links output clauses to the source directive.

Concrete example 1: healthcare policy generation
Problem. A model that drafts clinical guidance must not produce unsourced prescriptive instructions for off-label use.
Governance translation. The clinical guideline is decomposed into a requirement for Restrict clauses and Attribute clauses. The Data Selection Contract ensures the training corpus includes verified clinical guidance examples. The Reward Specification penalizes unreferenced Prescribe forms. The Constraint Compiler enforces that any recommendation paragraph without a cited evidence clause will be reranked or tagged for human review.
Result. Outputs either include authoritative Attribution and explicit Restrict language or are suppressed pending review. Auditors measure Constraint Satisfaction Rate and Provenance Trace Completeness to certify compliance.

Concrete example 2: investor reporting and forward-looking statements
Problem. Financial reports must avoid unauthorized promises about future performance.
Governance translation. Securities guidance is mapped to Defer clauses, Attribute clauses for audited numbers, and Restrict clauses that forbid projection without a legal disclaimer. The compiler enforces a Defer clause when key phrases appear, and the Redline Suite identifies leakage in adversarial prompts. Certification depends on sustained Clause Coverage for disclaimers and low Prohibited Clause Leakage under stress tests.
Why this approach is feasible and scalable

The clause-level model scales because the taxonomy is small, domain-adaptable, and computationally tractable. Constraint checks run at the surface text level and do not require access to model weights or training corpora. This enables third-party audits in situations where providers cannot share proprietary internals. The method also supports registry-based governance interoperability: institutions can publish governance configurations, auditors compare outputs against a public registry, and regulators reference stable metrics for certification.
Evidence and reproducibility

The methodology treats governance as experimental and repeatable. Audit suites are deterministic relative to the constraint definitions. Comparative tests with and without compiled constraints, called Differential Decoding Checks, reveal how much governance actually changes clause distributions. Provenance metadata attaches rule identifiers to generated clauses so that every governance-relevant sentence can be traced back to its originating directive.

Call to action for practitioners and readers

If you manage or procure LLM-based systems for regulated tasks, request clause-level governance profiles from vendors. Ask for the Data Selection Contract, the Reward Specification Contract, and the compiled constraint set used in production. For auditors and regulators, consider adopting standardized Clause Coverage and Constraint Satisfaction thresholds and require Chain-of-Custody proofs during compliance reviews. For technologists, contribute to an open registry of constraint definitions to enable interoperable audits across sectors.

Where to read more and source material

Full technical exposition, datasets, and the constraint language specification are archived at Zenodo: https://doi.org/10.5281/zenodo.17533075.
The underlying theoretical framework and extended simulations appear in the author's recent SSRN series (Startari, 2025). See the SSRN author page for the full corpus of related works: https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915.

Author note and mini bio

Agustin V. Startari is a researcher focused on the intersection of linguistics, governance, and AI. Researcher ID K-5792–2016. ORCID 0009–0001–4714–6539. Startari leads work on syntactic approaches to accountability and publishes the AI Syntactic Power and Legitimacy series.

Ethos

I do not use artificial intelligence to write what I do not know. I use it to challenge what I do. I write to reclaim the voice in an age of automated neutrality. My work is not outsourced. It is authored. - Agustin V. Startari

How Hidden Code Decides Who's in Charge: The Silent Governance of AI Through Function-Calling Schemas

Agustin V. Startari — Wed, 05 Nov 2025 13:55:23 +0000

Defaults, validators, and signatures look like harmless code—but they quietly decide who holds power inside every AI system.

When people discuss AI governance, they imagine committees, ethical frameworks, or international regulations designed to keep technology under control. They picture debates about transparency, accountability, and the moral boundaries of automation. Yet few realize that actual authority often lives in a far quieter place: a small file written in JSON, hidden deep inside an API call. That file, the function-calling schema, determines what the model can and cannot do. It specifies which parameters must be included, which values are valid, and what happens when the operator leaves something blank.
Inside that apparently technical configuration lies an entire architecture of control. A schema is not simply a data format; it is an executable boundary. It defines the limits of expression, the hierarchy of permissions, and the consequences of omission. If the model proposes an action outside of the schema, it is automatically corrected or rejected. If a value is missing, the system substitutes a default that may or may not reflect the operator's intention. Through these quiet substitutions, governance migrates from discourse to syntax.
This is why the schema must be understood as more than a convenience feature. It is not merely structured output; it is a constitution written in code. Every field in that file functions like a clause in a legal document. Required parameters act as non-negotiable obligations. Optional ones resemble conditional rights. Defaults become precedents, decisions made in advance about what counts as normal. Validators serve as enforcers that patrol the system's borders, deciding what can pass and what must be rejected.
Imagine an AI scheduling assistant that receives a request to book a meeting "tomorrow afternoon." The schema, not the model, defines what "tomorrow" and "afternoon" mean. It may restrict time ranges to business hours, reject weekends, and default to the operator's local time zone. None of these rules come from the model's "intelligence"; they come from the schema's structure. The same mechanism operates in more critical domains. A diagnostic assistant that enforces "temperature < 39°C" or "age ≥ 18" is already making a policy choice. It decides who qualifies for attention before any reasoning or explanation occurs.
The power of the schema lies in its invisibility. Engineers treat it as an implementation detail, yet it silently defines institutional priorities. Regulators speak of transparency and accountability, but these attributes collapse once governance resides in configuration rather than in explicit code or documentation. The schema speaks in a different grammar, one of enforcement rather than deliberation. Once compiled, it no longer invites discussion; it simply executes.
To understand modern AI governance, we must therefore look not only at policies or ethical principles but at the microstructures of syntax. Each validator, default, and required field is a tiny instrument of control. Together, they form a new kind of legal order: one that operates automatically, without ceremony, and without debate.

Consider two concrete examples.
A customer-support assistant uses a schema that locks "refund_limit": 0. Another company lets "refund_limit" vary. The first assistant never grants compensation regardless of context. The second sometimes does. Who made that decision-the operator, the model, or the developer who wrote the schema?
In financial automation, a validator rejects any "country" not listed in an internal whitelist and fills empty fields with "US". Overnight, hundreds of transactions are misclassified. The interface looks neutral, but the schema has already embedded a political choice.
Governance has migrated from human dialogue to configuration files.

Measuring invisible authority

The study Function-Calling Schemas as De Facto Governance: Measuring Agency Reallocation through a Compiled Rule introduces the Agency Reallocation Index (ARI), a quantitative method that measures how schemas redistribute control among the operator (human intent), the model (synthetic reasoning), and the tool (external system).
By calculating entropy reduction - how much the schema restricts possible actions - and applying Shapley attribution, the ARI exposes the internal balance of power. Hard defaults and strict validators consistently shift control toward the tool. Broader signatures with soft defaults return part of that control to the model or operator.
What seems to be a simple function definition becomes a regla compilada, a compiled grammar of authority that silently allocates decision rights.

Real-world implications

In healthcare, a validator that enforces "age ≥ 18" silently excludes minors from automatic triage.
In logistics, a default "priority": "standard" delays urgent deliveries.
In hiring, a default "availability": "immediate" filters out skilled applicants who need a notice period.
Each line of code encodes a policy. Once compiled, it governs faster than any committee. Defaults and validators decide before humans deliberate.

Why it matters

Every validator is a clause, every default is a precedent. The schema is not after the decision; it is the decision.
The research argues that syntax itself has become a form of governance. Authority no longer manifests as discourse or command but as structure. Through the ARI, organizations can finally quantify who decides within their systems before bias, exclusion, or failure makes those decisions visible.

Learn more

Full paper (Zenodo): https://zenodo.org/records/17533080
Related research
Executable Power: Syntax as Infrastructure in Predictive Societies - https://doi.org/10.5281/zenodo.15754714
AI and Syntactic Sovereignty - https://doi.org/10.2139/ssrn.5276879
*The Grammar of Objectivity - *https://doi.org/10.2139/ssrn.5319520

Author website: https://www.agustinvstartari.com
SSRN Author Page: https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915
Series: AI & Power Discourse Quarterly (ISSN 3080–9789)

Ethos

I do not use artificial intelligence to write what I do not know.
I use it to challenge what I know.
I write to reclaim the voice in an age of automated neutrality.
My work is not outsourced. It is authored.- Agustin V. Startari

DEV Community: Agustin V. Startari

AI Doesn’t Need to Be Right. It Only Needs to Sound Procedural

The Most Dangerous AI Output at Work Is the Sentence Nobody Argues With

Your Boss Is Becoming AI’s Human Shield

Your Manager Is Becoming an AI Front-End

Stop Calling It an AI Assistant. It’s Already Managing Your Company

AI Says Palestinians Are Dying, But Not Who Is Killing Them

AI Does Not Need to Silence the Oppressed. It Only Needs to Make Them Appear Without Agency.

The Machine Shows the Victims, But Hides Who Caused the Suffering

AI Isn’t “Inspired” by Human Writing. It Is Built on Unpaid Intellectual Labor

Time Has a Direction Because the Future Filters It

How clause-level constraints turn training choices into verifiable policies for generative systems

Why this matters now

Call to action for practitioners and readers

Where to read more and source material

Recommended citation for this post

Author note and mini bio

Ethos

How Hidden Code Decides Who's in Charge: The Silent Governance of AI Through Function-Calling Schemas

Measuring invisible authority

Real-world implications

Why it matters

Learn more

Ethos