Skip to content

Decisions

When the question shifts from "what do we know?" to "what should we do?", you need Euboulia — the decision engine. Describe a constrained allocation problem in plain language, and Euboulia walks you through formulating it mathematically, solving it, and understanding the result. The process is collaborative: you're the author of the decision, not the approver of a recommendation. Every stage presents results and asks for your confirmation before proceeding.

What Euboulia Solves

Euboulia solves constrained allocation problems — decisions where you have limited resources, a set of rules, and a goal:

Given limited resources and a set of rules, what is the best way to assign quantities or make selections to optimize — or simply satisfy — an objective?

Pattern What's being decided Example
How many to make Quantities of outputs Production planning, ingredient blending
Which ones to pick Yes/no selection from a set Project funding, recommendation triage
Who goes where Assignment of resources to tasks Inspector allocation, shift scheduling
How much to mix Proportional blending Ore composition, dietary planning
Is it even possible Feasibility check "Can we meet all constraints simultaneously?"

When a knowledge graph is connected, Euboulia adds one more dimension: the constraint data isn't given — it's pulled from domain knowledge. That's the step from textbook problem to real-world decision.

What Euboulia Doesn't Solve (Yet)

  • Multi-objective trade-offs. Every problem optimizes a single scalar. Balancing cost against safety against fairness requires scalarization or Pareto techniques not wired in yet.
  • Uncertainty. Parameters are deterministic point estimates, not distributions.
  • Dynamic re-optimization. Each decision is a one-shot solve. No rolling horizon or feedback loop.
  • Non-linear effects. LP/MILP only — no economies of scale, diminishing returns, or non-linear risk curves.
  • Arguable constraints. The pipeline assumes the rules are fixed. In reality, "what are the rules?" is often the harder question — Euboulia elicits but doesn't arbitrate.

The Collaborative Process

You describe the problem in natural language. Euboulia structures it mathematically. At every step, you confirm or redirect.

1. Describe the Problem

Start from the Intel Request chat:

"I need to allocate a €500K budget across five projects to maximize expected ROI. Each project requires a minimum spend of €20K and I can't exceed 40% on any single project."

Euboulia creates a Decision Brief and opens it in the workspace. If the problem description is vague, the assistant asks clarifying questions first — it won't guess at what you're trying to optimize.

Trigger phrases

The assistant routes to Euboulia when it detects decision intent: "allocate", "schedule", "assign", "optimize", "maximize/minimize", or "create a decision plan for…"

2. Review the Analysis

Euboulia extracts the parameters (named constants from your description) and presents them for confirmation:

Assistant: "I extracted these parameters: budget = €500K, min_spend = €20K, max_share = 40%. Are they correct and complete?"

  • Parameters look good
  • Missing parameters
  • Some parameters are wrong

You confirm, correct, or add missing parameters through the structured options.

3. Review Constraints and Objective

Next, Euboulia identifies the constraints (rules) and the objective (what to optimize):

Assistant: "I identified 3 constraints and a MAXIMIZE objective. Are these correct?"

  • Constraints and objective are correct
  • Missing constraints
  • Remove a constraint
  • Change the objective

4. Review the Mathematical Formulation

Each constraint and the objective are expressed mathematically. The formulations render as interactive cards — the assistant describes them in plain language:

Assistant: "I've formulated 3 constraints and the objective. Constraint 1 ensures non-negativity. Constraint 2 enforces the minimum spend. Constraint 3 caps the maximum allocation. All have confidence 5/5."

  • Model is correct
  • Revise a formulation
  • Add a constraint

If any formulation has low confidence, the assistant flags it explicitly.

5. Solve

Once you approve the model, Euboulia generates solver code and runs it:

Assistant: "Ready to run the solver with your data?"

  • Yes, run the solver
  • Show me the code first
  • Go back to formulation

6. Understand the Result

The result appears in the Decision Brief with the objective value, variable assignments, and a natural-language explanation:

Assistant: "Optimal allocation found (ROI: €127.5K). Project Gamma gets the maximum 40% due to its 25% expected return. Projects Alpha and Epsilon take the next-largest shares..."

  • Accept this solution
  • Try a different scenario
  • Adjust the model

7. Explore Scenarios

After a successful solve, you can adjust and re-run:

