Fable 5 vs GPT-5.6 Sol on NP-Hard: Does /goal Actually Help?

The Setup: Two Models, One Brutal Optimization Problem

Charles Azam ran a clean, side-by-side experiment pitting Fable 5 against GPT-5.6 Sol on a classic NP-hard problem: the Traveling Salesman Problem (TSP). The twist? Fable 5 ships with a /goal command—a structured prompting primitive designed to keep the model laser-focused on a single optimization target. The hypothesis was straightforward: if you explicitly tell an LLM to minimize total route distance and nothing else, it should outperform a model that just gets a natural-language prompt.

Spoiler: it didn't.

Both models were given 20 cities with Euclidean distances. The task was pure TSP—find the shortest Hamiltonian cycle visiting every city exactly once and returning to the start. No constraints, no time windows, no capacity limits. Just raw combinatorial optimization. The /goal variant told Fable 5: "Minimize total distance traveled. This is your only objective." GPT-5.6 Sol got the same problem description without the structured goal primitive.

This matters for engineers and Forward Deployed Engineers (FDEs) because we're increasingly asked whether LLMs can replace or augment traditional solvers for routing, scheduling, and resource allocation problems. The /goal command is marketed as a way to make models "try harder" on well-defined objectives. Let's see what actually happened.

What Actually Happened: Raw Results

Charles ran multiple trials and measured total route distances. Here's the breakdown:

Three things jump out immediately:

1. Neither LLM found the optimal solution. This isn't surprising—TSP is NP-hard, and LLMs are autoregressive token predictors, not combinatorial search engines.
2. The /goal command made Fable 5 worse, not better. The gap widened from 8.6% to 9.3%.
3. GPT-5.6 Sol outperformed both Fable 5 variants by a meaningful margin, landing within 3.7% of optimal without any special goal-oriented prompting.

Charles also measured route validity—whether the model returned a proper Hamiltonian cycle. Fable 5 with /goal produced invalid routes (repeated cities, missing cities) in 2 out of 10 trials. The baseline Fable 5 had 1 invalid route. GPT-5.6 Sol produced valid routes every time.

Why the /goal Command Fell Flat on Its Face

This is where the engineer's intuition should kick in. The /goal command isn't magic—it's a structured prompt that tells the model to optimize for a specific metric. But here's the problem: LLMs don't optimize. They generate.

When you tell an LLM to "minimize total distance," you're not giving it a gradient to follow or a search strategy. You're shaping the distribution of tokens it samples from. The model has learned from its training data that when someone says "minimize X," certain patterns of reasoning tend to follow—trying different orderings, checking for obvious improvements, maybe applying a greedy heuristic. But it has no mechanism for systematic search, no backtracking, no branch-and-bound, no dynamic programming memoization.

The /goal command likely caused Fable 5 to overthink. Instead of generating a clean greedy solution and moving on, it started second-guessing itself, shuffling cities around, and sometimes losing track of which cities it had already visited. The increased cognitive load—if we can anthropomorphize for a moment—led to more errors, not fewer.

Meanwhile, GPT-5.6 Sol's architecture appears to have stronger inductive biases toward structured problem-solving. It produced a solid greedy-with-2-opt-lookahead solution consistently, without the meta-cognitive overhead that /goal introduced.

The Engineer's Take: When AI Meets Computational Complexity

Here's the core insight that every engineer and FDE should internalize: LLMs are not OR solvers, and no amount of prompt engineering will make them one.

NP-hard problems have a fundamental property: verifying a solution is easy, but finding the optimal solution requires searching an exponentially large space. LLMs generate tokens one at a time, left to right, with a fixed compute budget per token. They can't allocate more compute to harder subproblems. They can't branch. They can't backtrack (without explicit chain-of-thought that simulates it, poorly).

This doesn't mean LLMs are useless for optimization problems. It means you need to use them for what they're good at:

• Problem formulation: "Here's my messy business constraint—turn it into a proper MIP formulation."
• Heuristic generation: "Give me a greedy construction heuristic for this variant of VRP."
• Solver orchestration: "Call OR-Tools with these parameters, parse the output, and explain the solution."
• Infeasibility explanation: "Why is this schedule infeasible? Walk me through the binding constraints."

What you shouldn't do is ask an LLM to be the solver. That's like asking a documentation generator to run your CI/CD pipeline. Wrong tool, wrong abstraction.

This connects directly to the AI Suppresses Critical Thinking problem we've covered before. When engineers see a model confidently output a route with a distance, they might accept it without verifying optimality. The /goal command makes this worse by creating an illusion of rigor—"I told it to optimize, so it optimized." No, it generated tokens that look like an optimization attempt.

How to Actually Use These Models for Hard Problems Today

If you're an FDE or engineer building AI tooling that touches optimization, here's the practical playbook:

