Agentic AI , AI Strategy , Data science & AI Sep 15, 2026

What Happens When an LLM Solves a Problem Humans Couldn't Crack for Centuries: Lessons for Enterprise AI Task Design

VECTOR Labs Team

Last updated on: Sep 15, 2026

In September 2025, Claude Fable 5.1 decoded the Voynich manuscript's cipher notation system, a problem that had resisted serious cryptographic effort since the manuscript's rediscovery in 1912. The decoding was not a fluke of brute-force pattern matching. It was the product of a carefully constructed task: sufficient historical context, explicit reasoning constraints, a structured output format, and enough token budget to sustain multi-step inference across a genuinely complex problem space. For engineering leaders who have watched frontier model deployments underperform against expectations, that framing detail is the part worth examining closely.

Why the Cipher Case Is a Useful Diagnostic

Most enterprise AI failures are not model failures. The underlying capability is present. What is missing is the scaffolding that allows the model to apply that capability to a specific, bounded problem.

The Voynich case is useful precisely because it is debuggable. The inputs are known, the task is well-defined in hindsight, and the success condition is unambiguous. That makes it a cleaner analytical frame than most enterprise deployments, where ambiguous outputs are blamed on the model rather than on the task design that preceded it.

The parallel to enterprise deployments is direct. When a model is handed a complex analytical task with minimal context, a vague objective, and no structured output requirement, it produces the AI equivalent of a junior analyst working from an incomplete brief: plausible-sounding output that does not actually solve the problem.

Task Framing: What the Cipher Prompt Got Right

The first structural lesson from the cipher case is that task framing is not preamble. It is load-bearing.

Effective framing for a high-complexity task specifies what the model is being asked to produce, what constraints apply to the reasoning process, and what prior attempts have failed and why. In the cipher case, that meant supplying linguistic hypotheses that had been ruled out, the manuscript's known provenance, and the specific structural features that prior analysts had identified but could not explain. This is not prompt engineering in the superficial sense. It is context sufficiency.

In enterprise deployments, the equivalent failure mode is handing a model a data file and a question without specifying the decision that depends on the answer, the constraints the answer must satisfy, or the known failure modes of previous approaches. The model fills that gap with assumptions, and those assumptions are rarely the ones the business would have chosen.

Token Budget as a Structural Variable

The second lesson concerns token budget, which most teams treat as a cost variable rather than a task-design variable. That is the wrong frame.

Complex, multi-step reasoning tasks require sustained inference chains. If the token budget is too constrained, the model is forced to compress or skip intermediate reasoning steps, which degrades the quality of the final output in ways that are difficult to diagnose because the surface-level response still looks coherent. The cipher decoding required the model to hold multiple competing hypotheses in parallel, evaluate them against structural evidence, and progressively eliminate candidates. That process has a minimum viable length.

The practical implication for enterprise teams is that token budget decisions should be made at the task-design stage, not at the infrastructure cost-optimisation stage. For high-value analytical tasks, the cost of a constrained token budget is a worse output, not a cheaper one.

Context Sufficiency and the Retrieval Problem

A recurring issue in enterprise deployments is that the model receives a task but not the context that would make the task tractable. This is partly a retrieval architecture problem and partly a task-design problem.

Retrieval Architecture

Retrieval-augmented generation pipelines are often configured to return semantically similar chunks without regard for whether those chunks are actually sufficient to support the reasoning the task requires. Similarity is not the same as relevance to a specific inferential step. A chunk that scores well on embedding distance may still be missing the specific constraint or prior finding that the model needs to make progress.

Task-Design Accountability

The more tractable problem is on the task-design side. Before a complex task is handed to a model, someone on the team should be able to answer: what does the model need to know that it does not already know, and is that information present in the prompt or retrievable context? If that question cannot be answered, the task is not ready to be assigned.

How Enterprise Teams Should Audit Their Own Prompting

The cipher case suggests a practical audit framework for high-complexity task assignments. It is not a checklist in the superficial sense. It is a set of questions that expose structural gaps before they become output failures.

The first question is whether the task objective is specified in terms of a decision or action, not just a topic. A model asked to "analyse customer churn" has no success condition. A model asked to "identify the three operational variables most predictive of churn in the 30-day window before cancellation, given the following constraints" has one.

The second question is whether known failure modes are included in the prompt. If previous analyses of the same problem reached incorrect or incomplete conclusions, those conclusions should be in the context so the model can reason around them rather than reproduce them.

The third question is whether the output format is specified with enough precision to make the response evaluable. Vague output requirements produce vague outputs, and vague outputs are difficult to evaluate systematically, which means quality problems compound over time.

Where Vector Labs Fits

We design and build production AI systems where task structure, context sufficiency, and output reliability are engineering constraints, not afterthoughts. In our reasoning-failure analysis, we examine the structural conditions under which frontier models produce unreliable outputs and what changes at the task-design level to correct them. If you are auditing your current model deployments for these failure modes, contact us at vector-labs.ai/contacts.

Companion piece to our broader work on LLM reasoning reliability. See LLM Reasoning Failures: Structural Limits & Enterprise for a technical analysis of where frontier model reasoning breaks down at the representational level and what that means for production deployments.

FAQs

We are already using a frontier model. Why are our outputs still inconsistent?

Inconsistency at the output level almost always traces back to inconsistency at the input level. If the task framing, context, and output format vary across runs or across team members constructing prompts, the model has no stable basis for producing stable outputs. The fix is upstream of the model: standardise task structure before optimising model parameters.

How do we know when a task is complex enough to warrant an extended token budget?

A useful heuristic is to ask how many distinct inferential steps a competent human analyst would need to complete the task. If the answer is more than three or four non-trivial steps, the task likely requires sustained reasoning chains that a constrained token budget will compress. For high-value analytical tasks, the cost of under-budgeting is a degraded output, not a faster one.

Our retrieval pipeline returns relevant chunks but the model still misses key constraints. What is going wrong?

Semantic similarity and inferential relevance are not the same thing. A chunk can score well on embedding distance while still missing the specific constraint or prior finding the model needs for a particular reasoning step. Retrieval pipelines need to be evaluated against task-specific relevance criteria, not just similarity scores. In practice, this often means restructuring how documents are chunked and indexed, not just tuning the retrieval threshold.

Is task-design improvement a one-time exercise or an ongoing process?

It is ongoing, for two reasons. First, the tasks your teams assign to models evolve as use cases mature. Second, frontier models themselves change across versions, and a task structure that was well-calibrated for one model version may need adjustment for the next. Building a lightweight review process into your deployment lifecycle is more reliable than treating task design as a solved problem after initial setup.

How should we evaluate whether a task-design change has actually improved output quality?

Define the success condition for the task before you run it, not after. This means specifying what a correct or useful output looks like in terms that can be evaluated independently of the model's confidence. Where possible, test task-design changes against a set of historical cases where the correct answer is known. Output quality improvements that cannot be measured against a defined success condition are difficult to distinguish from changes in output style.

A team that understands you

With 20+ years of experience in the world's leading consultancy companies, implementing AI and ML projects in industry-specific contexts, we are ready to hear your challenges.

Talk with an AI expert