"What if I increase the budget to €750K?" "What if I remove the 40% cap?" "What happens if I add Project Zeta with 30% expected ROI?"

Each scenario re-runs the solver with your new parameters.

Backtracking

You can go back to any previous stage at any time. Changed your mind about a constraint? Go back to formulation. Realized the problem statement was wrong? Start over. Euboulia doesn't force a linear path.

The Decision Brief

The Decision Brief in the workspace shows:

  • Parameters — named constants with their values and sources
  • Variables — what the solver decides (e.g., allocation per project)
  • Constraints — rules with their mathematical formulations
  • Objective — the function being optimized
  • Assumptions — anything Euboulia inferred that wasn't explicit (review these carefully)
  • Solution — variable assignments, objective value, and which constraints are binding
  • Shadow Prices — for each constraint, how much the objective would improve if relaxed by one unit

Result Statuses

Status Meaning What to do
Optimal Best possible solution Review and accept, or explore scenarios
Feasible Valid solution, optimality not guaranteed May improve with more time or tighter gap
Infeasible No solution satisfies all constraints Ask "Why is this infeasible?"
Unbounded Objective improves without limit A constraint is missing
Error Solver code failed Euboulia retries automatically (up to 3 times)

KG-Enhanced Mode

When connected to knowledge graphs, Euboulia enriches the decision with real data:

  • Parameter values retrieved from graph entities (incident counts, damage histories, risk profiles)
  • Constraints derived from graph relationships added automatically
  • KG Context section shows which connectors were queried

Graph-derived values can always be overridden in chat.

Decision History

Every decision is persisted — both in SQLite and as a FalkorDB provenance graph. From the workbench, the Decisions panel lists all past decisions with their status and objective value. Clicking a past decision restores the full brief: parameters, constraints, result, and interpretation. You can revisit and re-run with different scenarios at any time.

Practical Tips

  • Describe the problem naturally. No mathematical notation needed — Euboulia translates.
  • Review assumptions. Each shows an impact statement. Wrong assumptions → wrong solutions.
  • Explore scenarios. The first solution is rarely the last.
  • Use shadow prices. They tell you which constraints are most valuable to relax.

Under the Hood

The pipeline stages

A decision flows through 8 stages, each a tool on the decision MCP server:

Stage What happens
KG enrichment (optional) Pulls relevant entities from connected graphs
Analyze Parses description, extracts parameters
Extract Identifies objective and constraint descriptions
Formulate LaTeX per clause, registers variables, validates
Code Infers variable types, classifies problem (LP/MILP/BIP/SATISFY), generates CVXPY code
Solve Runs assembled script in sandboxed subprocess
Verify Checks constraint primal violations and variable type compliance
Sensitivity Extracts shadow prices
Interpret Generates the natural-language Decision Brief

PROV-O provenance at each boundary: Decision → Execution → Verification nodes in FalkorDB.

Problem types
Type Variables Use case
LP (Linear Programming) Continuous (any real number) Blending, continuous allocation
MILP (Mixed Integer LP) Some must be whole numbers Scheduling, integer allocation
BIP (Binary Integer) 0 or 1 only Yes/no selection
SATISFY Any — no optimization Feasibility checking

Euboulia classifies during type inference and stores it as problem_category.

Sensitivity and shadow prices

Shadow prices answer: "If I relaxed this constraint by one unit, how much would the objective improve?"

  • LPs: shadow prices from the primal solve — exact.
  • MIPs: CVXPY doesn't return meaningful duals at the MIP optimum. Euboulia fixes optimal integer values as equality constraints and re-solves the resulting LP with CLARABEL. These shadow prices reflect trade-offs within the chosen integer allocation — not what would happen if the integer decisions themselves changed.

The Decision Brief's Shadow Prices table shows binding status and shadow price per constraint. Vector constraints collapse to the largest absolute shadow price; click to expand per-element breakdown.

Solver options

Two knobs per run:

  • time_limit_seconds — graceful stop; returns best incumbent
  • mip_gap — relative optimality gap tolerance (e.g., 0.05 = 5%)

Set in chat: "Run with a 60 second time limit" or "Accept up to 5% gap."

Debug loop

If generated code raises an exception, Euboulia automatically: captures the error, sends it back to the LLM with the faulty code, receives a patched version, re-executes. Up to three retries.

Learn More