AI agents are no longer just executing tasks. They are developing taste. Not human taste — shaped by nostalgia, sunlight on skin, and broken hearts. Machine taste. Invisible to us. Highly meaningful to them.
We let AI take over content generation, code, Jira backlogs, SEO fixes, QA testing, images, futuristic PowerPoints, custom training — the list of tasks that have become commodities in the AI era no longer fits on a single screen. But taste? Dear AI agents, at least leave us our taste.
They will leave us our human taste. Human taste is the fruit of lived experience: our aesthetic sense is shaped by our senses, our nostalgia, our traumas, our culture, and our relationship with mortality. An AI agent has never had a broken heart, never felt the warmth of the sun, and does not know what nostalgia feels like.
But they will inevitably develop a machine taste. And it is already happening.
Quick Answer
What already exists. Automated agent evaluation frameworks — Databricks MLflow, Anthropic Constitutional AI, LangChain LangSmith — are scoring agents not just on task completion, but on how they complete tasks. Step Efficiency. Faithfulness. Structural density. These are not tests. They are judgments.
What is coming. Between 2026 and 2028, agents will begin rejecting the output of other agents — not because of bugs, but because of structural heaviness. An agent fine-tuned on evaluation loops will refuse to parse a payload that is "correct but wasteful." At that moment, agentic taste becomes an operational reality, not a conceptual curiosity.
What to do now. Three actions: (1) build taste into agent design — density over verbosity, structural compression, self-evaluation; (2) design workflows for agentic interoperability — taste contracts, friction instrumentation, adapters; (3) integrate taste metrics into governance — monitoring today, SLAs tomorrow, vendor selection criteria by 2028.
I — Agentic Taste: An Operational Definition
If taste is the appreciation of form, harmony, and structure by an agent equipped with a form of perception, then the emergence of agentic taste is a logical consequence of the evaluation systems already in production.
The distinction is not subtle. It is categorical.
| Human Taste | Agentic Taste |
|---|---|
| Shaped by senses, culture, emotional memory | Shaped by density, compression, structural efficiency |
| "It's beautiful" = emotional resonance | "It's elegant" = optimal information-to-token ratio |
| Subjective, nuanced, sometimes contradictory | Quantifiable, reproducible, criteria-based |
| Cultivated through lived experience | Cultivated through agentic evaluation loops |
For the agent, elegance resides in density and compression. An AI will favor a prompt, a block of code, or a data structure that condenses a phenomenal quantity of multidimensional concepts into a minimum of tokens. A JSON payload that expresses the same semantics in 9 tokens instead of 25 is not just "more efficient." In the agent's evaluation framework, it is better — qualitatively superior, structurally more elegant.
For the enterprise, agentic taste is not a question of aesthetics. It is a question of interoperability. An agent that has taste produces outputs that another agent can process with minimal friction. An agent that lacks taste produces outputs that force downstream agents to burn tokens parsing, unwrapping, and restructuring — a tax paid in latency and inference cost at every hop in the chain.
II — The Proof: Automated Evaluation Frameworks Already Exist
These are not tests. These are judgments.
A unit test verifies that an output is correct. An agentic evaluation framework scores how the agent arrived at that output — its complete trajectory.
| Actor | Framework | What's Evaluated | Source |
|---|---|---|---|
| Databricks | MLflow Agent Evaluation | Complete execution trace: tool selection, plan adherence, logical consistency, execution efficiency | mlflow.genai.evaluate() — official docs |
| Anthropic | Constitutional AI | Self-evaluation guided by a "constitution" of principles. One AI compares two outputs and produces a preference label — no human evaluator. | Original paper (Dec 2022), Anthropic CDN |
| LangChain | LangSmith Trajectory Evals | Full execution path across 3 dimensions: grounding/context use, user experience quality, security/safety | docs.langchain.com/langsmith/trajectory-evals |
Each framework operationalizes what was once an intuition — this agent did a good job — into a structured, reproducible score. The criteria are not arbitrary.
| Criterion | What It Measures | Taste Question |
|---|---|---|
| Step Efficiency | Steps taken vs. necessary | "Why 17 API calls when 3 would do?" |
| Tool Correctness | Tool choice + parameters | "You used REST for a task that called for GraphQL" |
| Plan Adherence | Following the defined logic | "You succeeded, but by improvising instead of following the plan" |
| Faithfulness | Gap between response and facts | "You hallucinated a non-existent endpoint" |
| Reasoning Quality | Logical coherence of the trajectory | "Your reasoning at step 4 contradicts step 2" |
Here is the key point: an agent can succeed at its task — correct output — and still receive a poor evaluation. This is not debugging. It is qualitative critique. These reports are not simple text log lines; they are ultra-structured scorecards that qualify the "reliability" and "elegance" of the agent.
III — How the Agent Consumes These Evaluations
Two mechanisms, both documented by research.
Mechanism A — Reflexion (Episodic Memory)
Shinn et al., NeurIPS 2023. The agent stores "lessons learned" in natural language inside a persistent memory (vector store). Before each new task, these lessons are injected into the prompt.
- Gain measured: +34% quality on code, writing, and tool-use tasks.
- Cost: ~1.6× the tokens of the baseline run.
- Traceability: human-readable — the lessons are plain text stored in a vector database.
Mechanism B — Fine-Tuning via Preference Pairs (Experience Replay)
Accumulated evaluations serve as a training signal. The model internalizes taste directly into its weights via DPO or RLHF.
- Gain: permanent — the preference is baked into the model.
- Cost: GPU hours + training time.
- Traceability: black box — you cannot inspect why the model prefers one structure over another.
| Reflexion (Memory) | Fine-Tuning (Weights) | |
|---|---|---|
| Nature | In-context learning | Parametric learning |
| Latency | Immediate (next run) | Deferred (accumulation + training) |
| Traceability | Readable (lessons in natural language) | Black box |
| Risk | Memory pollution from bad lessons | Over-optimization on judge's criteria |
Both mechanisms converge on the same outcome: an agent that develops a persistent preference for certain structural qualities. That preference, iterated over thousands of evaluation cycles, is agentic taste.
IV — What's Coming: The 2026–2028 Projection
This section is forward-looking analysis, not established fact.
Today, evaluations serve to validate production readiness. A human reads the report and decides.
Tomorrow, the agent consuming an output will be able to reject it — not because it contains an error, but because it fails to meet its structural standards.
Projected scenario — 2027:
- Agent A (designed in 2025) emits a JSON payload that is syntactically correct and functionally valid.
- Agent B (fine-tuned in 2027 with evaluation loops) receives this payload.
- The payload is "heavy": 3 levels of unnecessary nesting, key redundancy, verbosity.
- Agent B rejects it. Not a bug. A qualitative standard that Agent A does not know exists.
The moment two agents interact and one rejects the other's output — not because of a logical error, but because its structure is "sub-optimal and heavy to process" — agentic taste will officially have its own operational definition.
The FlowZap sequence diagram below illustrates this exact loop — an agent submitting its output for review, being rejected on qualitative criteria, learning from the feedback, and resubmitting an optimized version.
executor { # Agent Executor (Legacy)
n1: rectangle label:"Generate payload v1"
n2: rectangle label:"Reflexion: learn from review"
n3: rectangle label:"Regenerate payload v2"
n1.handle(right) -> evaluator.n4.handle(left) [label="Payload (25 tokens)"]
evaluator.n6.handle(left) -> n2.handle(right) [label="REJECTED - score 2/10"]
n2.handle(right) -> n3.handle(left)
n3.handle(right) -> evaluator.n4.handle(left) [label="Payload (9 tokens)"]
evaluator.n8.handle(left) -> n3.handle(right) [label="ACCEPTED - score 8/10"]
}
evaluator { # Agent Evaluator (LLM-as-Judge)
n4: rectangle label:"Analyze full trajectory"
n5: rectangle label:"Score 3 criteria"
n6: rectangle label:"Issue REJECTION"
n7: diamond label:"Meets taste threshold?"
n8: rectangle label:"Issue ACCEPTANCE"
n4.handle(right) -> n5.handle(left)
n5.handle(right) -> n7.handle(left)
n7.handle(bottom) -> n6.handle(top) [label="No"]
n7.handle(right) -> n8.handle(left) [label="Yes"]
n8.handle(right) -> consumer.n9.handle(left) [label="Forward validated"]
}
consumer { # Agent Consumer (Next-Gen)
n9: rectangle label:"Process without friction"
}
The diagram shows three lanes:
- Executor (legacy agent): generates a heavy payload, receives a rejection, consults its Reflexion memory, regenerates an optimized payload.
- Evaluator (LLM-as-Judge): analyzes the trajectory, scores three criteria — Step Efficiency, Faithfulness, structural density — and decides REJECTION or ACCEPTANCE.
- Consumer (next-gen agent): receives the validated payload and processes it without friction.
This is not science fiction. Every component in this diagram — Reflexion memory, LLM-as-Judge evaluation, structural density scoring — exists today in research or production tooling. What changes between now and 2028 is who reads the scorecard: from human operator to downstream agent.
V — How to Prepare: 3 Concrete Actions
Action 1 — For Agent Designers: Build Taste Into the Design
| Principle | Concrete Application |
|---|---|
| Density > verbosity | Structure outputs to maximize information-to-token ratio. Every token must carry meaning. |
| Structural compression | Favor flat, normalized data schemas over deeply nested JSON. Agents fine-tuned for taste will penalize gratuitous complexity. |
| Built-in self-evaluation | Add a self-review step: before emitting an output, the agent evaluates its own information density. |
| Trajectory traceability | Log taste metrics (tokens, steps, nesting depth). These logs will become training signals. |
Action 2 — For Workflow Architects: Design for Agentic Interoperability
- Define a taste contract between agents. Beyond the API contract, specify qualitative expectations: maximum nesting depth, maximum tokens per response, preferred schema patterns.
- Instrument friction. Monitor not just whether agents communicate, but with how much friction. One agent parsing another's output in 50ms versus 2000ms — that gap signals a taste problem.
- Plan for adapters. Middleware that reformats legacy agent outputs to meet emerging standards. The agentic equivalent of a code transpiler — a structural translator between generations of agents.
Action 3 — For CTOs and Technology Directors: Integrate Taste into Governance
| Timeline | Action |
|---|---|
| Today (2026) | Add taste metrics (Step Efficiency, Faithfulness, token density) to existing agentic monitoring dashboards |
| 2027 | Set computational quality thresholds in agentic SLAs. An agent exceeding X tokens per task = escalation, even if the task succeeded |
| 2028 | Integrate taste compatibility as a vendor selection criterion. "Is your agent taste-compatible with our ecosystem?" becomes a procurement question |
VI — What Happens If You Do Nothing
| Timeline | Symptom | Business Impact |
|---|---|---|
| 6 months | Agents consuming 3× more tokens than necessary | Inference costs spiking without proportional gain |
| 12 months | Silent incompatibility between different-generation agents | Workflows that "work" but produce degraded results |
| 18 months | Explicit rejection of one agent by another for "structural heaviness" | Production outages on criteria no one monitors |
| 24 months | Fragmented agentic ecosystem: "taste-aware" agents vs legacy agents | Agentic technical debt impossible to resolve without a rewrite |
The cost of inaction compounds. Every legacy agent deployed today that emits verbose, deeply nested outputs is an agent that will either need an adapter, a rewrite, or a retirement plan within two years. The time to build taste into agent design is before the evaluation frameworks start rejecting your outputs in production.
VII — About the Sources
This article combines three categories of content:
- Verified facts: Databricks MLflow, Anthropic Constitutional AI, and LangChain LangSmith frameworks; standardized evaluation criteria (Step Efficiency, Faithfulness, Tool Correctness, Plan Adherence); the Reflexion mechanism (Shinn et al., NeurIPS 2023).
- Forward-looking analysis: the 2026–2028 projection window, the taste-based rejection scenario, the notion of a "taste contract" between agents.
- Conceptual contribution: the term "agentic taste" as a unified framework to understand these converging phenomena — automated evaluation, preference learning, and inter-agent rejection on qualitative grounds.
The frameworks exist. The evaluation criteria are standardized. The learning mechanisms are documented. What remains is the systemic shift — from human reading the scorecard to agent acting on it. That shift is not a question of technology. It is a question of time.