1. Use LLMs as the Interface Layer, Not the Solver

User: "I need to route 50 technicians to 200 service appointments across 3 cities, minimizing drive time, respecting skill requirements and time windows."

LLM: [Parses constraints, generates OR-Tools model in Python, calls solver, returns schedule with visualization]

This is the pattern that actually works. The LLM translates natural language to structured optimization models. The solver does the heavy lifting. The LLM explains results. If you're building something like this, check out our guide on Build a Codebase Q&A Tool That Indexes a Repo with LlamaIndex and Cloudflare Workers for patterns on connecting LLMs to deterministic tools.

2. Benchmark Against a Ground-Truth Solver

Whenever you're evaluating an LLM on an optimization task, you need an exact solver (or a provably near-optimal heuristic) as your baseline. Without it, you're just comparing vibes. For TSP, use OR-Tools, Concorde, or even a brute-force for n ≤ 12. For scheduling, use CP-SAT. For routing, use VROOM or jsprit.

3. The /goal Command Has One Legitimate Use Case

It's not useless—it's just misapplied to combinatorial optimization. Where /goal shines is in generative tasks with fuzzy objectives:

• "Write a cold email that maximizes reply rate"
• "Summarize this document to minimize hallucination"
• "Generate code that minimizes cyclomatic complexity"

These are tasks where the objective function is learned from human preferences in the training data, not computed algorithmically. The /goal command biases the model toward outputs that humans have historically rated as "good" on that dimension. That's useful. It's just not optimization in the mathematical sense.

4. Try It Yourself (Responsibly)

If you have access to Fable 5 or a similar model with structured goal primitives, run your own benchmarks. Take a problem where you know the optimal solution. Try with and without /goal. Measure both solution quality and validity. Share your results. The field needs more empirical rigor and fewer benchmarks on toy problems that don't stress the models.

For a deeper dive into building AI systems that combine LLMs with deterministic tools, our Multi-Agent Research Assistant with Groq, Serper, and Llama 3.3 walkthrough shows the orchestration pattern in action.

A Balanced Verdict: Hype vs. Reality

Let's be fair to both sides.

What the /goal command represents is genuinely interesting. It's an attempt to give LLMs something they fundamentally lack: the ability to optimize toward a well-defined objective. Current LLMs are trained to maximize likelihood, not to minimize arbitrary loss functions. Structured goal primitives are a step toward bridging that gap, and future architectures might incorporate actual optimization loops (tree search, Monte Carlo rollouts, iterative refinement with verifier feedback).

But today, it doesn't work for NP-hard problems. The experiment is clear: Fable 5 with /goal performed worse than Fable 5 without it, and both were outperformed by GPT-5.6 Sol with a plain prompt. If you're an FDE building a routing optimization demo for a logistics prospect, do not reach for the /goal command. Reach for OR-Tools with an LLM wrapper.

The broader lesson: when vendors ship features like /goal, /optimize, or /try-harder, treat them as hypotheses, not capabilities. Test them on problems where you know the ground truth. If they don't improve outcomes, they're just syntactic sugar—and sometimes they're actively harmful.

This is exactly the kind of critical evaluation we emphasize in The FDE Interview Loop: What to Expect and How to Prepare in 2025. The best FDEs don't just demo features—they understand where the technology breaks and can articulate the boundary to technical stakeholders.

FAQ

Q: Does this mean LLMs are useless for optimization problems?

No. LLMs excel at problem formulation, constraint extraction, solver code generation, and results interpretation. They're the UX layer for optimization, not the engine. Use them accordingly.

Q: Why did the /goal command make Fable 5 worse?

The leading hypothesis is that it induced overthinking—the model tried to iteratively improve its solution but lacked the architectural support for systematic search, leading to more errors and no quality improvement.

Q: Should I use GPT-5.6 Sol for my routing problems?

Only if you're within 3-5% of optimal being acceptable and you have validation in place. For production routing, use a proper solver. For quick prototypes or demos where approximate is fine, an LLM might be acceptable—but always validate.

Q: How do I test whether a goal-oriented prompt actually helps?

Pick a problem with a known optimal solution. Run N trials with and without the goal primitive. Measure mean solution quality, variance, and validity rate. Run a statistical test (even a simple t-test) to see if the difference is significant. If you can't measure it, you can't improve it.

Q: What's the right architecture for AI + optimization?

An LLM that translates natural language to a structured optimization model (MIP, CP, SAT), calls a dedicated solver via function calling or code execution, and then translates the solver's output back to natural language with explanations. The LLM never touches the search itself.

Q: Where can I learn more about building these hybrid systems?

Our guide on Build a Personalized Newsletter Agent That Curates RSS Feeds with Groq and Supabase walks through the pattern of using LLMs for intent understanding and deterministic tools for execution—the same architecture that works for optimization problems.