Analysis and Decision-Making

Lesson updated November 2, 2026. The original examples used Magistral, which was retired on July 31, 2026. They now call Mistral Small 4 (mistral-small-2603) or Mistral Large 4 (mistral-large-4-0) with reasoning_effort="high", and parse the response using the separer function from Lesson 3. Source: Reasoning (Mistral Documentation).

Reasoning to Support Decision-Making

Let’s be honest before diving into techniques: the model won’t make the decision for you, and that’s not the point. What reasoning brings to decision-making is what a good consultant provides—explicitness. Criteria that remained implicit, scenarios you hadn’t walked through, risks no one mentioned: all of this laid out in black and white leaves the final call to you, but far better informed.

Complex decisions require multi-criteria analysis, consideration of different perspectives, and the ability to evaluate trade-offs. These are tasks where structured reasoning delivers considerable value compared to an intuitive response.

Structured Comparative Analysis

Reasoning enables methodical comparisons:

from mistralai.client import Mistral

client = Mistral(api_key="YOUR_API_KEY")

comparison = """My team needs to choose between PostgreSQL and MongoDB for a new application.

Context:
- B2B SaaS project management application
- 500 initial users, target of 10,000 in 2 years
- Structured data (users, projects, tasks) + free-text comments
- Team of 4 developers, all experienced in SQL
- Limited server budget (startup)

Analyze both options and recommend the best one."""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": """Senior technical consultant.

ANALYSIS METHOD:
1. Identify relevant decision criteria
2. Evaluate each option against each criterion
3. Weight criteria based on context
4. Identify risks for each option
5. Formulate an argued recommendation

REFLECTION:
Explore trade-offs. Consider short-term and long-term implications.

RESPONSE:
Clear recommendation with justification, risk mitigation plan."""},
        {"role": "user", "content": comparison}
    ],
)

Scenario Analysis

Reasoning is particularly effective for exploring the consequences of different choices:

scenario = """Our startup (15 employees, $2M ARR) received two offers:
1. Series A funding round of $5M from a VC with 25% dilution
2. Acquisition offer of $12M by a large group (3-year earn-out)

Analyze both scenarios and their implications."""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": """Strategic analyst.
For each scenario, evaluate:
- Financial impact at 1 year, 3 years, 5 years
- Impact on decision-making autonomy
- Risks and probability of realization
- Impact on team and culture"""},
        {"role": "user", "content": scenario}
    ],
)

Pattern: Automated Decision Matrix

You can automate the construction of decision matrices:

def decision_matrix(client, options, criteria, context):
    """Generates a structured decision matrix."""

    options_text = "\n".join(f"- {opt}" for opt in options)
    criteria_text = "\n".join(f"- {crit}" for crit in criteria)

    prompt = f"""Context: {context}

Options to evaluate:
{options_text}

Evaluation criteria:
{criteria_text}

For each option, rate each criterion on a scale of 1 to 5.
Justify each rating.
Calculate the total weighted score.
Recommend the optimal option."""

    response = client.chat.complete(
        model="mistral-small-2603",
        reasoning_effort="high",
        messages=[
            {"role": "system", "content": "Decision analysis expert. Be objective and rigorous in your evaluations."},
            {"role": "user", "content": prompt}
        ],
    )

    return separer(response.choices[0].message.content)[1]  # the response, without the reasoning

# Example: framework selection
result = decision_matrix(
    client,
    options=["React + Next.js", "Vue + Nuxt", "Svelte + SvelteKit"],
    criteria=[
        "Learning curve",
        "Ecosystem and community",
        "Performance",
        "Developer recruitment",
        "Long-term maintainability"
    ],
    context="Redesign of a B2C e-commerce site, team of 3 junior devs"
)

Risk Analysis

Structured reasoning is ideal for identifying and evaluating risks:

risk_analysis = """We plan to migrate our production database
(50 GB, 200 tables, 15 connected applications) from MySQL 5.7 to PostgreSQL 16.

Identify all risks associated with this migration and propose a mitigation plan."""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": """Senior DBA and system architect.

RISK ANALYSIS:
For each identified risk, specify:
- Probability (low/medium/high)
- Impact (low/medium/critical)
- Mitigation plan
- Rollback plan"""},
        {"role": "user", "content": risk_analysis}
    ],
)

Evaluating Trade-offs

Technical decisions often involve trade-offs. Reasoning helps make them explicit:

tradeoff = """Microservices vs. monolithic architecture for our application:

Our situation:
- Team of 6 developers
- HR management application
- 3 modules: recruitment, payroll, leave management
- Deployment on Kubernetes
- Need for independent module updates

Analyze the trade-offs of each approach."""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[{"role": "user", "content": tradeoff}]
)

Pattern: Devil’s Advocate

This is the most valuable pattern in this lesson because it corrects a bias everyone shares: once a decision is made, we only look for confirmation. Explicitly asking the model to attack the decision—finding weaknesses, failure scenarios, fragile assumptions—forces you to hear what no colleague dares say and what you no longer tell yourself:

def challenge_decision(client, decision, context):
    """Plays devil's advocate on a decision."""

    prompt = f"""A team has made the following decision:
DECISION: {decision}

CONTEXT: {context}

Play devil's advocate:
1. Identify the 5 main arguments AGAINST this decision
2. For each argument, assess its severity (1-5)
3. Propose conditions under which this decision would be catastrophic
4. Suggest necessary safeguard measures
5. Conclude: Is the decision solid despite the counter-arguments?"""

    return client.chat.complete(
        model="mistral-small-2603",
        reasoning_effort="high",
        messages=[
            {"role": "system", "content": "Critical analyst. Be incisive but constructive."},
            {"role": "user", "content": prompt}
        ],
    )

Small 4 or Large 4 for Analysis?

The right reflex is to align the model with the criticality and reversibility of the decision. For a simple comparison between two options with clear criteria, a quick evaluation, or a decision you can correct next week: Mistral Small 4 in high mode works very well at a lower cost. However, as soon as the analysis becomes multi-criteria with debatable weightings, the decision is strategic and hard to reverse—an architecture choice, a production migration, a financial arbitration—or the scenario involves real uncertainty, test Mistral Large 4 in high mode. A more capable model has a better chance of making a difference in exploring trade-offs and unfavorable cases, but only a comparison on your own cases will tell you if the extra cost is justified.

Key Takeaways

• Reasoning transforms decision analysis into a structured and reproducible process
• Use a system prompt that enforces an analysis method (criteria, weighting, risks)
• Decision matrices and scenario analysis benefit enormously from reasoning
• The devil’s advocate pattern leverages reasoning to challenge your decisions
• Match the model to the criticality of the decision: Small 4 for daily tasks, test Large 4 for strategic ones