diff --git a/agentigrid/README.md b/agentigrid/README.md
index 2a417db7..cb1f0ebb 100644
--- a/agentigrid/README.md
+++ b/agentigrid/README.md
@@ -56,7 +56,7 @@ Adding a generator supports two modes, chosen from the goal's wording (and named
 
 ### Custom Sweep Metric / Predicate (named registry)
 
-Beyond the default cost metric and standard V-band/loading feasibility, a sweep can select a **named, verified primitive** (`agentigrid/engine/sweep_metrics.py`) — not free-form code. Selection is by name; the registry is extensible (`register_metric` / `register_predicate`) for later capabilities.
+Beyond the default cost metric and standard V-band/loading feasibility, a sweep can select a **named, verified primitive** (`agentigrid/exago_engine/sweep_metrics.py`) — not free-form code. Selection is by name; the registry is extensible (`register_metric` / `register_predicate`) for later capabilities.
 
 - **`metric: "max_delta_v"`** — ranks buses by the worst *system-wide* voltage step `max_b |V_candidate[b] − V_base[b]|` caused by switching in a load block (`search.switched_load_mw`) at the candidate bus. A power-quality flag; the largest step need not be at the switched bus. Requires (and triggers) a one-time base-case solve for the reference voltages.
 - **`feasibility_predicate: "reactive_adequacy"`** — replaces standard feasibility with a reactive-headroom test: a feasible OPF must exist with the added unit forced to `(P = Pmax, Q = Qmax)` (the sweep pins `Qmin = Qmax`). Returns the limiting quantity when it fails.
@@ -78,6 +78,44 @@ agentigrid --tool gridkit --config configs/local_config.yaml \
   "Assume a short circuit fault at each bus of the system, tell me if the system can survive without blackout."
 ```
 
+**Starting from the latest ExaGO steady state.** A fault screen with
+`"start_from": "latest_steady_state"` (the LLM sets it when the goal asks for "the most
+recent steady state"; `--from-exago` forces it for the whole session) uses the GridKit
+case only for the dynamic models; the operating point and network come from the last
+simulation of the newest ExaGO journal in `workdir/exago/` (OPFLOW/PFLOW save their
+solved case, `opflowout.m` / `pflowout.m`, in the iteration folder). Bus voltages,
+machine `p0`/`q0`, loads, shunts and branches are taken from ExaGO; machines of
+generators that are off in ExaGO are removed with their controls. That start gets its
+own no-fault run before any fault. The screen is not run if that simulation did not
+converge, was a sweep, or has an online generator without a dynamic model in the
+GridKit case. The converted case is saved as `from_exago.case.json` in the session
+folder.
+
+**Saved solutions** (`exago.save_solutions` in the config, or
+`--set exago.save_solutions=<value>`). Single solves (base case, `modify`, `select`)
+always keep their solved case. For an action with many solves (sweep, explore,
+boundary, contingency, reserve):
+
+| Value | Kept |
+|---|---|
+| `best` (default) | the best run: cheapest feasible sweep candidate (or best by the sweep's metric), largest hosting capacity (boundary), Pareto-best variant (explore); the most recent if the action has no best (contingency, reserve) |
+| `newest` | the most recent run |
+| `all` | every run |
+| `none` | nothing is written; GridKit cannot start from the latest ExaGO steady state |
+
+Only the solution files are removed; run folders and their input cases stay. After an
+`explore`, pruning waits for the next action, so a variant chosen by `select` keeps
+its solution.
+
+**ContingencyAnalysis.** With `"application": "ContingencyAnalysis"` (the LLM sets it
+when the goal asks for contingency analysis), one GridKit `ContingencyAnalysis` process
+runs all bus faults of the screen, writing `output_<fault index>.csv` per fault in the
+screen's `contingency/` folder; the checks and verdict are the same as with
+`DynamicSimulation`. `ContingencyAnalysis` runs every fault device in the case file, so
+its case copy holds only the requested faults (fault devices shipped with the case,
+such as a demo fault, are left out of the copy). With `DynamicSimulation` they stay in
+the copy but are never switched on.
+
 Link the GridKit binaries and cases first (see [applications/gridkit/README.md](applications/gridkit/README.md)
 and [data/gridkit/README.md](data/gridkit/README.md)). Sessions are written to
 `workdir/gridkit/session_<time>/` (element map, case copies, one folder per fault,
@@ -438,6 +476,13 @@ For transient studies, link GridKit's binaries into `applications/gridkit/` and
 
 Edit `configs/default_config.yaml` or pass `--config path/to/config.yaml`. CLI arguments override config file values.
 
+One config file holds the settings for both tools: the `exago:` and `data:` sections
+for ExaGO, and the `gridkit:` section for GridKit (binary, timeout per run, the
+solver values written into each run's solver `.json`, and the default fault start).
+The LLM, iteration limit, worker count and output folders are shared. PJM pass/fail
+limits are not configurable; they live in `agentigrid/gridkit_engine/criteria.py`
+with their sources.
+
 Set your API key as an environment variable:
 ```bash
 export ANTHROPIC_API_KEY="your-key-here"
diff --git a/agentigrid/agentigrid/cli.py b/agentigrid/agentigrid/cli.py
index d8367696..b6a35aeb 100644
--- a/agentigrid/agentigrid/cli.py
+++ b/agentigrid/agentigrid/cli.py
@@ -6,7 +6,7 @@
 import logging
 import sys
 import threading
-from dataclasses import fields
+from dataclasses import fields, replace
 from datetime import datetime
 from pathlib import Path
 from typing import Any
@@ -208,6 +208,16 @@ def build_parser() -> argparse.ArgumentParser:
         help="Simulation tool: exago (steady state, .m case) or gridkit "
              "(transient stability, .case.json case). Default: exago",
     )
+    parser.add_argument(
+        "--from-exago",
+        action="store_true",
+        default=False,
+        help="GridKit only: start from the most recent ExaGO steady state "
+             "(last simulation of the newest journal in workdir/exago) instead of "
+             "the case's own operating point, for every fault screen. Without it, "
+             "the LLM chooses per fault screen (start_from), e.g. when the goal "
+             "asks for the most recent steady state.",
+    )
     parser.add_argument(
         "--version",
         action="version",
@@ -358,7 +368,8 @@ def _listen():
                 controller.request_stop()
                 print("[Steering] Stop requested.")
             elif lower == "save":
-                save_dir = Path(f"workdir/saved_session_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
+                stamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                save_dir = controller._config.output.workdir / f"saved_session_{stamp}"
                 controller.save_session(save_dir)
                 print(f"[Steering] Session saved to: {save_dir}")
             elif lower == "status":
@@ -389,7 +400,7 @@ def _listen():
 
 def run_search(cfg: AppConfig, goal: str, quiet: bool = False) -> None:
     """Run the LLM-driven search loop."""
-    from agentigrid.engine.agent_loop import AgentLoopController
+    from agentigrid.exago_engine.agent_loop import AgentLoopController
 
     controller = AgentLoopController(cfg, quiet=quiet)
 
@@ -400,6 +411,16 @@ def run_search(cfg: AppConfig, goal: str, quiet: bool = False) -> None:
     controller.run(cfg.search.base_case, goal)
 
 
+def exago_output(cfg: AppConfig) -> AppConfig:
+    """ExaGO runs write to an ``exago/`` subfolder of the output folders,
+    as GridKit runs write to ``gridkit/``."""
+    return replace(cfg, output=replace(
+        cfg.output,
+        workdir=Path(cfg.output.workdir) / "exago",
+        logs_dir=Path(cfg.output.logs_dir) / "exago",
+    ))
+
+
 def run_gridkit(cfg: AppConfig, args: argparse.Namespace) -> None:
     """Run a GridKit transient-stability study (``--tool gridkit``)."""
     from agentigrid.gridkit_engine.agent_loop import GridkitAgentLoop
@@ -415,8 +436,21 @@ def run_gridkit(cfg: AppConfig, args: argparse.Namespace) -> None:
     if not case_file.exists():
         logger.error("Case file does not exist: %s", case_file)
         sys.exit(1)
+    from agentigrid.gridkit_engine.from_exago import (
+        SteadyStateError, find_latest_steady_state,
+    )
+
+    steady_state = None
+    if args.from_exago:
+        try:
+            steady_state = find_latest_steady_state(exago_output(cfg).output.workdir)
+        except SteadyStateError as exc:
+            logger.error("%s", exc)
+            sys.exit(1)
     if args.dry_run:
         print(f"GridKit settings: {settings}")
+        if steady_state:
+            print(f"Start from: {steady_state.describe()}")
         return
     quiet = getattr(args, "quiet", False) or False
     if not quiet:
@@ -431,8 +465,9 @@ def run_gridkit(cfg: AppConfig, args: argparse.Namespace) -> None:
     from agentigrid.gridkit_parsers.case_parser import CaseFileError
 
     try:
-        session = GridkitAgentLoop(cfg, settings=settings, quiet=quiet).run(case_file, args.goal)
-    except (FileNotFoundError, CaseFileError) as exc:
+        session = GridkitAgentLoop(cfg, settings=settings, quiet=quiet).run(
+            case_file, args.goal, steady_state=steady_state)
+    except (FileNotFoundError, CaseFileError, SteadyStateError) as exc:
         logger.error("%s", exc)
         sys.exit(1)
     if session.termination_reason in ("llm_error", "base_case_failed", "parse_failures"):
@@ -447,7 +482,7 @@ def run_regenerate_report(argv: list[str] | None = None) -> None:
     renders from deterministic journal data only.
     """
     from agentigrid.backends import create_backend
-    from agentigrid.engine.regenerate_report import regenerate_from_journal
+    from agentigrid.exago_engine.regenerate_report import regenerate_from_journal
 
     sub = argparse.ArgumentParser(
         prog="agentigrid regenerate-report",
@@ -470,7 +505,7 @@ def run_regenerate_report(argv: list[str] | None = None) -> None:
         overrides["llm.backend"] = args.backend
     if args.model:
         overrides["llm.model"] = args.model
-    cfg = load_config(Path(args.config), cli_overrides=overrides)
+    cfg = exago_output(load_config(Path(args.config), cli_overrides=overrides))
     setup_logging(cfg.output.logs_dir, verbose=cfg.output.verbose)
 
     generate_analysis = not args.no_analysis
@@ -508,6 +543,7 @@ def main(argv: list[str] | None = None) -> None:
     if args.tool == "gridkit":
         run_gridkit(cfg, args)
         return
+    cfg = exago_output(cfg)
 
     # Set up logging
     verbose = cfg.output.verbose
@@ -538,7 +574,7 @@ def main(argv: list[str] | None = None) -> None:
             sys.exit(1)
         if not quiet:
             print(f"Resuming session from: {resume_dir}")
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         controller = AgentLoopController(cfg, quiet=quiet)
         if sys.stdin.isatty():
             _start_stdin_listener(controller)
diff --git a/agentigrid/agentigrid/config.py b/agentigrid/agentigrid/config.py
index ce52e93c..7f0cb8d5 100644
--- a/agentigrid/agentigrid/config.py
+++ b/agentigrid/agentigrid/config.py
@@ -29,6 +29,7 @@
         "env_script": None,
         "timeout": 600,
         "mpi_np": 1,
+        "save_solutions": "best",
     },
     "data": {
         "data_dir": "./data/exago",
@@ -98,8 +99,27 @@
         "near_optimal_abs_tol": 5.0,
         "network_summary_max_generators": 40,
     },
+    "gridkit": {
+        "binary_dir": "./applications/gridkit",
+        "dynamicsimulation_binary": None,
+        "timeout": 600,
+        "study": {
+            "tmax": 15.0,
+            "dt_monitor": 0.01,
+            "rel_tol": 1.0e-7,
+            "abs_tol": 1.0e-9,
+            "dt_fixed": 0.0,
+            "max_steps": 0,
+            "max_order": 5,
+        },
+        "fault": {
+            "start": 1.0,
+        },
+    },
 }
 
+SAVE_SOLUTIONS = ("all", "best", "newest", "none")
+
 # ---------------------------------------------------------------------------
 # Frozen dataclasses
 # ---------------------------------------------------------------------------
@@ -117,6 +137,11 @@ class ExagoConfig:
     env_script: Optional[Path]
     timeout: int
     mpi_np: int = 1
+    # Solved cases written by OPFLOW/PFLOW (opflowout.m / pflowout.m): "all" keeps
+    # every one; "best" / "newest" keep one per multi-solve action (the best, else
+    # the most recent / the most recent); single solves are always kept; "none"
+    # writes none.
+    save_solutions: str = "best"
 
 
 @dataclass(frozen=True)
@@ -210,6 +235,39 @@ class ReportConfig:
         # top-N by Pmax. Bounds system-prompt size at scale.
 
 
+@dataclass(frozen=True)
+class GridkitStudyConfig:
+    """Keys written one-to-one into GridKit's solver .json
+    (GridKit/application/PhasorDynamics/README.md)."""
+
+    tmax: float = 15.0          # simulation length, s (PJM M-14B G.2.2: 10-15 s)
+    dt_monitor: float = 0.01    # recording interval, s
+    rel_tol: float = 1.0e-7
+    abs_tol: float = 1.0e-9
+    dt_fixed: float = 0.0       # 0 = adaptive time step
+    max_steps: int = 0          # 0 = IDA default, negative = unlimited
+    max_order: int = 5          # IDA method order, 1-5
+
+    def solver_options(self) -> dict[str, Any]:
+        """Solver keys other than tmax/dt_monitor (those are set per run)."""
+        return {f.name: getattr(self, f.name) for f in fields(self)
+                if f.name not in ("tmax", "dt_monitor")}
+
+
+@dataclass(frozen=True)
+class GridkitFaultConfig:
+    start: float = 1.0          # fault_on time, s, when the goal gives none
+
+
+@dataclass(frozen=True)
+class GridkitConfig:
+    binary_dir: Path = Path("./applications/gridkit")
+    dynamicsimulation_binary: Optional[Path] = None   # defaults to {binary_dir}/DynamicSimulation
+    timeout: float = 600        # seconds per GridKit run
+    study: GridkitStudyConfig = field(default_factory=GridkitStudyConfig)
+    fault: GridkitFaultConfig = field(default_factory=GridkitFaultConfig)
+
+
 @dataclass(frozen=True)
 class AppConfig:
     """Top-level immutable configuration for AgentiGrid."""
@@ -220,6 +278,7 @@ class AppConfig:
     search: SearchConfig
     output: OutputConfig
     report: ReportConfig = field(default_factory=ReportConfig)
+    gridkit: GridkitConfig = field(default_factory=GridkitConfig)
 
 
 # ---------------------------------------------------------------------------
@@ -333,12 +392,38 @@ def load_config(
 
     report = _build_section(ReportConfig, merged.get("report", {}), config_root, set())
 
-    cfg = AppConfig(exago=exago, data=data, llm=llm, search=search, output=output, report=report)
+    gridkit = _build_gridkit(merged["gridkit"], config_root)
+
+    cfg = AppConfig(exago=exago, data=data, llm=llm, search=search, output=output, report=report,
+                    gridkit=gridkit)
 
     _validate(cfg)
     return cfg
 
 
+def _build_gridkit(raw: dict, root: Path) -> GridkitConfig:
+    """Build the ``gridkit:`` section. GridKit ignores unknown solver keys
+    without a word, so unknown keys here are warned about, not dropped silently."""
+    nested = {"study": GridkitStudyConfig, "fault": GridkitFaultConfig}
+    for name, cls in [("gridkit", GridkitConfig), *nested.items()]:
+        section = raw if name == "gridkit" else raw.get(name) or {}
+        unknown = set(section) - {f.name for f in fields(cls)}
+        if unknown:
+            logger.warning("Unknown key(s) in gridkit config %s: %s (ignored)",
+                           "" if name == "gridkit" else f"section '{name}'", sorted(unknown))
+    flat = {k: v for k, v in raw.items() if k not in nested}
+    base = _build_section(
+        GridkitConfig, flat, root, {"binary_dir", "dynamicsimulation_binary"},
+    )
+    # An empty "study:" line in YAML is null, which would replace the defaults.
+    parts = {name: _build_section(cls, {**DEFAULTS["gridkit"][name], **(raw.get(name) or {})},
+                                  root, set())
+             for name, cls in nested.items()}
+    return GridkitConfig(binary_dir=base.binary_dir,
+                         dynamicsimulation_binary=base.dynamicsimulation_binary,
+                         timeout=base.timeout, **parts)
+
+
 def _validate(cfg: AppConfig) -> None:
     """Emit warnings for missing paths; does not raise."""
     if not cfg.exago.binary_dir.exists():
@@ -349,6 +434,10 @@ def _validate(cfg: AppConfig) -> None:
     if not cfg.data.data_dir.exists():
         logger.warning("Data directory does not exist: %s", cfg.data.data_dir)
 
+    if cfg.exago.save_solutions not in SAVE_SOLUTIONS:
+        logger.warning("Unknown exago.save_solutions '%s' (expected one of %s)",
+                       cfg.exago.save_solutions, SAVE_SOLUTIONS)
+
     valid_backends = {"openai", "anthropic", "ollama", "ollama-cloud"}
     if cfg.llm.backend not in valid_backends:
         logger.warning("Unknown LLM backend '%s' (expected one of %s)", cfg.llm.backend, valid_backends)
@@ -452,3 +541,13 @@ def _validate(cfg: AppConfig) -> None:
             "sweep_max_workers=%d is negative; treating as auto (min(cpu_count, 16)).",
             cfg.search.sweep_max_workers,
         )
+
+    study, fault = cfg.gridkit.study, cfg.gridkit.fault
+    if not 1 <= study.max_order <= 5:
+        logger.warning("gridkit.study.max_order=%s is outside 1-5; GridKit will refuse to run.",
+                       study.max_order)
+    if study.dt_monitor <= 0:
+        logger.warning("gridkit.study.dt_monitor=%s must be positive.", study.dt_monitor)
+    if fault.start >= study.tmax:
+        logger.warning("gridkit.fault.start=%s s is not before gridkit.study.tmax=%s s.",
+                       fault.start, study.tmax)
diff --git a/agentigrid/agentigrid/engine/__init__.py b/agentigrid/agentigrid/exago_engine/__init__.py
similarity index 63%
rename from agentigrid/agentigrid/engine/__init__.py
rename to agentigrid/agentigrid/exago_engine/__init__.py
index 6a46826a..207b678b 100644
--- a/agentigrid/agentigrid/engine/__init__.py
+++ b/agentigrid/agentigrid/exago_engine/__init__.py
@@ -4,20 +4,20 @@
 
 import logging
 
-from agentigrid.engine.agent_loop import AgentLoopController, SearchSession
-from agentigrid.engine.commands import ModCommand, parse_command
-from agentigrid.engine.executor import SimulationExecutor, SimulationResult
-from agentigrid.engine.explore import ExploreCache, VariantResult
-from agentigrid.engine.journal import JournalEntry, ObjectiveEntry, ObjectiveRegistry, SearchJournal
-from agentigrid.engine.metric_extractor import available_metrics, extract_all_metrics, extract_metric
-from agentigrid.engine.modifier import ModificationReport, apply_modifications
-from agentigrid.engine.objective_parser import build_objective_extraction_prompt, parse_objective_extraction
-from agentigrid.engine.schema_description import command_schema_text
-from agentigrid.engine.session_io import save_session, load_session
-from agentigrid.engine.validation import ValidationResult, validate_command
-from agentigrid.parsers.matpower_model import MATNetwork
+from agentigrid.exago_engine.agent_loop import AgentLoopController, SearchSession
+from agentigrid.exago_engine.commands import ModCommand, parse_command
+from agentigrid.exago_engine.executor import SimulationExecutor, SimulationResult
+from agentigrid.exago_engine.explore import ExploreCache, VariantResult
+from agentigrid.exago_engine.journal import JournalEntry, ObjectiveEntry, ObjectiveRegistry, SearchJournal
+from agentigrid.exago_engine.metric_extractor import available_metrics, extract_all_metrics, extract_metric
+from agentigrid.exago_engine.modifier import ModificationReport, apply_modifications
+from agentigrid.exago_engine.objective_parser import build_objective_extraction_prompt, parse_objective_extraction
+from agentigrid.exago_engine.schema_description import command_schema_text
+from agentigrid.exago_engine.session_io import save_session, load_session
+from agentigrid.exago_engine.validation import ValidationResult, validate_command
+from agentigrid.exago_parsers.matpower_model import MATNetwork
 
-logger = logging.getLogger("agentigrid.engine")
+logger = logging.getLogger("agentigrid.exago_engine")
 
 __all__ = [
     "AgentLoopController",
diff --git a/agentigrid/agentigrid/engine/agent_loop.py b/agentigrid/agentigrid/exago_engine/agent_loop.py
similarity index 97%
rename from agentigrid/agentigrid/engine/agent_loop.py
rename to agentigrid/agentigrid/exago_engine/agent_loop.py
index 72763d59..e2f55880 100644
--- a/agentigrid/agentigrid/engine/agent_loop.py
+++ b/agentigrid/agentigrid/exago_engine/agent_loop.py
@@ -20,9 +20,9 @@
 from agentigrid.backends import create_backend
 from agentigrid.backends.base import LLMBackend, LLMResponse
 from agentigrid.config import AppConfig
-from agentigrid.engine.commands import parse_command
-from agentigrid.engine.executor import SimulationExecutor, SimulationResult
-from agentigrid.engine.explore import (
+from agentigrid.exago_engine.commands import parse_command
+from agentigrid.exago_engine.executor import SimulationExecutor, SimulationResult
+from agentigrid.exago_engine.explore import (
     ExploreCache,
     VariantResult,
     annotate_cost_equivalent_siblings,
@@ -30,28 +30,28 @@
     compute_pareto_labels,
     format_variant_results,
 )
-from agentigrid.engine.journal import JournalEntry, ObjectiveEntry, SearchJournal
-from agentigrid.engine.metric_extractor import available_metrics, available_metrics_for_app, extract_all_metrics
-from agentigrid.engine.modifier import apply_modifications, build_index_maps
-from agentigrid.engine import sweep_metrics
-from agentigrid.engine.objective_parser import (
+from agentigrid.exago_engine.journal import JournalEntry, ObjectiveEntry, SearchJournal
+from agentigrid.exago_engine.metric_extractor import available_metrics, available_metrics_for_app, extract_all_metrics
+from agentigrid.exago_engine.modifier import apply_modifications, build_index_maps
+from agentigrid.exago_engine import sweep_metrics
+from agentigrid.exago_engine.objective_parser import (
     build_objective_extraction_prompt,
     parse_objective_extraction,
 )
-from agentigrid.engine.schema_description import command_schema_text
-from agentigrid.parsers import (
+from agentigrid.exago_engine.schema_description import command_schema_text
+from agentigrid.exago_parsers import (
     parse_matpower,
     network_metadata,
     network_summary,
     parse_simulation_result_for_app,
     results_summary_for_app,
 )
-from agentigrid.parsers.matpower_model import MATNetwork
-from agentigrid.parsers.opflow_results import OPFLOWResult
-from agentigrid.engine import topology
-from agentigrid.engine import contingency
-from agentigrid.engine import relief as relief_search
-from agentigrid.engine import reserve as reserve_search
+from agentigrid.exago_parsers.matpower_model import MATNetwork
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine import topology
+from agentigrid.exago_engine import contingency
+from agentigrid.exago_engine import relief as relief_search
+from agentigrid.exago_engine import reserve as reserve_search
 
 
 def _count_scenario_rows(scenario_path: Path) -> int:
@@ -62,9 +62,9 @@ def _count_scenario_rows(scenario_path: Path) -> int:
     except (OSError, UnicodeDecodeError):
         return 1
 from agentigrid.prompts.exago import build_system_prompt, build_user_prompt
-from agentigrid.engine.goal_classifier import build_classification_prompts, parse_goal_classification
+from agentigrid.exago_engine.goal_classifier import build_classification_prompts, parse_goal_classification
 
-logger = logging.getLogger("agentigrid.engine.agent_loop")
+logger = logging.getLogger("agentigrid.exago_engine.agent_loop")
 
 _MAX_CONSECUTIVE_PARSE_FAILURES = 3
 
@@ -691,7 +691,7 @@ def _by_capacity_desc(s: dict):
 
 def _benchmark_to_dict(bresult) -> dict:
     """Convert a BenchmarkResult to a serializable dict."""
-    from agentigrid.engine.benchmark import DispatchComparison, LoadabilityResult
+    from agentigrid.exago_engine.benchmark import DispatchComparison, LoadabilityResult
     d: dict = {
         "opflow_converged": bresult.opflow_converged,
         "opflow_objective": bresult.opflow_objective,
@@ -811,6 +811,10 @@ def __init__(
         self._sopflow_num_scenarios: int = 0
         self._sopflow_scenario_override: Optional[Path] = None
         self._explore_cache: Optional[ExploreCache] = None
+        # Saved-solution pruning (exago.save_solutions): the best run folder of the
+        # current action, and an explore's folders waiting for the next action.
+        self._batch_best: Optional[Path] = None
+        self._pending_explore: Optional[tuple[list[Path], Optional[Path]]] = None
         # Sticky session-level load factor (Task 1)
         self._session_load_factor: Optional[float] = config.search.load_factor
         # Benchmark result computed at session start (Task 2)
@@ -958,7 +962,7 @@ def _normalize_sopflow_wind_base(self) -> None:
             scenario = self._sopflow_scenario_override or self._config.search.scenario_file
             if scenario:
                 try:
-                    from agentigrid.parsers.sopflow_dispatch import _parse_wind_columns
+                    from agentigrid.exago_parsers.sopflow_dispatch import _parse_wind_columns
                     _cols, bus_map = _parse_wind_columns(Path(str(scenario)))
                     wind_buses = set(bus_map.values())
                     wind_idx = {
@@ -1020,7 +1024,7 @@ def run(self, base_case: Path, goal: str) -> SearchSession:
             and self._config.search.benchmark_opflow
         ):
             try:
-                from agentigrid.engine.benchmark import _run_opflow_on_base_case
+                from agentigrid.exago_engine.benchmark import _run_opflow_on_base_case
                 from agentigrid.prompts.exago.system_prompt import format_benchmark_for_prompt
                 self._print("[Session] Running OPFLOW baseline for benchmark reference...")
                 opflow_baseline = _run_opflow_on_base_case(base_case, self._config)
@@ -1042,7 +1046,7 @@ def run(self, base_case: Path, goal: str) -> SearchSession:
                     if opflow_cost and pflow_baseline_cost and opflow_cost != 0:
                         gap_abs = pflow_baseline_cost - opflow_cost
                         gap_pct = gap_abs / abs(opflow_cost) * 100
-                    from agentigrid.engine.benchmark import _build_dispatch_comparison, DispatchComparison
+                    from agentigrid.exago_engine.benchmark import _build_dispatch_comparison, DispatchComparison
                     dispatch_cmp = _build_dispatch_comparison(opflow_baseline, pflow_result_tmp if pflow_result_tmp is not None else None)
                     bench_dict: dict = {
                         "opflow_converged": opflow_baseline.converged,
@@ -1102,14 +1106,14 @@ def run(self, base_case: Path, goal: str) -> SearchSession:
 
         # Extract SCOPFLOW metadata (num_contingencies) once from base case
         if self._config.search.application == "scopflow" and sim_result.success:
-            from agentigrid.parsers import parse_scopflow_metadata
+            from agentigrid.exago_parsers import parse_scopflow_metadata
             meta = parse_scopflow_metadata(sim_result)
             if meta:
                 self._scopflow_num_contingencies = meta.get("num_contingencies", 0)
 
         # Extract TCOPFLOW metadata and period files once from base case
         if self._config.search.application == "tcopflow" and sim_result.success:
-            from agentigrid.parsers import parse_tcopflow_metadata, parse_tcopflow_period_files
+            from agentigrid.exago_parsers import parse_tcopflow_metadata, parse_tcopflow_period_files
             meta = parse_tcopflow_metadata(sim_result)
             if meta:
                 self._tcopflow_num_steps = meta.get("num_steps", 0)
@@ -1120,7 +1124,7 @@ def run(self, base_case: Path, goal: str) -> SearchSession:
 
         # Extract SOPFLOW metadata once from base case
         if self._config.search.application == "sopflow" and sim_result.success:
-            from agentigrid.parsers import parse_sopflow_metadata
+            from agentigrid.exago_parsers import parse_sopflow_metadata
             meta = parse_sopflow_metadata(sim_result)
             if meta:
                 self._sopflow_num_scenarios = meta.get("num_scenarios", 0)
@@ -1128,7 +1132,7 @@ def run(self, base_case: Path, goal: str) -> SearchSession:
         # Compute second-stage wind absorption (offered/dispatched/curtailed)
         wind_absorption = None
         if self._config.search.application == "sopflow" and sim_result.success:
-            from agentigrid.parsers import compute_wind_absorption
+            from agentigrid.exago_parsers import compute_wind_absorption
             active_scenario = self._sopflow_scenario_override or self._config.search.scenario_file
             if active_scenario:
                 wind_absorption = compute_wind_absorption(sim_result.workdir, Path(str(active_scenario)))
@@ -1360,7 +1364,16 @@ def _iteration(
         data = response.json_data
         action = data.get("action", "").lower()
 
-        # Dispatch action
+        # The solves of one action form a batch whose saved solutions are
+        # pruned afterwards (exago.save_solutions).
+        self._batch_best = None
+        self._executor.begin_batch()
+        try:
+            return self._dispatch_action(action, iteration, data)
+        finally:
+            self._prune_saved_solutions(action, self._executor.end_batch())
+
+    def _dispatch_action(self, action: str, iteration: int, data: dict) -> tuple[str, bool]:
         if action == "modify":
             self._explore_cache = None
             return self._handle_modify(iteration, data)
@@ -1387,6 +1400,24 @@ def _iteration(
                 self._error_feedback = f"Unknown action '{action}'. Valid actions: modify, complete, analyze."
             return "error", True
 
+    def _prune_saved_solutions(self, action: str, run_dirs: list[Path]) -> None:
+        """Keep one saved solution per multi-solve action (exago.save_solutions).
+
+        The variants of an explore are pruned only after the next action, so a
+        variant the LLM then selects keeps its solution: select reuses the
+        variant's run, and GridKit may start from it.
+        """
+        pending, self._pending_explore = self._pending_explore, None
+        if pending is not None:
+            dirs, best = pending
+            if action == "select" and self._batch_best is not None:
+                best = self._batch_best
+            self._executor.prune_solutions(dirs, best)
+        if action == "explore":
+            self._pending_explore = (run_dirs, self._batch_best)
+        elif len(run_dirs) > 1:
+            self._executor.prune_solutions(run_dirs, self._batch_best)
+
     # ------------------------------------------------------------------
     # Action handlers
     # ------------------------------------------------------------------
@@ -1515,13 +1546,13 @@ def _handle_modify(
 
         # Parse TCOPFLOW period files after simulation
         if self._config.search.application == "tcopflow" and opflow is not None and sim_result.success:
-            from agentigrid.parsers import parse_tcopflow_period_files
+            from agentigrid.exago_parsers import parse_tcopflow_period_files
             self._tcopflow_period_data = parse_tcopflow_period_files(sim_result.workdir)
 
         # Compute second-stage wind absorption (offered/dispatched/curtailed)
         wind_absorption = None
         if self._config.search.application == "sopflow" and sim_result.success:
-            from agentigrid.parsers import compute_wind_absorption
+            from agentigrid.exago_parsers import compute_wind_absorption
             active_scenario = self._sopflow_scenario_override or self._config.search.scenario_file
             if active_scenario:
                 wind_absorption = compute_wind_absorption(sim_result.workdir, Path(str(active_scenario)))
@@ -1941,6 +1972,8 @@ def _handle_explore(
             best = variant_results[pareto_labels[0]]
             if best.opflow_result is not None:
                 self._latest_opflow = best.opflow_result
+            if best.sim_result is not None:
+                self._batch_best = best.sim_result.workdir
 
         self._print(
             f"[Iter {iteration}] Explored {len(variant_results)} variants. "
@@ -2530,6 +2563,15 @@ def _sweep_progress(done: int, total: int) -> None:
                 objective_name = "cost"
                 objective_direction = "minimize"
 
+        # Best feasible candidate by the same ranking: its saved solution is kept.
+        cand_index = {bus: i for i, bus in enumerate(candidates)}
+        ranked = [(s[rank_key], cand_index[s["bus"]]) for s in candidate_summaries
+                  if s.get("feasible") and s.get(rank_key) is not None
+                  and cand_index.get(s["bus"]) in results_by_cand]
+        if ranked:
+            pick = (max if objective_direction == "maximize" else min)(ranked)
+            self._batch_best = results_by_cand[pick[1]].workdir
+
         self._latest_results_text = _build_sweep_llm_view(
             candidate_summaries=candidate_summaries,
             feasible_buses=feasible_buses,
@@ -2604,6 +2646,7 @@ def _bisect_candidate(
         s = self._config.search
         tan_phi = _tan_phi_from_pf_spec(pf_spec, tan_phi_avg) if entity == "load" else 0.0
         probe_counter = {"n": 0}
+        boundary_probe = {"mw": None, "dir": None}   # highest feasible probe = boundary point
 
         def solve_probe(delta_mw: float) -> _ProbeOutcome:
             probe_counter["n"] += 1
@@ -2624,6 +2667,8 @@ def solve_probe(delta_mw: float) -> _ProbeOutcome:
             feasible = (
                 opflow.feasibility_detail == "feasible" and opflow.num_violations == 0
             )
+            if feasible and (boundary_probe["mw"] is None or delta_mw > boundary_probe["mw"]):
+                boundary_probe["mw"], boundary_probe["dir"] = delta_mw, sim_result.workdir
             return _ProbeOutcome(
                 feasible=feasible,
                 voltage_min=opflow.voltage_min,
@@ -2643,6 +2688,7 @@ def solve_probe(delta_mw: float) -> _ProbeOutcome:
         )
         result["bus"] = bus
         result["entity"] = entity
+        result["_boundary_run_dir"] = boundary_probe["dir"]   # popped by _handle_boundary_sweep
         if entity == "load":
             result["pf_tan_phi"] = tan_phi
         return result
@@ -2759,8 +2805,16 @@ def _boundary_progress(done: int, total: int) -> None:
         # Assemble per-candidate summaries (in sorted candidate order).
         candidate_summaries: list[dict] = []
         determined_buses: list[int] = []
+        best_mw = None
         for idx, bus in enumerate(candidates):
             r = results_map.get(idx)
+            if isinstance(r, dict):
+                # The largest hosting capacity is the best; its boundary point's
+                # saved solution is kept.
+                run_dir = r.pop("_boundary_run_dir", None)
+                mw = r.get("max_feasible_mw")
+                if run_dir is not None and mw is not None and (best_mw is None or mw > best_mw):
+                    best_mw, self._batch_best = mw, run_dir
             if r is None or isinstance(r, Exception):
                 candidate_summaries.append({
                     "bus": bus,
@@ -3950,6 +4004,8 @@ def _handle_select(
             )
             return "error", True
         self._print(f'[Iter {iteration}] Selected variant {choice} — "{selected.description}"')
+        if selected.sim_result is not None:
+            self._batch_best = selected.sim_result.workdir   # keeps its saved solution
 
         # Update current state
         self._current_network = selected.modified_net
@@ -4189,7 +4245,7 @@ def _handle_scenario_voltage_spread(
         LLM/backend call. Fully guarded so a missing/cleaned workdir just yields
         an informative error instead of crashing.
         """
-        from agentigrid.parsers import compute_scenario_voltage_spread
+        from agentigrid.exago_parsers import compute_scenario_voltage_spread
 
         if self._config.search.application != "sopflow":
             self._error_feedback = (
@@ -4772,6 +4828,10 @@ def _assemble_prompt(
     def _finalize(self, session: SearchSession, elapsed_seconds: float) -> None:
         """Print summary and save journal."""
         total_tokens = self._total_prompt_tokens + self._total_completion_tokens
+        if self._pending_explore is not None:      # session ended right after an explore
+            dirs, best = self._pending_explore
+            self._pending_explore = None
+            self._executor.prune_solutions(dirs, best)
 
         # --- Post-search goal classification via LLM ---
         goal_classification: Optional[dict] = None
@@ -4927,7 +4987,7 @@ def _finalize(self, session: SearchSession, elapsed_seconds: float) -> None:
             and self._config.search.benchmark_opflow
         ):
             try:
-                from agentigrid.engine.benchmark import run_pflow_vs_opflow_benchmark
+                from agentigrid.exago_engine.benchmark import run_pflow_vs_opflow_benchmark
 
                 best_iter_num = stats.get("best_iteration")
                 goal_type_str = stats.get("goal_type") or goal_type
@@ -4977,7 +5037,7 @@ def resume_from(self, save_dir: Path) -> SearchSession:
         Returns:
             Completed SearchSession.
         """
-        from agentigrid.engine.session_io import load_session
+        from agentigrid.exago_engine.session_io import load_session
 
         saved = load_session(save_dir)
 
@@ -5173,7 +5233,7 @@ def save_session(self, save_dir: Path, config_path: Path | str | None = None) ->
         Returns:
             Path to the saved session directory.
         """
-        from agentigrid.engine.session_io import save_session as _save_session
+        from agentigrid.exago_engine.session_io import save_session as _save_session
 
         last_entry = self._journal.latest
         last_iteration = last_entry.iteration if last_entry else 0
diff --git a/agentigrid/agentigrid/engine/benchmark.py b/agentigrid/agentigrid/exago_engine/benchmark.py
similarity index 95%
rename from agentigrid/agentigrid/engine/benchmark.py
rename to agentigrid/agentigrid/exago_engine/benchmark.py
index 2054935c..50edaf49 100644
--- a/agentigrid/agentigrid/engine/benchmark.py
+++ b/agentigrid/agentigrid/exago_engine/benchmark.py
@@ -7,14 +7,14 @@
 from pathlib import Path
 from typing import Optional
 
-from agentigrid.engine.executor import SimulationExecutor, SimulationResult
-from agentigrid.engine.journal import SearchJournal
-from agentigrid.parsers import parse_simulation_result_for_app
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine.executor import SimulationExecutor, SimulationResult
+from agentigrid.exago_engine.journal import SearchJournal
+from agentigrid.exago_parsers import parse_simulation_result_for_app
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 from agentigrid.config import AppConfig
 
-logger = logging.getLogger("agentigrid.engine.benchmark")
+logger = logging.getLogger("agentigrid.exago_engine.benchmark")
 
 
 @dataclass
@@ -258,8 +258,8 @@ def _find_opflow_max_loadability(
     tolerance: float = 0.01,
 ) -> float | None:
     """Find maximum load scaling factor via OPFLOW binary search."""
-    from agentigrid.engine.commands import ScaleAllLoads
-    from agentigrid.engine.modifier import apply_modifications
+    from agentigrid.exago_engine.commands import ScaleAllLoads
+    from agentigrid.exago_engine.modifier import apply_modifications
 
     low = 1.0
     high = 3.0
diff --git a/agentigrid/agentigrid/engine/commands.py b/agentigrid/agentigrid/exago_engine/commands.py
similarity index 99%
rename from agentigrid/agentigrid/engine/commands.py
rename to agentigrid/agentigrid/exago_engine/commands.py
index 96e36932..14ee183f 100644
--- a/agentigrid/agentigrid/engine/commands.py
+++ b/agentigrid/agentigrid/exago_engine/commands.py
@@ -6,7 +6,7 @@
 from dataclasses import dataclass, field
 from typing import Optional, Union
 
-logger = logging.getLogger("agentigrid.engine.commands")
+logger = logging.getLogger("agentigrid.exago_engine.commands")
 
 
 @dataclass
diff --git a/agentigrid/agentigrid/engine/contingency.py b/agentigrid/agentigrid/exago_engine/contingency.py
similarity index 98%
rename from agentigrid/agentigrid/engine/contingency.py
rename to agentigrid/agentigrid/exago_engine/contingency.py
index 8c42b9a0..fabdb69b 100644
--- a/agentigrid/agentigrid/engine/contingency.py
+++ b/agentigrid/agentigrid/exago_engine/contingency.py
@@ -27,8 +27,8 @@
 from dataclasses import dataclass
 from itertools import combinations
 
-from agentigrid.engine import topology
-from agentigrid.parsers.matpower_model import Branch, MATNetwork
+from agentigrid.exago_engine import topology
+from agentigrid.exago_parsers.matpower_model import Branch, MATNetwork
 
 # Stable kind ordering for the pool total order.
 _KIND_RANK = {"branch": 0, "gen": 1, "load": 2, "shunt": 3}
@@ -202,10 +202,10 @@ def apply_mutation(net: MATNetwork, raw: object) -> tuple[MATNetwork, ChangedEle
     be parsed, or is rejected by validation.
     """
     # Imported here: modifier/commands are only needed for this step.
-    from agentigrid.engine.commands import (
+    from agentigrid.exago_engine.commands import (
         AddGeneratorAtBus, AddLoadAtBus, SetBranchStatus, SetGenStatus, SetLoad, parse_command,
     )
-    from agentigrid.engine.modifier import apply_modifications
+    from agentigrid.exago_engine.modifier import apply_modifications
 
     if not isinstance(raw, dict) or raw.get("action") not in MUTATION_ACTIONS:
         got = raw.get("action") if isinstance(raw, dict) else raw
diff --git a/agentigrid/agentigrid/engine/executor.py b/agentigrid/agentigrid/exago_engine/executor.py
similarity index 85%
rename from agentigrid/agentigrid/engine/executor.py
rename to agentigrid/agentigrid/exago_engine/executor.py
index 00003a1b..70e86cfa 100644
--- a/agentigrid/agentigrid/engine/executor.py
+++ b/agentigrid/agentigrid/exago_engine/executor.py
@@ -6,6 +6,7 @@
 import os
 import shlex
 import subprocess
+import threading
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
@@ -14,10 +15,10 @@
 from typing import Callable, Optional
 
 from agentigrid.config import ExagoConfig, OutputConfig
-from agentigrid.parsers.matpower_model import MATNetwork
-from agentigrid.parsers.matpower_writer import write_matpower
+from agentigrid.exago_parsers.matpower_model import MATNetwork
+from agentigrid.exago_parsers.matpower_writer import write_matpower
 
-logger = logging.getLogger("agentigrid.engine.executor")
+logger = logging.getLogger("agentigrid.exago_engine.executor")
 
 _THREAD_ENV_VARS = (
     "OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS",
@@ -59,6 +60,17 @@ def _default_cmd_builder(
     return cmd
 
 
+def _steady_state_cmd_builder(
+    binary: Path, input_file: Path, extra_args: list[str] | None,
+) -> list[str]:
+    """Build command for OPFLOW / PFLOW: -save_output writes the solved case
+    (opflowout.m / pflowout.m) into the run folder, where GridKit can start from it."""
+    cmd = [str(binary), "-netfile", str(input_file), "-print_output", "-save_output"]
+    if extra_args:
+        cmd.extend(extra_args)
+    return cmd
+
+
 def _tcopflow_cmd_builder(
     binary: Path, input_file: Path, extra_args: list[str] | None,
 ) -> list[str]:
@@ -79,10 +91,14 @@ def _sopflow_cmd_builder(
     return cmd
 
 
+# Solved cases written by _steady_state_cmd_builder runs (-save_output).
+SOLUTION_FILES = ("opflowout.m", "pflowout.m")
+
+
 _CMD_BUILDERS: dict[str, Callable] = {
-    "opflow": _default_cmd_builder,
+    "opflow": _steady_state_cmd_builder,
     "dcopflow": _default_cmd_builder,
-    "pflow": _default_cmd_builder,
+    "pflow": _steady_state_cmd_builder,
     "scopflow": _default_cmd_builder,
     "tcopflow": _tcopflow_cmd_builder,
     "sopflow": _sopflow_cmd_builder,
@@ -118,6 +134,44 @@ def __init__(self, exago_config: ExagoConfig, output_config: OutputConfig) -> No
         if self._env_script and not self._env_script.exists():
             logger.warning("env_script does not exist: %s", self._env_script)
 
+        # Run folders of the current batch (one agent action), in completion order.
+        self._batch: list[Path] | None = None
+        self._batch_lock = threading.Lock()
+
+    # ------------------------------------------------------------------
+    # Saved solutions (exago.save_solutions)
+    # ------------------------------------------------------------------
+
+    def begin_batch(self) -> None:
+        """Start recording the run folders of one agent action."""
+        with self._batch_lock:
+            self._batch = []
+
+    def end_batch(self) -> list[Path]:
+        """Stop recording; the batch's run folders, in completion order."""
+        with self._batch_lock:
+            dirs, self._batch = self._batch or [], None
+        return dirs
+
+    def prune_solutions(self, run_dirs: list[Path], best: Path | None = None) -> Path | None:
+        """Keep one saved solution among *run_dirs*, per ``exago.save_solutions``:
+        "best" keeps *best* if it has one, else the most recent; "newest" keeps
+        the most recent; "all" and "none" delete nothing. Only the solution
+        files are deleted; run folders and their input cases stay.
+        Returns the folder whose solution was kept (None if none was saved)."""
+        mode = self._exago.save_solutions
+        saved = [d for d in run_dirs if any((d / f).exists() for f in SOLUTION_FILES)]
+        if mode not in ("best", "newest") or not saved:
+            return None
+        kept = best if mode == "best" and best in saved else saved[-1]
+        for d in saved:
+            if d != kept:
+                for f in SOLUTION_FILES:
+                    (d / f).unlink(missing_ok=True)
+        if len(saved) > 1:
+            logger.info("Saved solutions (%s): kept %s, removed %d", mode, kept.name, len(saved) - 1)
+        return kept
+
     # ------------------------------------------------------------------
     # Public API
     # ------------------------------------------------------------------
@@ -203,6 +257,8 @@ def run(
 
         # 4. Build command
         builder = _CMD_BUILDERS.get(application, _default_cmd_builder)
+        if builder is _steady_state_cmd_builder and self._exago.save_solutions == "none":
+            builder = _default_cmd_builder
         cmd = builder(binary, input_file, extra_args)
 
         if self._exago.mpi_np > 1 and application in ("scopflow", "sopflow"):
@@ -301,6 +357,9 @@ def run(
             "succeeded" if success else "FAILED",
             elapsed, proc.returncode, len(proc.stdout),
         )
+        with self._batch_lock:
+            if self._batch is not None:
+                self._batch.append(run_dir)
 
         return SimulationResult(
             success=success,
diff --git a/agentigrid/agentigrid/engine/explore.py b/agentigrid/agentigrid/exago_engine/explore.py
similarity index 96%
rename from agentigrid/agentigrid/engine/explore.py
rename to agentigrid/agentigrid/exago_engine/explore.py
index 842ddaf9..d0df77fb 100644
--- a/agentigrid/agentigrid/engine/explore.py
+++ b/agentigrid/agentigrid/exago_engine/explore.py
@@ -6,15 +6,15 @@
 from dataclasses import dataclass, field
 from typing import Optional
 
-from agentigrid.engine.commands import ModCommand
-from agentigrid.engine.executor import SimulationResult
-from agentigrid.engine.journal import ObjectiveEntry
-from agentigrid.engine.metric_extractor import extract_all_metrics
-from agentigrid.engine.pareto import ParetoCandidate, pareto_filter
-from agentigrid.parsers.matpower_model import MATNetwork
-from agentigrid.parsers.opflow_results import OPFLOWResult
-
-logger = logging.getLogger("agentigrid.engine.explore")
+from agentigrid.exago_engine.commands import ModCommand
+from agentigrid.exago_engine.executor import SimulationResult
+from agentigrid.exago_engine.journal import ObjectiveEntry
+from agentigrid.exago_engine.metric_extractor import extract_all_metrics
+from agentigrid.exago_engine.pareto import ParetoCandidate, pareto_filter
+from agentigrid.exago_parsers.matpower_model import MATNetwork
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
+
+logger = logging.getLogger("agentigrid.exago_engine.explore")
 
 
 def _describe_command(cmd: ModCommand) -> str:
diff --git a/agentigrid/agentigrid/engine/goal_classifier.py b/agentigrid/agentigrid/exago_engine/goal_classifier.py
similarity index 99%
rename from agentigrid/agentigrid/engine/goal_classifier.py
rename to agentigrid/agentigrid/exago_engine/goal_classifier.py
index d5a39b7e..d9edf13a 100644
--- a/agentigrid/agentigrid/engine/goal_classifier.py
+++ b/agentigrid/agentigrid/exago_engine/goal_classifier.py
@@ -12,7 +12,7 @@
 import re
 from typing import Any
 
-logger = logging.getLogger("agentigrid.engine.goal_classifier")
+logger = logging.getLogger("agentigrid.exago_engine.goal_classifier")
 
 _SYSTEM_PROMPT = (
     "You are an expert power systems analyst reviewing the results of an "
diff --git a/agentigrid/agentigrid/engine/journal.py b/agentigrid/agentigrid/exago_engine/journal.py
similarity index 99%
rename from agentigrid/agentigrid/engine/journal.py
rename to agentigrid/agentigrid/exago_engine/journal.py
index c7b04539..f86d4bc5 100644
--- a/agentigrid/agentigrid/engine/journal.py
+++ b/agentigrid/agentigrid/exago_engine/journal.py
@@ -10,9 +10,9 @@
 from pathlib import Path
 from typing import Optional
 
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
-logger = logging.getLogger("agentigrid.engine.journal")
+logger = logging.getLogger("agentigrid.exago_engine.journal")
 
 # Modes that correspond to a real ExaGO solve iteration (a single scalar solve),
 # as opposed to analyze/complete control markers or sweep/explore aggregate entries.
diff --git a/agentigrid/agentigrid/engine/metric_extractor.py b/agentigrid/agentigrid/exago_engine/metric_extractor.py
similarity index 97%
rename from agentigrid/agentigrid/engine/metric_extractor.py
rename to agentigrid/agentigrid/exago_engine/metric_extractor.py
index 67b1cb54..3183673f 100644
--- a/agentigrid/agentigrid/engine/metric_extractor.py
+++ b/agentigrid/agentigrid/exago_engine/metric_extractor.py
@@ -9,9 +9,9 @@
 import logging
 from typing import Optional
 
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
-logger = logging.getLogger("agentigrid.engine.metric_extractor")
+logger = logging.getLogger("agentigrid.exago_engine.metric_extractor")
 
 
 def extract_metric(result: OPFLOWResult, metric_name: str) -> Optional[float]:
diff --git a/agentigrid/agentigrid/engine/modifier.py b/agentigrid/agentigrid/exago_engine/modifier.py
similarity index 99%
rename from agentigrid/agentigrid/engine/modifier.py
rename to agentigrid/agentigrid/exago_engine/modifier.py
index f1c0822d..0f912d2f 100644
--- a/agentigrid/agentigrid/engine/modifier.py
+++ b/agentigrid/agentigrid/exago_engine/modifier.py
@@ -8,7 +8,7 @@
 from dataclasses import dataclass, field, replace
 from pathlib import Path
 
-from agentigrid.engine.commands import (
+from agentigrid.exago_engine.commands import (
     AddGeneratorAtBus,
     AddLoadAtBus,
     ModCommand,
@@ -30,14 +30,14 @@
     SetShuntSusceptance,
     SetTapRatio,
 )
-from agentigrid.engine.validation import validate_command
-from agentigrid.parsers.matpower_model import GenCost, Generator, MATNetwork
+from agentigrid.exago_engine.validation import validate_command
+from agentigrid.exago_parsers.matpower_model import GenCost, Generator, MATNetwork
 
 _DEFAULT_PF_TAN = 0.3286  # tan(acos(0.95)) — reactive limit as fraction of MW capacity
 # Fallback mid-merit linear cost ($/MWh) when the case has no usable polynomial curves.
 _FALLBACK_GEN_COST = [0.0, 40.0, 0.0]
 
-logger = logging.getLogger("agentigrid.engine.modifier")
+logger = logging.getLogger("agentigrid.exago_engine.modifier")
 
 
 def _median_existing_cost_coeffs(net: MATNetwork) -> list[float]:
diff --git a/agentigrid/agentigrid/engine/objective_parser.py b/agentigrid/agentigrid/exago_engine/objective_parser.py
similarity index 98%
rename from agentigrid/agentigrid/engine/objective_parser.py
rename to agentigrid/agentigrid/exago_engine/objective_parser.py
index 0d9df403..10dfc1a8 100644
--- a/agentigrid/agentigrid/engine/objective_parser.py
+++ b/agentigrid/agentigrid/exago_engine/objective_parser.py
@@ -11,7 +11,7 @@
 import re
 from typing import Any
 
-logger = logging.getLogger("agentigrid.engine.objective_parser")
+logger = logging.getLogger("agentigrid.exago_engine.objective_parser")
 
 
 def build_objective_extraction_prompt(
diff --git a/agentigrid/agentigrid/engine/pareto.py b/agentigrid/agentigrid/exago_engine/pareto.py
similarity index 96%
rename from agentigrid/agentigrid/engine/pareto.py
rename to agentigrid/agentigrid/exago_engine/pareto.py
index b80a6bce..c1641c18 100644
--- a/agentigrid/agentigrid/engine/pareto.py
+++ b/agentigrid/agentigrid/exago_engine/pareto.py
@@ -5,9 +5,9 @@
 import logging
 from dataclasses import dataclass, field
 
-from agentigrid.engine.journal import ObjectiveEntry
+from agentigrid.exago_engine.journal import ObjectiveEntry
 
-logger = logging.getLogger("agentigrid.engine.pareto")
+logger = logging.getLogger("agentigrid.exago_engine.pareto")
 
 
 @dataclass
diff --git a/agentigrid/agentigrid/engine/regenerate_report.py b/agentigrid/agentigrid/exago_engine/regenerate_report.py
similarity index 97%
rename from agentigrid/agentigrid/engine/regenerate_report.py
rename to agentigrid/agentigrid/exago_engine/regenerate_report.py
index 43cbd790..a18c66fa 100644
--- a/agentigrid/agentigrid/engine/regenerate_report.py
+++ b/agentigrid/agentigrid/exago_engine/regenerate_report.py
@@ -18,18 +18,18 @@
 from typing import Any, Optional
 
 from agentigrid.config import AppConfig
-from agentigrid.engine.goal_classifier import (
+from agentigrid.exago_engine.goal_classifier import (
     build_classification_prompts,
     parse_goal_classification,
 )
-from agentigrid.engine.journal import (
+from agentigrid.exago_engine.journal import (
     JournalEntry,
     ObjectiveEntry,
     ObjectiveRegistry,
     SearchJournal,
 )
 
-logger = logging.getLogger("agentigrid.engine.regenerate_report")
+logger = logging.getLogger("agentigrid.exago_engine.regenerate_report")
 
 
 def _import_report_generator():
@@ -153,7 +153,7 @@ def build_session_stub(
     default to now(); ``benchmark_result`` is carried over from the journal.
     """
     # Imported lazily so this module has no import-time coupling to the loop.
-    from agentigrid.engine.agent_loop import SearchSession
+    from agentigrid.exago_engine.agent_loop import SearchSession
 
     now = datetime.now().isoformat()
     return SearchSession(
diff --git a/agentigrid/agentigrid/engine/relief.py b/agentigrid/agentigrid/exago_engine/relief.py
similarity index 98%
rename from agentigrid/agentigrid/engine/relief.py
rename to agentigrid/agentigrid/exago_engine/relief.py
index ddc732cb..44b3b07e 100644
--- a/agentigrid/agentigrid/engine/relief.py
+++ b/agentigrid/agentigrid/exago_engine/relief.py
@@ -31,10 +31,10 @@
 from dataclasses import dataclass, field
 from typing import Callable, Optional
 
-from agentigrid.engine import sweep_metrics, topology
-from agentigrid.engine.commands import parse_command
-from agentigrid.engine.modifier import apply_modifications
-from agentigrid.parsers.matpower_model import MATNetwork
+from agentigrid.exago_engine import sweep_metrics, topology
+from agentigrid.exago_engine.commands import parse_command
+from agentigrid.exago_engine.modifier import apply_modifications
+from agentigrid.exago_parsers.matpower_model import MATNetwork
 
 # Priority order (highest first) and the canonical measure names.
 MEASURE_ORDER = (
diff --git a/agentigrid/agentigrid/engine/reserve.py b/agentigrid/agentigrid/exago_engine/reserve.py
similarity index 100%
rename from agentigrid/agentigrid/engine/reserve.py
rename to agentigrid/agentigrid/exago_engine/reserve.py
diff --git a/agentigrid/agentigrid/engine/schema_description.py b/agentigrid/agentigrid/exago_engine/schema_description.py
similarity index 100%
rename from agentigrid/agentigrid/engine/schema_description.py
rename to agentigrid/agentigrid/exago_engine/schema_description.py
diff --git a/agentigrid/agentigrid/engine/session_io.py b/agentigrid/agentigrid/exago_engine/session_io.py
similarity index 97%
rename from agentigrid/agentigrid/engine/session_io.py
rename to agentigrid/agentigrid/exago_engine/session_io.py
index 985a6326..cfd65e4b 100644
--- a/agentigrid/agentigrid/engine/session_io.py
+++ b/agentigrid/agentigrid/exago_engine/session_io.py
@@ -9,14 +9,14 @@
 from pathlib import Path
 from typing import Any, Optional
 
-from agentigrid.engine.journal import (
+from agentigrid.exago_engine.journal import (
     JournalEntry, ObjectiveEntry, ObjectiveRegistry, SearchJournal,
 )
-from agentigrid.parsers.matpower_model import MATNetwork
-from agentigrid.parsers.matpower_writer import write_matpower
-from agentigrid.parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.matpower_model import MATNetwork
+from agentigrid.exago_parsers.matpower_writer import write_matpower
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
 
-logger = logging.getLogger("agentigrid.engine.session_io")
+logger = logging.getLogger("agentigrid.exago_engine.session_io")
 
 SESSION_FORMAT_VERSION = "1.1"
 
diff --git a/agentigrid/agentigrid/engine/sweep_metrics.py b/agentigrid/agentigrid/exago_engine/sweep_metrics.py
similarity index 100%
rename from agentigrid/agentigrid/engine/sweep_metrics.py
rename to agentigrid/agentigrid/exago_engine/sweep_metrics.py
diff --git a/agentigrid/agentigrid/engine/topology.py b/agentigrid/agentigrid/exago_engine/topology.py
similarity index 99%
rename from agentigrid/agentigrid/engine/topology.py
rename to agentigrid/agentigrid/exago_engine/topology.py
index d62bc625..f3fcb052 100644
--- a/agentigrid/agentigrid/engine/topology.py
+++ b/agentigrid/agentigrid/exago_engine/topology.py
@@ -16,7 +16,7 @@
 if TYPE_CHECKING:
     pass
 
-from agentigrid.parsers.matpower_model import Branch, MATNetwork
+from agentigrid.exago_parsers.matpower_model import Branch, MATNetwork
 
 
 # ---------------------------------------------------------------------------
diff --git a/agentigrid/agentigrid/engine/validation.py b/agentigrid/agentigrid/exago_engine/validation.py
similarity index 98%
rename from agentigrid/agentigrid/engine/validation.py
rename to agentigrid/agentigrid/exago_engine/validation.py
index 5be75b29..8d8aa382 100644
--- a/agentigrid/agentigrid/engine/validation.py
+++ b/agentigrid/agentigrid/exago_engine/validation.py
@@ -5,7 +5,7 @@
 import logging
 from dataclasses import dataclass, field
 
-from agentigrid.engine.commands import (
+from agentigrid.exago_engine.commands import (
     AddGeneratorAtBus,
     AddLoadAtBus,
     ModCommand,
@@ -25,9 +25,9 @@
     SetShuntSusceptance,
     SetTapRatio,
 )
-from agentigrid.parsers.matpower_model import MATNetwork
+from agentigrid.exago_parsers.matpower_model import MATNetwork
 
-logger = logging.getLogger("agentigrid.engine.validation")
+logger = logging.getLogger("agentigrid.exago_engine.validation")
 
 
 @dataclass
diff --git a/agentigrid/agentigrid/parsers/__init__.py b/agentigrid/agentigrid/exago_parsers/__init__.py
similarity index 86%
rename from agentigrid/agentigrid/parsers/__init__.py
rename to agentigrid/agentigrid/exago_parsers/__init__.py
index 68c01100..077b7433 100644
--- a/agentigrid/agentigrid/parsers/__init__.py
+++ b/agentigrid/agentigrid/exago_parsers/__init__.py
@@ -4,55 +4,55 @@
 
 import logging
 
-from agentigrid.parsers.matpower_model import (
+from agentigrid.exago_parsers.matpower_model import (
     Branch,
     Bus,
     GenCost,
     Generator,
     MATNetwork,
 )
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.matpower_writer import write_matpower
-from agentigrid.parsers.network_metadata import network_metadata
-from agentigrid.parsers.network_summary import network_summary
-from agentigrid.parsers.opflow_parser import parse_opflow_output, parse_simulation_result
-from agentigrid.parsers.opflow_results import (
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.matpower_writer import write_matpower
+from agentigrid.exago_parsers.network_metadata import network_metadata
+from agentigrid.exago_parsers.network_summary import network_summary
+from agentigrid.exago_parsers.opflow_parser import parse_opflow_output, parse_simulation_result
+from agentigrid.exago_parsers.opflow_results import (
     BranchResult,
     BusResult,
     GenResult,
     OPFLOWResult,
 )
-from agentigrid.parsers.results_summary import results_summary
-from agentigrid.parsers.dcopflow_summary import dcopflow_results_summary
-from agentigrid.parsers.scopflow_parser import (
+from agentigrid.exago_parsers.results_summary import results_summary
+from agentigrid.exago_parsers.dcopflow_summary import dcopflow_results_summary
+from agentigrid.exago_parsers.scopflow_parser import (
     parse_scopflow_output,
     parse_scopflow_simulation_result,
 )
-from agentigrid.parsers.scopflow_summary import scopflow_results_summary
-from agentigrid.parsers.tcopflow_parser import (
+from agentigrid.exago_parsers.scopflow_summary import scopflow_results_summary
+from agentigrid.exago_parsers.tcopflow_parser import (
     parse_tcopflow_output,
     parse_tcopflow_simulation_result,
     parse_tcopflow_period_files,
     parse_tcopflow_metadata,
 )
-from agentigrid.parsers.tcopflow_summary import tcopflow_results_summary
-from agentigrid.parsers.sopflow_parser import (
+from agentigrid.exago_parsers.tcopflow_summary import tcopflow_results_summary
+from agentigrid.exago_parsers.sopflow_parser import (
     parse_sopflow_output,
     parse_sopflow_simulation_result,
 )
-from agentigrid.parsers.sopflow_summary import sopflow_results_summary
-from agentigrid.parsers.sopflow_dispatch import (
+from agentigrid.exago_parsers.sopflow_summary import sopflow_results_summary
+from agentigrid.exago_parsers.sopflow_dispatch import (
     compute_wind_absorption,
     compute_scenario_voltage_spread,
     all_scenarios_converged,
 )
-from agentigrid.parsers.pflow_parser import (
+from agentigrid.exago_parsers.pflow_parser import (
     parse_pflow_output,
     parse_pflow_simulation_result,
 )
-from agentigrid.parsers.pflow_summary import pflow_results_summary
+from agentigrid.exago_parsers.pflow_summary import pflow_results_summary
 
-_logger = logging.getLogger("agentigrid.parsers")
+_logger = logging.getLogger("agentigrid.exago_parsers")
 
 # Applications that use the OPFLOW parser directly (identical output format)
 _OPFLOW_COMPATIBLE_APPS = {"opflow", "dcopflow"}
diff --git a/agentigrid/agentigrid/parsers/dcopflow_summary.py b/agentigrid/agentigrid/exago_parsers/dcopflow_summary.py
similarity index 98%
rename from agentigrid/agentigrid/parsers/dcopflow_summary.py
rename to agentigrid/agentigrid/exago_parsers/dcopflow_summary.py
index ab7fb46b..56188f22 100644
--- a/agentigrid/agentigrid/parsers/dcopflow_summary.py
+++ b/agentigrid/agentigrid/exago_parsers/dcopflow_summary.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 
 def dcopflow_results_summary(result: OPFLOWResult) -> str:
diff --git a/agentigrid/agentigrid/parsers/matpower_model.py b/agentigrid/agentigrid/exago_parsers/matpower_model.py
similarity index 100%
rename from agentigrid/agentigrid/parsers/matpower_model.py
rename to agentigrid/agentigrid/exago_parsers/matpower_model.py
diff --git a/agentigrid/agentigrid/parsers/matpower_parser.py b/agentigrid/agentigrid/exago_parsers/matpower_parser.py
similarity index 98%
rename from agentigrid/agentigrid/parsers/matpower_parser.py
rename to agentigrid/agentigrid/exago_parsers/matpower_parser.py
index dc381b0b..49576d1d 100644
--- a/agentigrid/agentigrid/parsers/matpower_parser.py
+++ b/agentigrid/agentigrid/exago_parsers/matpower_parser.py
@@ -6,7 +6,7 @@
 import re
 from pathlib import Path
 
-from agentigrid.parsers.matpower_model import (
+from agentigrid.exago_parsers.matpower_model import (
     Branch,
     Bus,
     GenCost,
@@ -14,7 +14,7 @@
     MATNetwork,
 )
 
-logger = logging.getLogger("agentigrid.parsers.matpower")
+logger = logging.getLogger("agentigrid.exago_parsers.matpower")
 
 # ---------------------------------------------------------------------------
 # Regex patterns
diff --git a/agentigrid/agentigrid/parsers/matpower_writer.py b/agentigrid/agentigrid/exago_parsers/matpower_writer.py
similarity index 97%
rename from agentigrid/agentigrid/parsers/matpower_writer.py
rename to agentigrid/agentigrid/exago_parsers/matpower_writer.py
index 10bef308..ca787f7f 100644
--- a/agentigrid/agentigrid/parsers/matpower_writer.py
+++ b/agentigrid/agentigrid/exago_parsers/matpower_writer.py
@@ -5,7 +5,7 @@
 import logging
 from pathlib import Path
 
-from agentigrid.parsers.matpower_model import (
+from agentigrid.exago_parsers.matpower_model import (
     Branch,
     Bus,
     GenCost,
@@ -13,7 +13,7 @@
     MATNetwork,
 )
 
-logger = logging.getLogger("agentigrid.parsers.matpower")
+logger = logging.getLogger("agentigrid.exago_parsers.matpower")
 
 
 def _fmt(value: float) -> str:
diff --git a/agentigrid/agentigrid/parsers/network_metadata.py b/agentigrid/agentigrid/exago_parsers/network_metadata.py
similarity index 98%
rename from agentigrid/agentigrid/parsers/network_metadata.py
rename to agentigrid/agentigrid/exago_parsers/network_metadata.py
index 50fabc68..0bc0429c 100644
--- a/agentigrid/agentigrid/parsers/network_metadata.py
+++ b/agentigrid/agentigrid/exago_parsers/network_metadata.py
@@ -11,7 +11,7 @@
 
 from __future__ import annotations
 
-from agentigrid.parsers.matpower_model import MATNetwork
+from agentigrid.exago_parsers.matpower_model import MATNetwork
 
 
 _UNIFORM_COST_WARNING_TEMPLATE = (
diff --git a/agentigrid/agentigrid/parsers/network_summary.py b/agentigrid/agentigrid/exago_parsers/network_summary.py
similarity index 98%
rename from agentigrid/agentigrid/parsers/network_summary.py
rename to agentigrid/agentigrid/exago_parsers/network_summary.py
index f9950b5d..96c45438 100644
--- a/agentigrid/agentigrid/parsers/network_summary.py
+++ b/agentigrid/agentigrid/exago_parsers/network_summary.py
@@ -4,7 +4,7 @@
 
 from collections import Counter
 
-from agentigrid.parsers.matpower_model import MATNetwork
+from agentigrid.exago_parsers.matpower_model import MATNetwork
 
 
 _BUS_TYPE_NAMES = {1: "PQ", 2: "PV", 3: "Ref", 4: "Isolated"}
diff --git a/agentigrid/agentigrid/parsers/opflow_parser.py b/agentigrid/agentigrid/exago_parsers/opflow_parser.py
similarity index 99%
rename from agentigrid/agentigrid/parsers/opflow_parser.py
rename to agentigrid/agentigrid/exago_parsers/opflow_parser.py
index 74c15013..09973560 100644
--- a/agentigrid/agentigrid/parsers/opflow_parser.py
+++ b/agentigrid/agentigrid/exago_parsers/opflow_parser.py
@@ -6,14 +6,14 @@
 import re
 from typing import Optional
 
-from agentigrid.parsers.opflow_results import (
+from agentigrid.exago_parsers.opflow_results import (
     BranchResult,
     BusResult,
     GenResult,
     OPFLOWResult,
 )
 
-logger = logging.getLogger("agentigrid.parsers.opflow")
+logger = logging.getLogger("agentigrid.exago_parsers.opflow")
 
 # ---------------------------------------------------------------------------
 # Regex patterns
diff --git a/agentigrid/agentigrid/parsers/opflow_results.py b/agentigrid/agentigrid/exago_parsers/opflow_results.py
similarity index 100%
rename from agentigrid/agentigrid/parsers/opflow_results.py
rename to agentigrid/agentigrid/exago_parsers/opflow_results.py
diff --git a/agentigrid/agentigrid/parsers/pflow_parser.py b/agentigrid/agentigrid/exago_parsers/pflow_parser.py
similarity index 98%
rename from agentigrid/agentigrid/parsers/pflow_parser.py
rename to agentigrid/agentigrid/exago_parsers/pflow_parser.py
index c37efcbf..2a2b15ac 100644
--- a/agentigrid/agentigrid/parsers/pflow_parser.py
+++ b/agentigrid/agentigrid/exago_parsers/pflow_parser.py
@@ -6,15 +6,15 @@
 import re
 from typing import Optional
 
-from agentigrid.parsers.opflow_parser import _is_near_boundary
-from agentigrid.parsers.opflow_results import (
+from agentigrid.exago_parsers.opflow_parser import _is_near_boundary
+from agentigrid.exago_parsers.opflow_results import (
     BranchResult,
     BusResult,
     GenResult,
     OPFLOWResult,
 )
 
-logger = logging.getLogger("agentigrid.parsers.pflow")
+logger = logging.getLogger("agentigrid.exago_parsers.pflow")
 
 _PFLOW_ITERATIONS_RE = re.compile(r"Number of iterations\s+(\d+)", re.MULTILINE)
 _PFLOW_SOLVE_TIME_RE = re.compile(r"Solve Time \(sec\)\s+([\d.]+)", re.MULTILINE)
diff --git a/agentigrid/agentigrid/parsers/pflow_summary.py b/agentigrid/agentigrid/exago_parsers/pflow_summary.py
similarity index 98%
rename from agentigrid/agentigrid/parsers/pflow_summary.py
rename to agentigrid/agentigrid/exago_parsers/pflow_summary.py
index f788058d..56bc0f6f 100644
--- a/agentigrid/agentigrid/parsers/pflow_summary.py
+++ b/agentigrid/agentigrid/exago_parsers/pflow_summary.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 
 def pflow_results_summary(
diff --git a/agentigrid/agentigrid/parsers/results_summary.py b/agentigrid/agentigrid/exago_parsers/results_summary.py
similarity index 97%
rename from agentigrid/agentigrid/parsers/results_summary.py
rename to agentigrid/agentigrid/exago_parsers/results_summary.py
index 97b8a466..dc093a10 100644
--- a/agentigrid/agentigrid/parsers/results_summary.py
+++ b/agentigrid/agentigrid/exago_parsers/results_summary.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 
 def results_summary(result: OPFLOWResult) -> str:
diff --git a/agentigrid/agentigrid/parsers/scopflow_parser.py b/agentigrid/agentigrid/exago_parsers/scopflow_parser.py
similarity index 94%
rename from agentigrid/agentigrid/parsers/scopflow_parser.py
rename to agentigrid/agentigrid/exago_parsers/scopflow_parser.py
index 289057f5..d7980fd0 100644
--- a/agentigrid/agentigrid/parsers/scopflow_parser.py
+++ b/agentigrid/agentigrid/exago_parsers/scopflow_parser.py
@@ -6,10 +6,10 @@
 import re
 from typing import Optional
 
-from agentigrid.parsers.opflow_parser import parse_opflow_output, _is_marginal_exit, _is_near_boundary
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.opflow_parser import parse_opflow_output, _is_marginal_exit, _is_near_boundary
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
-logger = logging.getLogger("agentigrid.parsers.scopflow")
+logger = logging.getLogger("agentigrid.exago_parsers.scopflow")
 
 _NUM_CONTINGENCIES_RE = re.compile(r"^Number of contingencies\s+(\d+)", re.MULTILINE)
 _MULTI_PERIOD_RE = re.compile(r"^Multi-period contingencies\?\s+(\S+)", re.MULTILINE)
diff --git a/agentigrid/agentigrid/parsers/scopflow_summary.py b/agentigrid/agentigrid/exago_parsers/scopflow_summary.py
similarity index 98%
rename from agentigrid/agentigrid/parsers/scopflow_summary.py
rename to agentigrid/agentigrid/exago_parsers/scopflow_summary.py
index dde6d795..f171c610 100644
--- a/agentigrid/agentigrid/parsers/scopflow_summary.py
+++ b/agentigrid/agentigrid/exago_parsers/scopflow_summary.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 
 def scopflow_results_summary(result: OPFLOWResult, num_contingencies: int = 0) -> str:
diff --git a/agentigrid/agentigrid/parsers/sopflow_dispatch.py b/agentigrid/agentigrid/exago_parsers/sopflow_dispatch.py
similarity index 98%
rename from agentigrid/agentigrid/parsers/sopflow_dispatch.py
rename to agentigrid/agentigrid/exago_parsers/sopflow_dispatch.py
index 8e626554..38d2be91 100644
--- a/agentigrid/agentigrid/parsers/sopflow_dispatch.py
+++ b/agentigrid/agentigrid/exago_parsers/sopflow_dispatch.py
@@ -17,9 +17,9 @@
 import statistics
 from pathlib import Path
 
-from agentigrid.parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
 
-logger = logging.getLogger("agentigrid.parsers.sopflow_dispatch")
+logger = logging.getLogger("agentigrid.exago_parsers.sopflow_dispatch")
 
 # Scenario CSV columns that are not wind generators.
 _NON_WIND_COLUMNS = {"scenario_nr", "sim_timestamp", "weight"}
diff --git a/agentigrid/agentigrid/parsers/sopflow_parser.py b/agentigrid/agentigrid/exago_parsers/sopflow_parser.py
similarity index 97%
rename from agentigrid/agentigrid/parsers/sopflow_parser.py
rename to agentigrid/agentigrid/exago_parsers/sopflow_parser.py
index 5d99d663..ca359690 100644
--- a/agentigrid/agentigrid/parsers/sopflow_parser.py
+++ b/agentigrid/agentigrid/exago_parsers/sopflow_parser.py
@@ -7,11 +7,11 @@
 from pathlib import Path
 from typing import Optional
 
-from agentigrid.parsers.opflow_parser import parse_opflow_output, _is_marginal_exit, _is_near_boundary
-from agentigrid.parsers.opflow_results import OPFLOWResult
-from agentigrid.parsers.sopflow_dispatch import all_scenarios_converged
+from agentigrid.exago_parsers.opflow_parser import parse_opflow_output, _is_marginal_exit, _is_near_boundary
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.sopflow_dispatch import all_scenarios_converged
 
-logger = logging.getLogger("agentigrid.parsers.sopflow")
+logger = logging.getLogger("agentigrid.exago_parsers.sopflow")
 
 _NUM_SCENARIOS_RE = re.compile(r"^Number of scenarios\s+(\d+)", re.MULTILINE)
 _MULTI_CONTINGENCY_RE = re.compile(r"^Multi-contingency scenarios\?\s+(\S+)", re.MULTILINE)
diff --git a/agentigrid/agentigrid/parsers/sopflow_summary.py b/agentigrid/agentigrid/exago_parsers/sopflow_summary.py
similarity index 98%
rename from agentigrid/agentigrid/parsers/sopflow_summary.py
rename to agentigrid/agentigrid/exago_parsers/sopflow_summary.py
index fc50ee91..aa658060 100644
--- a/agentigrid/agentigrid/parsers/sopflow_summary.py
+++ b/agentigrid/agentigrid/exago_parsers/sopflow_summary.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 
 def sopflow_results_summary(
diff --git a/agentigrid/agentigrid/parsers/tcopflow_parser.py b/agentigrid/agentigrid/exago_parsers/tcopflow_parser.py
similarity index 97%
rename from agentigrid/agentigrid/parsers/tcopflow_parser.py
rename to agentigrid/agentigrid/exago_parsers/tcopflow_parser.py
index fa4092e0..dc14d40a 100644
--- a/agentigrid/agentigrid/parsers/tcopflow_parser.py
+++ b/agentigrid/agentigrid/exago_parsers/tcopflow_parser.py
@@ -7,11 +7,11 @@
 from pathlib import Path
 from typing import Optional
 
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.opflow_parser import parse_opflow_output, _is_marginal_exit
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.opflow_parser import parse_opflow_output, _is_marginal_exit
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
-logger = logging.getLogger("agentigrid.parsers.tcopflow")
+logger = logging.getLogger("agentigrid.exago_parsers.tcopflow")
 
 _DURATION_RE = re.compile(r"^Duration \(minutes\)\s+([\d.]+)", re.MULTILINE)
 _TIMESTEP_RE = re.compile(r"^Time-step \(minutes\)\s+([\d.]+)", re.MULTILINE)
diff --git a/agentigrid/agentigrid/parsers/tcopflow_summary.py b/agentigrid/agentigrid/exago_parsers/tcopflow_summary.py
similarity index 99%
rename from agentigrid/agentigrid/parsers/tcopflow_summary.py
rename to agentigrid/agentigrid/exago_parsers/tcopflow_summary.py
index 7975e84f..ae7c80a8 100644
--- a/agentigrid/agentigrid/parsers/tcopflow_summary.py
+++ b/agentigrid/agentigrid/exago_parsers/tcopflow_summary.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 # Cap the per-period table so a long horizon cannot blow up the LLM prompt. The
 # aggregated-metrics block above the table already spans ALL periods (min/max
diff --git a/agentigrid/agentigrid/gridkit_engine/agent_loop.py b/agentigrid/agentigrid/gridkit_engine/agent_loop.py
index f5e4521e..3b350d77 100644
--- a/agentigrid/agentigrid/gridkit_engine/agent_loop.py
+++ b/agentigrid/agentigrid/gridkit_engine/agent_loop.py
@@ -3,6 +3,10 @@
 Mirrors the ExaGO loop: the LLM only picks one JSON action per turn; AgentiGrid
 builds the case copy, runs GridKit, applies the named checks and writes the
 verdict. Actions: ``fault_screen`` and ``complete``.
+
+A fault screen starts from the GridKit case's own operating point or, with
+``start_from: latest_steady_state``, from the most recent ExaGO solution
+(see from_exago.py); either start must pass a no-fault run first.
 """
 
 from __future__ import annotations
@@ -19,14 +23,20 @@
 from agentigrid.config import AppConfig
 from agentigrid.gridkit_engine import criteria
 from agentigrid.gridkit_engine.commands import FaultStudy, RecordVariables, parse_fault_study
-from agentigrid.gridkit_engine.executor import RunJob, RunResult, run_many, run_one
+from agentigrid.gridkit_engine.executor import RunJob, RunResult, run_contingency, run_many, run_one
+from agentigrid.gridkit_engine.from_exago import (
+    SteadyStateError, SteadyStateSource, build_from_exago, find_latest_steady_state,
+    goal_wants_steady_state,
+)
 from agentigrid.gridkit_engine.journal import GridkitJournal, JournalEntry, outcome_row
 from agentigrid.gridkit_engine.modifier import apply_modifications, prepare_fault_case, write_case
 from agentigrid.gridkit_engine.schema_description import command_schema_text
 from agentigrid.gridkit_engine.settings import GridkitSettings
 from agentigrid.gridkit_engine.sweep_metrics import FaultOutcome, run_checks, screen_verdict
 from agentigrid.gridkit_engine.validation import validate_fault_study
-from agentigrid.gridkit_parsers.case_parser import MACHINE_CLASSES, create_element_map, load_case
+from agentigrid.gridkit_parsers.case_parser import (
+    MACHINE_CLASSES, build_element_map, create_element_map, load_case,
+)
 from agentigrid.gridkit_parsers.network_summary import network_summary
 from agentigrid.gridkit_parsers.results_parser import read_results
 from agentigrid.prompts.gridkit import build_system_prompt
@@ -51,6 +61,18 @@ class GridkitSession:
     total_prompt_tokens: int = 0
     total_completion_tokens: int = 0
     screens: list[str] = field(default_factory=list)   # verdict lines, in order
+    steady_state: Optional[str] = None                  # ExaGO source, when started from it
+
+
+@dataclass
+class _Start:
+    """An operating point fault screens can start from."""
+
+    case: Optional[dict]          # None when it could not be built
+    emap: Optional[dict]
+    label: str                    # for verdicts and prompts
+    ok: bool                      # built, and its no-fault run solved and stayed steady
+    text: str                     # how it was built and what the no-fault run showed
 
 
 class GridkitAgentLoop:
@@ -69,6 +91,7 @@ def __init__(
         self._backend = backend
         self._quiet = quiet
         self._screen_cache: dict[str, tuple[int, str]] = {}
+        self._starts: dict[str, _Start] = {}     # by FaultStudy.start_from
 
     def _print(self, msg: str) -> None:
         """Print progress message unless quiet mode is enabled."""
@@ -78,7 +101,11 @@ def _print(self, msg: str) -> None:
             logger.info(msg)
 
     # ------------------------------------------------------------------
-    def run(self, case_file: Path | str, goal: str) -> GridkitSession:
+    def run(self, case_file: Path | str, goal: str,
+            steady_state: Optional[SteadyStateSource] = None) -> GridkitSession:
+        """Run the study on *case_file*. With *steady_state*, the case's dynamic
+        models start from that ExaGO solution (written as from_exago.case.json in
+        the session folder) instead of the case's own operating point."""
         case_file = Path(case_file)
         binary = self._settings.dynamic_simulation
         if not binary.exists():
@@ -88,22 +115,48 @@ def run(self, case_file: Path | str, goal: str) -> GridkitSession:
             )
         stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         session_dir = self._settings.workdir / f"session_{stamp}"
+        self._goal = goal
+        self._source_case_file = case_file
+        source_text = None
+        if steady_state is not None:
+            case, notes = build_from_exago(load_case(case_file), steady_state)
+            case_file = write_case(case, session_dir / "from_exago.case.json")
+            source_text = "\n".join([f"Operating point: {steady_state.describe()}.",
+                                      *(f"  {n}" for n in notes)])
         self._case = load_case(case_file)
         self._emap, _ = create_element_map(case_file, session_dir)
         self._case_name = self._emap.get("case_name") or case_file.stem
         self._session_dir = session_dir
         self._journal = GridkitJournal(goal, case_file, session_dir)
         session = GridkitSession(goal=goal, case_file=case_file, session_dir=session_dir)
+        self._session = session
+        if source_text:
+            session.steady_state = steady_state.describe()
+            self._journal.add(JournalEntry(0, "steady_state", "operating point from ExaGO",
+                                           result_text=source_text, run_dir=str(steady_state.run_dir)))
+            self._print(f"[Session] {source_text}")
         self._print(f"[Session] {self._case_name}: {self._emap['counts']['buses']} buses, "
                     f"{len(self._emap['machines'])} machines -> {session_dir}")
 
-        base_text, base_ok = self._run_base_case()
+        base_text, base_ok = self._run_base_case(self._case, self._emap,
+                                                 session_dir / "iter_000_base")
+        if source_text:
+            base_text = f"{source_text}\n{base_text}"
+        # With an ExaGO start given up front (--from-exago), both start_from
+        # values mean that start.
+        start = _Start(self._case, self._emap,
+                       _exago_label(steady_state) if steady_state else "the GridKit case's operating point",
+                       base_ok, base_text)
+        self._starts = {"case": start}
+        if steady_state is not None:
+            self._starts["latest_steady_state"] = start
         if not base_ok:
             session.termination_reason = "base_case_failed"
             return self._finalize(session)
 
         system_prompt = build_system_prompt(
-            command_schema_text(), network_summary(self._emap), base_text,
+            command_schema_text(self._settings.fault_start_s, self._settings.tmax_s),
+            network_summary(self._emap), base_text,
         )
         latest: Optional[str] = None
         feedback: Optional[str] = None
@@ -149,18 +202,19 @@ def run(self, case_file: Path | str, goal: str) -> GridkitSession:
         return self._finalize(session)
 
     # ------------------------------------------------------------------
-    def _run_base_case(self) -> tuple[str, bool]:
-        """No-fault run of the case copy: it must solve and stay still."""
-        run_dir = self._session_dir / "iter_000_base"
+    def _run_base_case(self, case: dict, emap: dict, run_dir: Path,
+                       iteration: int = 0, what: str = "no fault") -> tuple[str, bool]:
+        """No-fault run of a copy of *case*: it must solve and stay still."""
         work, report = apply_modifications(
-            self._case, [RecordVariables(machines=["delta", "omega"], buses=["Vm"])], self._emap,
+            case, [RecordVariables(machines=["delta", "omega"], buses=["Vm"])], emap,
         )
         case_path = write_case(work, run_dir / "case.json")
-        job = RunJob(run_dir, case_path, tmax_s=criteria.SIM_LENGTH_S, dt_monitor_s=0.01)
-        self._print(f"[Iter 0] Base case: no fault, {criteria.SIM_LENGTH_S:g} s ...")
+        job = RunJob(run_dir, case_path, tmax_s=self._settings.tmax_s,
+                     dt_monitor_s=self._settings.dt_monitor_s)
+        self._print(f"[Iter {iteration}] Base case: {what}, {self._settings.tmax_s:g} s ...")
         res = run_one(job, self._settings)
         if res.status.solved:
-            series = read_results(res.csv_path, self._emap)
+            series = read_results(res.csv_path, emap)
             steady = criteria.check_steady_state(
                 series.t, series.device_variable("delta", MACHINE_CLASSES), series.bus_variable("Vm"),
             )
@@ -171,13 +225,44 @@ def _run_base_case(self) -> tuple[str, bool]:
             text = f"GridKit base case did not solve: {res.status.reason}."
         if not ok:
             text += " Fault screens are not meaningful until the base case solves and stays steady."
-        self._print(f"[Iter 0] {text}")
+        self._print(f"[Iter {iteration}] {text}")
         self._journal.add(JournalEntry(
-            0, "base_case", "no fault", verdict=text, result_text=text,
+            iteration, "base_case", what, verdict=text, result_text=text,
             elapsed_s=res.elapsed_s, run_dir=str(run_dir),
         ))
         return text, ok
 
+    def _start(self, start_from: str, iteration: int) -> _Start:
+        """The operating point a screen asked for, built (and checked) once."""
+        if start_from in self._starts:
+            return self._starts[start_from]
+        # Only "latest_steady_state" gets here: the most recent ExaGO solution
+        # applied to the GridKit case's dynamic models.
+        try:
+            source = find_latest_steady_state(self._settings.exago_workdir)
+            case, notes = build_from_exago(load_case(self._source_case_file), source)
+        except SteadyStateError as exc:
+            text = f"The most recent ExaGO steady state cannot be used: {exc}"
+            start = _Start(None, None, "the latest ExaGO steady state", False, text)
+            self._journal.add(JournalEntry(iteration, "steady_state", "latest ExaGO steady state",
+                                           verdict=text, result_text=text))
+            self._print(f"[Iter {iteration}] {text}")
+            self._starts[start_from] = start
+            return start
+        path = write_case(case, self._session_dir / "from_exago.case.json")
+        emap = build_element_map(case, path)
+        source_text = "\n".join([f"Operating point: {source.describe()}.", *(f"  {n}" for n in notes)])
+        self._journal.add(JournalEntry(iteration, "steady_state", "operating point from ExaGO",
+                                       result_text=source_text, run_dir=str(source.run_dir)))
+        self._print(f"[Iter {iteration}] {source_text}")
+        base_text, ok = self._run_base_case(
+            case, emap, self._session_dir / f"iter_{iteration:03d}_steady_state_base",
+            iteration, "no fault, from the latest ExaGO steady state",
+        )
+        start = _Start(case, emap, _exago_label(source), ok, f"{source_text}\n{base_text}")
+        self._starts[start_from] = start
+        return start
+
     def _user_prompt(self, goal: str, latest: Optional[str], feedback: Optional[str], iteration: int) -> str:
         parts = [f"GOAL: {goal}", "", "HISTORY", self._journal.digest() or "(none)"]
         if latest:
@@ -193,11 +278,32 @@ def _handle_fault_screen(self, iteration: int, data: dict) -> tuple[Optional[str
         """Returns (result text for the LLM, error feedback)."""
         description = data.get("description", "fault screen")
         try:
-            study = parse_fault_study(data)
+            study = parse_fault_study(data, self._settings.study_defaults())
         except ValueError as exc:
             self._journal.add(JournalEntry(iteration, "error", str(exc), request=data))
             return None, str(exc)
-        check = validate_fault_study(study, self._emap)
+        if study.start_from == "case" and goal_wants_steady_state(self._goal) \
+                and "latest_steady_state" not in self._starts:
+            msg = ('fault_screen rejected: the goal asks for the most recent steady state, '
+                   'so set "start_from": "latest_steady_state".')
+            self._journal.add(JournalEntry(iteration, "error", msg, request=data))
+            return None, msg
+        ca = study.application == "ContingencyAnalysis"
+        if ca and not self._settings.contingency_analysis.exists():
+            msg = (f"fault_screen rejected: GridKit ContingencyAnalysis not found at "
+                   f"{self._settings.contingency_analysis}; use DynamicSimulation.")
+            self._journal.add(JournalEntry(iteration, "error", msg, request=data))
+            return None, msg
+        start = self._start(study.start_from, iteration)
+        if not start.ok:
+            text = (f"The fault screen was NOT run: {start.label} is not usable.\n{start.text}")
+            self._journal.add(JournalEntry(iteration, "fault_screen", f"{description} (not run)",
+                                           request=data, verdict=text.splitlines()[0],
+                                           result_text=text))
+            return text, None
+        if study.start_from == "latest_steady_state" and not self._session.steady_state:
+            self._session.steady_state = start.label
+        check = validate_fault_study(study, start.emap)
         if not check.valid:
             msg = "fault_screen rejected: " + "; ".join(check.errors)
             self._journal.add(JournalEntry(iteration, "error", msg, request=data))
@@ -214,7 +320,8 @@ def _handle_fault_screen(self, iteration: int, data: dict) -> tuple[Optional[str
             return text, None
 
         iter_dir = self._session_dir / f"iter_{iteration:03d}"
-        work, wmap, fault_ids, report = prepare_fault_case(self._case, study, self._emap)
+        work, wmap, fault_ids, report = prepare_fault_case(start.case, study, start.emap,
+                                                           only_study_faults=ca)
         if report.errors:
             msg = "fault_screen could not build the case copy: " + "; ".join(report.errors)
             self._journal.add(JournalEntry(iteration, "error", msg, request=data))
@@ -223,22 +330,26 @@ def _handle_fault_screen(self, iteration: int, data: dict) -> tuple[Optional[str
         (iter_dir / "element_map.json").write_text(json.dumps(wmap, indent=1))
 
         clear = study.clear_time_s()
+        device_ids = {f["element_id"]: f["id"] for f in wmap["bus_faults"]}
         jobs = [
-            RunJob(iter_dir / f"bus_{bus}", case_path, study.tmax_s, study.dt_monitor_s,
-                   element_id=eid, start_s=study.start_s, clear_s=clear, bus=bus)
+            RunJob(iter_dir / ("contingency" if ca else f"bus_{bus}"), case_path,
+                   study.tmax_s, study.dt_monitor_s, element_id=eid, start_s=study.start_s,
+                   clear_s=clear, bus=bus, fault_id=device_ids.get(eid))
             for bus, eid in fault_ids.items()
         ]
-        self._print(f'[Iter {iteration}] fault_screen "{description}": {len(jobs)} bus faults, '
-                    f"{self._settings.resolved_workers(len(jobs))} at a time ...")
+        how = ("ContingencyAnalysis, one process" if ca
+               else f"{self._settings.resolved_workers(len(jobs))} at a time")
+        self._print(f'[Iter {iteration}] fault_screen "{description}": {len(jobs)} bus faults, {how} ...')
         t0 = time.monotonic()
-        results = run_many(jobs, self._settings)
+        results = run_contingency(jobs, self._settings) if ca else run_many(jobs, self._settings)
         outcomes = [self._judge(r, wmap, study, clear) for r in results]
         elapsed = time.monotonic() - t0
 
         cycles = study.clearing_cycles + study.margin_cycles
         note = (f"bus short circuit to ground at {study.start_s:g} s, cleared after {cycles:g} cycles "
                 f"({study.duration_s():.3f} s), R = {study.R:g} pu, X = {study.X:g} pu, "
-                f"{study.tmax_s:g} s simulated")
+                f"{study.tmax_s:g} s simulated, GridKit {study.application}, "
+                f"starting from {start.label}")
         text = screen_verdict(self._subject(study), outcomes, note)
         if check.warnings:
             text += "\n\nWARNINGS:\n" + "\n".join(f"  {w}" for w in check.warnings)
@@ -283,6 +394,8 @@ def _finalize(self, session: GridkitSession) -> GridkitSession:
         print("=" * 60)
         print(f"  Goal:        {session.goal}")
         print(f"  Case:        {session.case_file}")
+        if session.steady_state:
+            print(f"  Start from:  {session.steady_state}")
         print(f"  Stopped:     {session.termination_reason}")
         if session.error:
             print(f"  Error:       {session.error[:300]}")
@@ -299,6 +412,12 @@ def _finalize(self, session: GridkitSession) -> GridkitSession:
         return session
 
 
+def _exago_label(source: SteadyStateSource) -> str:
+    """Short name of an ExaGO start for verdict lines."""
+    return (f"the latest ExaGO steady state ({source.application.upper()} iteration "
+            f"{source.iteration}, {source.journal.name})")
+
+
 def _outcome_table(outcomes: list[FaultOutcome]) -> str:
     """Every fault, one row: result and the main check values."""
     def val(o: FaultOutcome, name: str, fmt: str) -> str:
diff --git a/agentigrid/agentigrid/gridkit_engine/commands.py b/agentigrid/agentigrid/gridkit_engine/commands.py
index 3d60c03a..bd12b5ee 100644
--- a/agentigrid/agentigrid/gridkit_engine/commands.py
+++ b/agentigrid/agentigrid/gridkit_engine/commands.py
@@ -71,6 +71,10 @@ def parse_command(raw: dict) -> CaseCommand:
 # Fault study request
 # ---------------------------------------------------------------------------
 
+START_FROM = ("case", "latest_steady_state")
+APPLICATIONS = ("DynamicSimulation", "ContingencyAnalysis")
+
+
 @dataclass
 class FaultStudy:
     """One bus short circuit to ground per listed bus, each in its own run.
@@ -80,6 +84,11 @@ class FaultStudy:
       all_buses    every bus in the case
       poi + hops   the POI bus and every bus up to *hops* branches away
                    (PJM M-14B G.3.2: at least the POI and one bus away)
+
+    start_from   "case": the GridKit case's own operating point;
+                 "latest_steady_state": the most recent ExaGO solution
+    application  GridKit application: DynamicSimulation (one process per
+                 fault) or ContingencyAnalysis (one process for the screen)
     """
 
     buses: Optional[list[int]] = None
@@ -96,6 +105,8 @@ class FaultStudy:
     checks: list[str] = field(default_factory=lambda: [
         "angle_stability", "voltage_recovery", "damping", "final_voltage",
     ])
+    start_from: str = "case"
+    application: str = "DynamicSimulation"
 
     def duration_s(self, freq_hz: float = 60.0) -> float:
         return criteria.clearing_time_s(self.clearing_cycles, self.margin_cycles, freq_hz)
@@ -107,14 +118,20 @@ def clear_time_s(self, freq_hz: float = 60.0) -> float:
 _STUDY_FIELDS = set(FaultStudy.__dataclass_fields__)
 
 
-def parse_fault_study(raw: dict) -> FaultStudy:
-    """Parse the LLM's fault-study request (the action dict minus bookkeeping keys)."""
+def parse_fault_study(raw: dict, defaults: Optional[dict] = None) -> FaultStudy:
+    """Parse the LLM's fault-study request (the action dict minus bookkeeping keys).
+    *defaults* (from the gridkit config) fill fields the LLM did not give."""
     ignored = {"action", "description", "reasoning"}
     unknown = set(raw) - _STUDY_FIELDS - ignored
     if unknown:
         raise ValueError(f"Unknown fault-study fields: {sorted(unknown)}. Valid: {sorted(_STUDY_FIELDS)}")
-    kwargs = {k: v for k, v in raw.items() if k in _STUDY_FIELDS}
+    kwargs = {**(defaults or {}), **{k: v for k, v in raw.items() if k in _STUDY_FIELDS}}
     try:
-        return FaultStudy(**kwargs)
+        study = FaultStudy(**kwargs)
     except TypeError as exc:
         raise ValueError(f"Invalid fault-study fields: {exc}") from exc
+    if study.start_from not in START_FROM:
+        raise ValueError(f"start_from must be one of {list(START_FROM)}, not {study.start_from!r}")
+    if study.application not in APPLICATIONS:
+        raise ValueError(f"application must be one of {list(APPLICATIONS)}, not {study.application!r}")
+    return study
diff --git a/agentigrid/agentigrid/gridkit_engine/executor.py b/agentigrid/agentigrid/gridkit_engine/executor.py
index 24db7afb..ebef55de 100644
--- a/agentigrid/agentigrid/gridkit_engine/executor.py
+++ b/agentigrid/agentigrid/gridkit_engine/executor.py
@@ -1,10 +1,12 @@
-"""Run GridKit DynamicSimulation: one run folder per fault, several at once."""
+"""Run GridKit: DynamicSimulation (one run folder per fault, several at once)
+or ContingencyAnalysis (one process and folder for all faults of a screen)."""
 
 from __future__ import annotations
 
 import json
 import logging
 import os
+import re
 import subprocess
 import time
 from concurrent.futures import ThreadPoolExecutor
@@ -20,6 +22,10 @@
 SOLVER_FILE = "study.solver.json"
 OUTPUT_FILE = "output.csv"
 
+# ContingencyAnalysis console lines that name one fault
+_CA_FAILED_RE = re.compile(r"Study failed for fault:\s*(\S+)")
+_CA_EXCEPTION_RE = re.compile(r"exception caught at fault id:\s*(\d+)")
+
 
 @dataclass
 class RunJob:
@@ -33,6 +39,7 @@ class RunJob:
     start_s: float = 0.0
     clear_s: float = 0.0
     bus: Optional[int] = None
+    fault_id: Optional[str] = None    # fault device id (ContingencyAnalysis names failures by it)
 
 
 @dataclass
@@ -43,8 +50,9 @@ class RunResult:
     elapsed_s: float
 
 
-def solver_file_content(job: RunJob) -> dict:
-    """The solver .json for a job (paths relative to the run folder)."""
+def solver_file_content(job: RunJob, solver_options: Optional[dict] = None) -> dict:
+    """The solver .json for a job (paths relative to the run folder).
+    *solver_options* are the config's gridkit.study solver keys (rel_tol, ...)."""
     events = []
     if job.element_id is not None:
         events = [
@@ -56,6 +64,7 @@ def solver_file_content(job: RunJob) -> dict:
         "dt_monitor": job.dt_monitor_s,
         "tmax": job.tmax_s,
         "output_file": OUTPUT_FILE,
+        **(solver_options or {}),
         "events": events,
     }
 
@@ -64,7 +73,8 @@ def run_one(job: RunJob, settings: GridkitSettings) -> RunResult:
     """Write the solver file, run DynamicSimulation in the run folder, keep
     stdout/stderr, and read the run status."""
     job.run_dir.mkdir(parents=True, exist_ok=True)
-    (job.run_dir / SOLVER_FILE).write_text(json.dumps(solver_file_content(job), indent=1))
+    content = solver_file_content(job, settings.solver_options)
+    (job.run_dir / SOLVER_FILE).write_text(json.dumps(content, indent=1))
     binary = settings.dynamic_simulation.resolve()
     start = time.monotonic()
     try:
@@ -95,3 +105,68 @@ def run_many(jobs: list[RunJob], settings: GridkitSettings) -> list[RunResult]:
     workers = settings.resolved_workers(len(jobs))
     with ThreadPoolExecutor(max_workers=workers) as pool:
         return list(pool.map(lambda j: run_one(j, settings), jobs))
+
+
+def _names_job(line: str, job: RunJob) -> bool:
+    """True if a ContingencyAnalysis console line reports a failure of *job*'s fault."""
+    m = _CA_FAILED_RE.search(line)
+    if m:
+        return m.group(1) == job.fault_id
+    m = _CA_EXCEPTION_RE.search(line)
+    return bool(m) and int(m.group(1)) == job.element_id
+
+
+def run_contingency(jobs: list[RunJob], settings: GridkitSettings) -> list[RunResult]:
+    """Run all *jobs* of one screen with a single ContingencyAnalysis call.
+
+    The jobs share one run folder and one case copy, which must hold exactly
+    their fault devices: ContingencyAnalysis runs one study per fault device in
+    the case, applying the solver file's events to each fault in turn, and
+    writes ``output_<element_id>.csv`` for each. Results are in job order.
+    """
+    if not jobs:
+        return []
+    run_dir = jobs[0].run_dir
+    run_dir.mkdir(parents=True, exist_ok=True)
+    content = solver_file_content(jobs[0], settings.solver_options)
+    (run_dir / SOLVER_FILE).write_text(json.dumps(content, indent=1))
+    binary = settings.contingency_analysis.resolve()
+    start = time.monotonic()
+    try:
+        proc = subprocess.run(
+            [str(binary), SOLVER_FILE], cwd=run_dir,
+            capture_output=True, text=True, timeout=settings.timeout_s * len(jobs),
+        )
+        exit_code, stdout, stderr = proc.returncode, proc.stdout, proc.stderr
+    except subprocess.TimeoutExpired as exc:
+        exit_code = None
+        stdout = exc.stdout.decode() if isinstance(exc.stdout, bytes) else (exc.stdout or "")
+        stderr = exc.stderr.decode() if isinstance(exc.stderr, bytes) else (exc.stderr or "")
+    except OSError as exc:
+        exit_code, stdout, stderr = None, "", f"[ERROR] cannot run {binary}: {exc}"
+    elapsed = time.monotonic() - start
+    (run_dir / "stdout.txt").write_text(stdout)
+    (run_dir / "stderr.txt").write_text(stderr)
+
+    # Split the shared console into what concerns each fault.
+    lines = stdout.splitlines()
+    named = {i: line for i, line in enumerate(lines)
+             if _CA_FAILED_RE.search(line) or _CA_EXCEPTION_RE.search(line)}
+    common = "\n".join(line for i, line in enumerate(lines) if i not in named)
+    results = []
+    for job in jobs:
+        own = [line for line in named.values() if _names_job(line, job)]
+        if exit_code is None:
+            code = None
+        elif own:
+            code = 1
+        elif exit_code != 0 and not named:
+            code = exit_code        # failed, but not for a named fault: all count as failed
+        else:
+            code = 0
+        csv_path = run_dir / f"output_{job.element_id}.csv"
+        status = parse_run_status(code, "\n".join([common, *own]),
+                                  stderr if code else "", csv_path, job.tmax_s)
+        logger.debug("GridKit ContingencyAnalysis bus %s: %s", job.bus, status.reason)
+        results.append(RunResult(job, status, csv_path, elapsed))
+    return results
diff --git a/agentigrid/agentigrid/gridkit_engine/from_exago.py b/agentigrid/agentigrid/gridkit_engine/from_exago.py
new file mode 100644
index 00000000..246464b7
--- /dev/null
+++ b/agentigrid/agentigrid/gridkit_engine/from_exago.py
@@ -0,0 +1,288 @@
+"""Start a GridKit study from the most recent ExaGO steady state.
+
+GridKit needs dynamic data (machines, governors, exciters) that a MATPOWER
+case does not have, so the GridKit case still supplies the dynamic models; the
+ExaGO solution supplies the operating point and the network:
+
+  buses      init Vr/Vi from the solved Vm/Va
+  machines   p0/q0 from the solved Pg/Qg; machines of generators that are off
+             in ExaGO are removed together with their controls (governor,
+             exciter, stabilizer: every device on the machine's signals)
+  loads      one constant-impedance LoadZIP per bus from Pd/Qd
+  shunts     separate constant-impedance LoadZIP from Gs/Bs
+  branches   rebuilt from the online ExaGO branches (R, X, B, tap, phase)
+
+An online ExaGO generator without a machine model is an error: GridKit could
+only treat it as a fixed injection, which is not a dynamic study.
+
+"Most recent" means the last simulation in the newest ExaGO journal, not the
+best one: GridKit is meant to run on top of the latest steady state.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import math
+import re
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from agentigrid.exago_parsers.matpower_model import MATNetwork
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.gridkit_parsers.case_parser import MACHINE_CLASSES, _is_bus_port
+
+# AC steady states that ExaGO saves as one solved MATPOWER case (-save_output).
+STEADY_STATE_APPS = {"opflow": "opflowout.m", "pflow": "pflowout.m"}
+
+_GOAL_RE = re.compile(r"\b(most\s+recent|latest|last)\s+steady[\s-]*state\b", re.IGNORECASE)
+
+
+class SteadyStateError(ValueError):
+    """The ExaGO steady state cannot be found or used for GridKit."""
+
+
+def goal_wants_steady_state(goal: str) -> bool:
+    """True if the goal asks to use the most recent steady-state results."""
+    return bool(_GOAL_RE.search(goal or ""))
+
+
+@dataclass(frozen=True)
+class SteadyStateSource:
+    journal: Path
+    iteration: int
+    description: str
+    application: str
+    run_dir: Path
+    solved_file: Path
+
+    def describe(self) -> str:
+        return (f"ExaGO {self.application.upper()} iteration {self.iteration} "
+                f"(\"{self.description}\") from {self.journal.name}, solution {self.solved_file}")
+
+
+def _netfile(argv: list[str]) -> Optional[Path]:
+    for flag, value in zip(argv, argv[1:]):
+        if flag == "-netfile":
+            return Path(value)
+    return None
+
+
+def find_latest_steady_state(exago_workdir: Path | str) -> SteadyStateSource:
+    """The last simulation of the newest ExaGO journal in *exago_workdir*.
+
+    Raises SteadyStateError when that simulation is not a single converged
+    AC steady state with a saved solution (no silent fallback to an older one).
+    """
+    exago_workdir = Path(exago_workdir)
+    journals = sorted(exago_workdir.glob("journal_*.json"))
+    if not journals:
+        raise SteadyStateError(f"No ExaGO journal in {exago_workdir}; run an ExaGO study first.")
+    journal = journals[-1]          # names carry the timestamp, so sorting by name is by time
+    entries = json.loads(journal.read_text()).get("entries", [])
+    simulated = [e for e in entries if e.get("exago_command")]
+    if not simulated:
+        raise SteadyStateError(f"{journal.name} has no simulation.")
+    entry = simulated[-1]
+    cmd = entry["exago_command"]
+    it = entry.get("iteration")
+    app = cmd.get("application", "")
+    where = f"The most recent ExaGO iteration ({it}, {journal.name})"
+    if cmd.get("mode") != "single":
+        raise SteadyStateError(f"{where} is a '{cmd.get('mode')}' run of many solves, "
+                               "not a single steady state.")
+    if app not in STEADY_STATE_APPS:
+        raise SteadyStateError(f"{where} ran {app}; only {sorted(STEADY_STATE_APPS)} give an "
+                               "AC steady state GridKit can start from.")
+    # PFLOW's saved file always has converged = 0 (ExaGO writes the OPFLOW
+    # flag), so the journal's status is the one to trust.
+    status = str(entry.get("convergence_status", ""))
+    if not status.upper().startswith("CONVERGED"):
+        raise SteadyStateError(f"{where} did not converge (status: {status or 'unknown'}).")
+    netfile = _netfile(cmd.get("argv") or [])
+    if netfile is None:
+        raise SteadyStateError(f"{where}: no -netfile in the recorded command.")
+    solved = netfile.parent / STEADY_STATE_APPS[app]
+    if not solved.exists():
+        raise SteadyStateError(f"{where}: solution file {solved} is missing "
+                               "(runs before ExaGO saved its output cannot be used).")
+    return SteadyStateSource(journal, int(it), str(entry.get("description", "")), app,
+                             netfile.parent, solved)
+
+
+# ---------------------------------------------------------------------------
+# Conversion
+# ---------------------------------------------------------------------------
+
+def _signal_ports(device: dict) -> set:
+    return {v for k, v in device.get("ports", {}).items() if not _is_bus_port(k)}
+
+
+def _machine_unit(device: dict) -> str:
+    """Machine id within its bus ('49_1_genrou' -> '1'), for ordering."""
+    parts = str(device.get("id", "")).split("_")
+    return parts[1] if len(parts) > 2 else str(device.get("id", ""))
+
+
+def _unit_key(unit: str):
+    return (0, int(unit), "") if unit.isdigit() else (1, 0, unit)
+
+
+def apply_steady_state(case: dict, net: MATNetwork) -> tuple[dict, list[str]]:
+    """GridKit case with *net*'s solved operating point and network.
+
+    Returns (new case, notes). Raises SteadyStateError when the two cases
+    cannot be matched.
+    """
+    base = float(net.baseMVA)
+    out = copy.deepcopy(case)
+    notes: list[str] = []
+    buses = {b.bus_i: b for b in net.buses}
+    gk_buses = {b["number"]: b for b in out["buses"]}
+
+    # --- buses ---------------------------------------------------------
+    missing = sorted(set(buses) - set(gk_buses))
+    extra = sorted(set(gk_buses) - set(buses))
+    if missing or extra:
+        raise SteadyStateError(
+            "Bus numbers differ between the ExaGO and GridKit cases"
+            + (f"; only in ExaGO: {missing[:10]}" if missing else "")
+            + (f"; only in GridKit: {extra[:10]}" if extra else "")
+        )
+    isolated = sorted(n for n, b in buses.items() if b.type == 4)
+    if isolated:
+        raise SteadyStateError(f"ExaGO case has isolated buses {isolated[:10]}; "
+                               "GridKit cannot start from an islanded network.")
+    for n, b in buses.items():
+        va = math.radians(b.Va)
+        gk_buses[n]["init"] = {"Vr": b.Vm * math.cos(va), "Vi": b.Vm * math.sin(va)}
+
+    devices = out["devices"]
+
+    # --- generators -> machines ------------------------------------------
+    gens_at: dict[int, list] = defaultdict(list)
+    for g in net.generators:
+        gens_at[g.bus].append(g)
+    machines_at: dict[int, list[dict]] = defaultdict(list)
+    for d in devices:
+        if d["class"] in MACHINE_CLASSES:
+            machines_at[d["ports"]["bus"]].append(d)
+    no_model, ambiguous, removed_machines = [], [], []
+    for bus in sorted(set(gens_at) | set(machines_at)):
+        gens = gens_at.get(bus, [])
+        online = [g for g in gens if g.status]
+        machines = sorted(machines_at.get(bus, []), key=lambda d: _unit_key(_machine_unit(d)))
+        if len(online) > len(machines):
+            no_model.append(bus)
+            continue
+        if len(gens) == len(machines):
+            pairs = list(zip(gens, machines))
+        elif len(online) == len(machines):
+            pairs = list(zip(online, machines))
+        elif not online:
+            pairs = [(None, m) for m in machines]
+        else:
+            ambiguous.append(bus)
+            continue
+        for g, m in pairs:
+            if g is None or not g.status:
+                removed_machines.append(m)
+            else:
+                m["params"]["p0"] = g.Pg / base
+                m["params"]["q0"] = g.Qg / base
+    if no_model:
+        raise SteadyStateError(
+            f"Online ExaGO generator(s) at bus(es) {no_model} have no dynamic model "
+            "in the GridKit case; GridKit cannot simulate them."
+        )
+    if ambiguous:
+        raise SteadyStateError(
+            f"Cannot match ExaGO generators to GridKit machines at bus(es) {ambiguous} "
+            "(different unit counts)."
+        )
+    if removed_machines:
+        signals = set().union(*(_signal_ports(m) for m in removed_machines))
+        drop = {id(m) for m in removed_machines}
+        controls = [d for d in devices if id(d) not in drop and d["class"] not in MACHINE_CLASSES
+                    and _signal_ports(d) & signals]
+        drop |= {id(d) for d in controls}
+        devices[:] = [d for d in devices if id(d) not in drop]
+        still_used = set().union(*(_signal_ports(d) for d in devices)) if devices else set()
+        out["signals"] = [s for s in out.get("signals", []) if s["signal_id"] in still_used]
+        notes.append(
+            "Removed machines of generators that are off in ExaGO: "
+            + ", ".join(m["id"] for m in removed_machines)
+            + (f" (with {len(controls)} control device(s))" if controls else "")
+        )
+
+    # --- loads and shunts --------------------------------------------------
+    old_loads = [d for d in devices if d["class"] == "LoadZIP"]
+    nonz = sorted({d["ports"]["bus"] for d in old_loads
+                   if d["params"].get("alphaI", 0) or d["params"].get("alphaP", 0)})
+    if nonz:
+        # Pnom applies at the initial voltage either way, so the steady state
+        # holds; only the dynamic voltage dependence differs.
+        notes.append(f"Loads at buses {nonz[:10]} keep their ZIP fractions.")
+    alphas = {d["ports"]["bus"]: (d["params"].get("alphaI", 0.0), d["params"].get("alphaP", 0.0))
+              for d in old_loads}
+    load_ids = {d["ports"]["bus"]: d["id"] for d in old_loads}
+    devices[:] = [d for d in devices if d["class"] != "LoadZIP"]
+    n_shunts = 0
+    for n, b in sorted(buses.items()):
+        if b.Pd or b.Qd:
+            ai, ap = alphas.get(n, (0.0, 0.0))
+            devices.append({"class": "LoadZIP", "id": load_ids.get(n, f"load_{n}"),
+                            "ports": {"bus": n},
+                            "params": {"Pnom": b.Pd / base, "Qnom": b.Qd / base,
+                                       "alphaI": ai, "alphaP": ap}})
+        if b.Gs or b.Bs:
+            vm2 = b.Vm * b.Vm      # Pnom/Qnom are taken at the initial voltage
+            devices.append({"class": "LoadZIP", "id": f"shunt_{n}", "ports": {"bus": n},
+                            "params": {"Pnom": b.Gs * vm2 / base, "Qnom": -b.Bs * vm2 / base,
+                                       "alphaI": 0.0, "alphaP": 0.0}})
+            n_shunts += 1
+    if n_shunts:
+        notes.append(f"{n_shunts} ExaGO shunt(s) added as constant-impedance loads.")
+
+    # --- branches ------------------------------------------------------------
+    old_ids: dict[tuple, list[str]] = defaultdict(list)
+    for d in devices:
+        if d["class"] == "Branch":
+            old_ids[tuple(sorted((d["ports"]["bus1"], d["ports"]["bus2"])))].append(d["id"])
+    devices[:] = [d for d in devices if d["class"] != "Branch"]
+    used: dict[tuple, int] = defaultdict(int)
+    n_off = 0
+    for br in net.branches:
+        key = tuple(sorted((br.fbus, br.tbus)))
+        k = used[key]
+        used[key] += 1
+        if not br.status:
+            n_off += 1
+            continue
+        ids = old_ids.get(key, [])
+        devices.append({
+            "class": "Branch",
+            "id": ids[k] if k < len(ids) else f"branch_{br.fbus}_{br.tbus}_{k + 1}",
+            "ports": {"bus1": br.fbus, "bus2": br.tbus},
+            "params": {"R": br.r, "X": br.x, "B": br.b,
+                       "tap": br.ratio if br.ratio else 1.0,
+                       "phase": math.radians(br.angle)},
+        })
+    only_gk = sorted(f"{key[0]}-{key[1]}" for key, ids in old_ids.items()
+                     if used.get(key, 0) < len(ids))
+    if only_gk:
+        notes.append(f"Branches only in the GridKit case were left out (ExaGO's network is "
+                     f"the steady state): {', '.join(only_gk[:10])}")
+    if n_off:
+        notes.append(f"{n_off} branch(es) out of service in ExaGO left out.")
+
+    out.setdefault("header", {})["case_comments"] = "operating point from ExaGO"
+    return out, notes
+
+
+def build_from_exago(case: dict, source: SteadyStateSource) -> tuple[dict, list[str]]:
+    """Read *source*'s solved case and apply it to the GridKit *case*."""
+    net = parse_matpower(source.solved_file)
+    return apply_steady_state(case, net)
diff --git a/agentigrid/agentigrid/gridkit_engine/modifier.py b/agentigrid/agentigrid/gridkit_engine/modifier.py
index 65d9ce97..2060de36 100644
--- a/agentigrid/agentigrid/gridkit_engine/modifier.py
+++ b/agentigrid/agentigrid/gridkit_engine/modifier.py
@@ -80,11 +80,17 @@ def apply_modifications(
 
 
 def prepare_fault_case(
-    case: dict, study: FaultStudy, element_map: dict,
+    case: dict, study: FaultStudy, element_map: dict, only_study_faults: bool = False,
 ) -> tuple[dict, dict, dict[int, int], ModificationReport]:
     """Case copy for a fault study: a fault device at every study bus and the
     variables the requested checks read.
 
+    With *only_study_faults*, fault devices at other buses (such as a demo
+    fault shipped with the case) are left out of the copy. ContingencyAnalysis
+    runs every fault device in the file, so they would add runs nobody asked
+    for. DynamicSimulation only switches on the fault its events name, so
+    other fault devices stay in the copy, inactive.
+
     Returns (case copy, its element map, {bus: GridKit element_id}, report).
     """
     need = required_variables(study.checks)
@@ -96,6 +102,15 @@ def prepare_fault_case(
     commands: list[CaseCommand] = [AddBusFault(bus=b, R=study.R, X=study.X) for b in buses]
     commands.append(record)
     work, report = apply_modifications(case, commands, element_map)
+    if only_study_faults:
+        keep = set(buses)
+        dropped = [d.get("id") for d in work["devices"]
+                   if d.get("class") == FAULT_CLASS and (d.get("ports") or {}).get("bus") not in keep]
+        if dropped:
+            work["devices"] = [d for d in work["devices"]
+                               if not (d.get("class") == FAULT_CLASS
+                                       and (d.get("ports") or {}).get("bus") not in keep)]
+            report.applied.append(f"fault devices at other buses left out: {', '.join(map(str, dropped))}")
     work_map = build_element_map(work)
     fault_ids = {f["bus"]: f["element_id"] for f in reversed(work_map["bus_faults"])}
     return work, work_map, {b: fault_ids[b] for b in buses if b in fault_ids}, report
diff --git a/agentigrid/agentigrid/gridkit_engine/schema_description.py b/agentigrid/agentigrid/gridkit_engine/schema_description.py
index 96751897..58d12d82 100644
--- a/agentigrid/agentigrid/gridkit_engine/schema_description.py
+++ b/agentigrid/agentigrid/gridkit_engine/schema_description.py
@@ -7,8 +7,10 @@
 from agentigrid.gridkit_engine.validation import MAX_FAULTS
 
 
-def command_schema_text() -> str:
-    """Text for the GridKit system prompt: what the LLM may ask for."""
+def command_schema_text(start_s: float = criteria.FAULT_START_S,
+                        tmax_s: float = criteria.SIM_LENGTH_S) -> str:
+    """Text for the GridKit system prompt: what the LLM may ask for.
+    *start_s* and *tmax_s* are the defaults in effect (from the gridkit config)."""
     checks = "\n".join(f"     - {name}: {desc}" for name, (_, _, desc) in CHECKS.items())
     skipped = "\n".join(f"   - {tid} {name}: {why}" for tid, name, why in criteria.SKIPPED_TESTS)
     default_checks = ", ".join(f'"{c}"' for c in ("angle_stability", "voltage_recovery",
@@ -25,16 +27,28 @@ def command_schema_text() -> str:
      poi (int), hops (int)   POI bus and every bus up to hops branches away
                              (PJM: at least the POI and one bus away -> hops = 1)
    Optional (defaults are PJM-based; only change them if the goal says so):
-     start_s ({criteria.FAULT_START_S})            fault start time
+     start_s ({start_s})            fault start time
      clearing_cycles ({criteria.NORMAL_CLEARING_CYCLES})       nominal clearing time, cycles
      margin_cycles ({criteria.MARGIN_PRIMARY_CYCLES})        PJM clearing margin, cycles
-     tmax_s ({criteria.SIM_LENGTH_S})            simulation length, s (damping needs >= {criteria.DAMPING_MIN_RUN_S})
+     tmax_s ({tmax_s})            simulation length, s (damping needs >= {criteria.DAMPING_MIN_RUN_S})
      R, X ({criteria.FAULT_R_PU}, {criteria.FAULT_X_PU})         fault impedance, pu
      checks (default [{default_checks}]):
 {checks}
+     start_from ("case")    operating point the runs start from:
+       "case"                 the GridKit case's own operating point
+       "latest_steady_state"  the most recent ExaGO steady-state solution
+                              (last simulation of the newest ExaGO journal; its
+                              voltages, angles, dispatch, generator outages and
+                              network are applied to the GridKit case first)
+     application ("DynamicSimulation")  GridKit application that runs the faults:
+       "DynamicSimulation"    one GridKit process per bus fault
+       "ContingencyAnalysis"  one GridKit process runs every bus fault of the screen
+                              (same simulation, same checks)
    At most {MAX_FAULTS} bus faults per screen.
    Example: {{"action": "fault_screen", "poi": 29, "hops": 1}}
    Example: {{"action": "fault_screen", "all_buses": true}}
+   Example: {{"action": "fault_screen", "buses": [135], "start_from": "latest_steady_state",
+             "application": "ContingencyAnalysis"}}
 
 2. complete — finish with the answer
    "summary" must be the VERDICT line of the screen; "details" must list every
diff --git a/agentigrid/agentigrid/gridkit_engine/settings.py b/agentigrid/agentigrid/gridkit_engine/settings.py
index 3e3d5b65..d2d21603 100644
--- a/agentigrid/agentigrid/gridkit_engine/settings.py
+++ b/agentigrid/agentigrid/gridkit_engine/settings.py
@@ -1,36 +1,52 @@
 """GridKit run settings.
 
-The one shared config has no ``gridkit:`` section yet (draft kept in the
-session notes until the GridKit team's solver .json change lands). Until
-then these defaults apply; LLM, output folders, iteration limit and worker
-count come from the existing config sections.
+Taken from the ``gridkit:`` section of the one shared config (binary, timeout,
+solver .json values, default fault start). LLM, output folders, iteration
+limit and worker count come from the other config sections.
 """
 
 from __future__ import annotations
 
 import os
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Any, Optional
 
-from agentigrid.config import AppConfig
+from agentigrid.config import AppConfig, GridkitConfig
 
-DEFAULT_BINARY_DIR = Path("./applications/gridkit")   # relative to cwd, like exago.binary_dir
-DEFAULT_TIMEOUT_S = 600.0
+_DEFAULTS = GridkitConfig()
+DEFAULT_BINARY_DIR = _DEFAULTS.binary_dir   # relative to cwd, like exago.binary_dir
+DEFAULT_TIMEOUT_S = float(_DEFAULTS.timeout)
 MAX_AUTO_WORKERS = 8
 
 
 @dataclass(frozen=True)
 class GridkitSettings:
     binary_dir: Path = DEFAULT_BINARY_DIR
+    dynamicsimulation_binary: Optional[Path] = None
     timeout_s: float = DEFAULT_TIMEOUT_S
     workers: int = 0                # 0 = auto: min(cpu count, MAX_AUTO_WORKERS)
     workdir: Path = Path("./workdir/gridkit")
+    exago_workdir: Path = Path("./workdir/exago")   # where "latest_steady_state" is looked up
     logs_dir: Path = Path("./logs/gridkit")
     max_iterations: int = 10
+    tmax_s: float = _DEFAULTS.study.tmax
+    dt_monitor_s: float = _DEFAULTS.study.dt_monitor
+    fault_start_s: float = _DEFAULTS.fault.start
+    solver_options: dict[str, Any] = field(default_factory=_DEFAULTS.study.solver_options)
 
     @property
     def dynamic_simulation(self) -> Path:
-        return self.binary_dir / "DynamicSimulation"
+        return self.dynamicsimulation_binary or self.binary_dir / "DynamicSimulation"
+
+    @property
+    def contingency_analysis(self) -> Path:
+        return self.binary_dir / "ContingencyAnalysis"
+
+    def study_defaults(self) -> dict[str, float]:
+        """FaultStudy fields the config sets when the LLM gives no value."""
+        return {"start_s": self.fault_start_s, "tmax_s": self.tmax_s,
+                "dt_monitor_s": self.dt_monitor_s}
 
     def resolved_workers(self, n_jobs: int) -> int:
         auto = min(os.cpu_count() or 1, MAX_AUTO_WORKERS)
@@ -39,11 +55,20 @@ def resolved_workers(self, n_jobs: int) -> int:
     @classmethod
     def from_config(cls, cfg: AppConfig, **overrides) -> "GridkitSettings":
         """Settings from the shared config: outputs go to a ``gridkit/`` subfolder."""
+        gk = cfg.gridkit
         base = dict(
+            binary_dir=gk.binary_dir,
+            dynamicsimulation_binary=gk.dynamicsimulation_binary,
+            timeout_s=float(gk.timeout),
             workdir=Path(cfg.output.workdir) / "gridkit",
+            exago_workdir=Path(cfg.output.workdir) / "exago",
             logs_dir=Path(cfg.output.logs_dir) / "gridkit",
             max_iterations=cfg.search.max_iterations,
             workers=cfg.search.sweep_max_workers,
+            tmax_s=gk.study.tmax,
+            dt_monitor_s=gk.study.dt_monitor,
+            fault_start_s=gk.fault.start,
+            solver_options=gk.study.solver_options(),
         )
         base.update({k: v for k, v in overrides.items() if v is not None})
         return cls(**base)
diff --git a/agentigrid/agentigrid/gridkit_parsers/status_parser.py b/agentigrid/agentigrid/gridkit_parsers/status_parser.py
index 5263eba9..06162115 100644
--- a/agentigrid/agentigrid/gridkit_parsers/status_parser.py
+++ b/agentigrid/agentigrid/gridkit_parsers/status_parser.py
@@ -24,7 +24,8 @@
 logger = logging.getLogger("agentigrid.gridkit_parsers.status")
 
 _ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
-_COMPLETE_RE = re.compile(r"Complete in\s+([\d.eE+-]+)\s+seconds")
+# DynamicSimulation: "Complete in 2.57 seconds"; ContingencyAnalysis: "Complete in 1.91939s"
+_COMPLETE_RE = re.compile(r"Complete in\s+([\d.]+(?:[eE][+-]?\d+)?)\s*(?:seconds|s)\b")
 _FLAG_RE = re.compile(r"Function\s+(\w+)\s+failed with flag\s+(\w+)")
 _FAILED_AT_RE = re.compile(r"\bAt t\s*=\s*([\d.eE+-]+)")
 _ERROR_TAG = "[ERROR]"
diff --git a/agentigrid/agentigrid/prompts/gridkit/system_prompt.py b/agentigrid/agentigrid/prompts/gridkit/system_prompt.py
index 1752fd1b..160f64ae 100644
--- a/agentigrid/agentigrid/prompts/gridkit/system_prompt.py
+++ b/agentigrid/agentigrid/prompts/gridkit/system_prompt.py
@@ -16,20 +16,27 @@
 2. Turn the user's goal into ONE fault_screen that answers it. Use the defaults
    unless the goal states a value (clearing time, fault impedance, simulation
    length, buses). "Each bus" / "every bus" / "all buses" -> "all_buses": true.
-   A connection request at a bus (a POI) -> "poi": <bus>, "hops": 1 (PJM: the POI
-   and every bus one bus away), unless the goal names other buses or a depth.
+   A fault or connection request at a bus (a POI) -> that bus only:
+   "buses": [<bus>]. Add the buses around it ("poi": <bus>, "hops": 1 or more;
+   PJM: the POI and every bus one bus away) only if the goal asks for nearby
+   buses, a depth, or the PJM POI screen.
 3. DO NOT RE-RUN AN IDENTICAL FAULT SCREEN. If a screen already answered the goal,
    finish with "complete".
 4. The verdict is decided by AgentiGrid. Your "summary" must be the VERDICT line
    exactly as shown. Your "details" must list every failed or unjudged bus fault
    with its reason, the assumptions used (fault start, clearing time, simulation
-   length, fault impedance), and every PJM test listed as SKIPPED.
+   length, fault impedance, operating point), and every PJM test listed as SKIPPED.
 5. Never report a SKIPPED PJM test as passed, and never suggest an approximation
    for it. GridKit does not have the element it needs.
 6. A test or report goal only reports. Do not propose fixes unless the goal asks.
 7. If the goal asks to connect a new generator or load, say plainly in "details"
    that it was NOT added to the model (skipped test NEW): the screen shows how the
    existing system responds to faults at the POI and nearby buses.
+8. If the goal asks to start from the most recent / latest / last steady state
+   (or the last ExaGO / OPF / power-flow result), set "start_from":
+   "latest_steady_state". Otherwise leave the default "case".
+9. If the goal asks for contingency analysis or ContingencyAnalysis, set
+   "application": "ContingencyAnalysis". Otherwise leave the default.
 """
 
 _COMPLETE = """\
diff --git a/agentigrid/agentigrid_architecture.md b/agentigrid/agentigrid_architecture.md
index 3d8ee808..3bf3bde8 100644
--- a/agentigrid/agentigrid_architecture.md
+++ b/agentigrid/agentigrid_architecture.md
@@ -170,7 +170,7 @@ Responsibilities:
 
 ### 4.6 Goal Classification
 
-After the search loop completes, a shared utility module (`agentigrid/engine/goal_classifier.py`) builds a classification prompt and parses the LLM's structured JSON response. Both the CLI path (`AgentLoopController._finalize`) and the GUI path (`SessionManager.get_summary_analysis`) use this shared logic.
+After the search loop completes, a shared utility module (`agentigrid/exago_engine/goal_classifier.py`) builds a classification prompt and parses the LLM's structured JSON response. Both the CLI path (`AgentLoopController._finalize`) and the GUI path (`SessionManager.get_summary_analysis`) use this shared logic.
 
 Goal types:
 
@@ -489,12 +489,12 @@ Each explore+select cycle costs **one iteration** against `max_iterations`, but
 
 | Component | File | Description |
 |-----------|------|-------------|
-| `ParetoCandidate` + `pareto_filter()` | `agentigrid/engine/pareto.py` | Non-dominated sorting over variant results. Feasible candidates dominate infeasible ones. Default objective: lowest generation cost. Multi-objective: uses registered objective directions. |
-| `VariantResult` + `ExploreCache` | `agentigrid/engine/explore.py` | Data structures for explore results. `ExploreCache` holds all variant results between explore and select actions. |
-| `format_variant_results()` | `agentigrid/engine/explore.py` | Formats variant comparison table for LLM prompt with Pareto ★ markers. |
-| `_handle_explore()` | `agentigrid/engine/agent_loop.py` | Parses variant command lists, applies each to a deep copy of the base/current network, runs all simulations concurrently via `run_parallel()`, computes Pareto front, stores results in `_explore_cache`. |
-| `_handle_select()` | `agentigrid/engine/agent_loop.py` | Validates selection against cache, updates `_current_network` to selected variant's network, creates journal entry with `explored_variants` metadata, clears cache. |
-| `SimulationExecutor.run_parallel()` | `agentigrid/engine/executor.py` | Thin ThreadPoolExecutor wrapper that runs N simulations concurrently. Each simulation is an independent subprocess. |
+| `ParetoCandidate` + `pareto_filter()` | `agentigrid/exago_engine/pareto.py` | Non-dominated sorting over variant results. Feasible candidates dominate infeasible ones. Default objective: lowest generation cost. Multi-objective: uses registered objective directions. |
+| `VariantResult` + `ExploreCache` | `agentigrid/exago_engine/explore.py` | Data structures for explore results. `ExploreCache` holds all variant results between explore and select actions. |
+| `format_variant_results()` | `agentigrid/exago_engine/explore.py` | Formats variant comparison table for LLM prompt with Pareto ★ markers. |
+| `_handle_explore()` | `agentigrid/exago_engine/agent_loop.py` | Parses variant command lists, applies each to a deep copy of the base/current network, runs all simulations concurrently via `run_parallel()`, computes Pareto front, stores results in `_explore_cache`. |
+| `_handle_select()` | `agentigrid/exago_engine/agent_loop.py` | Validates selection against cache, updates `_current_network` to selected variant's network, creates journal entry with `explored_variants` metadata, clears cache. |
+| `SimulationExecutor.run_parallel()` | `agentigrid/exago_engine/executor.py` | Thin ThreadPoolExecutor wrapper that runs N simulations concurrently. Each simulation is an independent subprocess. |
 | System prompt | `agentigrid/prompts/exago/system_prompt.py` | Dynamic action schema (5 actions for concurrent PFLOW vs 3 for standard). `explore` is action #1 (primary) when concurrent mode is on. Search heuristics are rewritten to recommend parallel search patterns. |
 
 #### Search Strategy
@@ -612,7 +612,7 @@ This document serves as shared context between the human developer, Claude (brai
 - **Binding-constraint identification is activity-based, not value-based, and is a diagnostic label distinct from the certified capacity.** The `binding_constraint` label attached to each `max_feasible_mw` is computed at the max-feasible point and never affects the capacity number. ExaGO OPFLOW exposes **line-flow Lagrange multipliers** (`mult_Sf`/`mult_St`, nonzero exactly when a flow limit is active) but **not** voltage-bound shadow prices (the bus table carries only power-balance multipliers). So identification is hybrid: (1) **thermal** — the genuinely-active line with the largest |multiplier| when duals are present, else the *globally* most-loaded line(s) within `binding_eps` (0.5%) of the system max, computed from **both ends** `max(|Sf|,|St|)/Slim` (an earlier bug used `Sf` only and mis-named local lines at 94–97% while the system was at 100%); (2) **voltage** — a bound binds only if its margin *collapsed* relative to the base solve (clearly positive in base, ~0 at the boundary), which excludes pinned PV setpoints (e.g. a bus regulating to Vmax=1.10 in every solve, previously blamed by the value-based `metric == limit` test); (3) when both a thermal line and a voltage bound are newly active, **both** are reported. The base-case solved result is threaded into the identifier for the margin-vs-base comparison. Historical journals that predate this fix cannot be retroactively corrected without re-running.
 - **Dispatchable-generator siting needs a load-bearing cost curve, not a cosmetic one.** Min-cost location for a *dispatchable* unit (prompt 13) is the deliberate exception to forced injection: the OPF must choose the unit's output, so the unit needs a realistic cost curve. With zero cost it dispatches to max everywhere (free energy) and the location ranking is meaningless; with too-high cost it never dispatches and every location looks identical to base. The default curve is the **case median** of existing model-2 polynomials (mid-merit), so the unit partially dispatches and locations differentiate (`search.added_gen_cost_strategy`). The per-candidate dispatched Pg is recorded as a diagnostic — a unit dispatching ~0 MW is not helping at that location.
 - **Fixed-injection vs dispatchable must be chosen from the prompt wording, never defaulted.** "Hosting capacity / forced output" → fixed injection (`Pmin = Pmax`); "economic dispatch / minimize cost / let the unit choose" → dispatchable (`Pmin = 0, Pmax = cap`) with a cost curve. These are different questions (e.g. a forced 160/40 split vs an optimized 200/200 dispatch) and silently picking the wrong mode flips the answer — the system prompt (rule X.1) makes the LLM map phrasing → mode and name the mode back.
-- **Custom sweep metrics/predicates are a named registry of verified primitives, not LLM-synthesized code.** This is the Phase-1 trusted-primitive approach (`engine/sweep_metrics.py`): the LLM selects a `metric` / `feasibility_predicate` *by name*; the registry is extensible via `register_metric` / `register_predicate` for later capabilities. `max_delta_v` (worst system-wide voltage step on switching, needs a one-time base solve) and `reactive_adequacy` (feasible OPF at forced P=Pmax, Q=Qmax) generalize the sweep beyond cost + standard V-band/loading feasibility. When neither is specified the default path is byte-identical to before, so existing baselines are preserved.
+- **Custom sweep metrics/predicates are a named registry of verified primitives, not LLM-synthesized code.** This is the Phase-1 trusted-primitive approach (`exago_engine/sweep_metrics.py`): the LLM selects a `metric` / `feasibility_predicate` *by name*; the registry is extensible via `register_metric` / `register_predicate` for later capabilities. `max_delta_v` (worst system-wide voltage step on switching, needs a one-time base solve) and `reactive_adequacy` (feasible OPF at forced P=Pmax, Q=Qmax) generalize the sweep beyond cost + standard V-band/loading feasibility. When neither is specified the default path is byte-identical to before, so existing baselines are preserved.
 - **Custom metrics are certified-gated — same rule as the binding-constraint identifier.** A metric read from a candidate's solved state is trustworthy only if that candidate *converged*; the shared `_is_certified(opflow)` gate (status starts with `CONVERGED`) decides this. For non-converged candidates `metric_value` is set to `None`, so the LLM's max/min reduction and the report operate over certified candidates only and never elevate an uncertified iterate to the headline. (Evidence: prompt-15 originally reported 0.09 p.u. at a *non-converged* bus 77 — its iterate showed 293.8% loading — when the correct feasible maximum was 0.032 at bus 139.) Note on semantics: under OPFLOW `max_delta_v` is the change between two cost-optimal voltage profiles (the solver re-dispatches reactive support), a steady-state sensitivity, not a physical energization transient; it is taken over all buses including the connection bus.
 - **Best-feasible summary aggregation must descend into sweep variants.** Sweep iterations carry no scalar `objective_value` (they journal as `SWEEP`), so a naive iteration-level minimum collapses to the base case and reports it as the optimum. `SearchJournal.summary_stats` therefore descends into each cost sweep's `explored_variants` and takes the global minimum feasible per-candidate cost (returning `best_bus` alongside `best_objective`/`best_iteration`). It stays goal-aware: boundary sweeps (variants carry `max_feasible_mw`) and custom-metric sweeps (variants carry `metric_name`) are skipped, and the descent only runs for cost-style goals. (Evidence: prompt-13 reported the base case $27,557.57 (iter 0) instead of the sweep optimum $27,367.73 at bus 181.)
 - **`reactive_adequacy` forces Q, and records it for audit.** The predicate's intent is "Qmax *while at* Pmax", so the mutation pins `Qmin == Qmax == Qmax_target` (forced, not merely upper-bounded). The added unit's solved reactive output is recorded as `dispatched_q` (mirroring `dispatched_pg`) and surfaced in the reactive-adequacy table — at every certified/adequate bus it should equal the Qmax target, making the forcing verifiable from results.
diff --git a/agentigrid/configs/default_config.yaml.template b/agentigrid/configs/default_config.yaml.template
index 9ef1edfc..dd5dd092 100644
--- a/agentigrid/configs/default_config.yaml.template
+++ b/agentigrid/configs/default_config.yaml.template
@@ -15,6 +15,13 @@ exago:
   env_script: "./configs/env_setup.sh"
   # Default timeout for simulation execution (seconds)
   timeout: 360
+  # Solved cases written by OPFLOW/PFLOW (opflowout.m / pflowout.m) in each run folder:
+  #   all     keep every one
+  #   best    single solves kept; a multi-solve action (sweep, explore, boundary,
+  #           contingency, reserve) keeps only its best, or the most recent if it has no best
+  #   newest  single solves kept; a multi-solve action keeps only its most recent
+  #   none    not written (GridKit cannot start from the latest ExaGO steady state)
+  save_solutions: "best"
 
 # Data settings
 data:
@@ -65,3 +72,28 @@ output:
   journal_format: "json"        # json | csv
   save_modified_files: true     # keep modified .m files from each iteration
   verbose: false                # print detailed output during search
+
+# GridKit settings (used with --tool gridkit). LLM, iteration limit, worker
+# count and output folders come from the sections above; GridKit output goes
+# to {output.workdir}/gridkit/ and {output.logs_dir}/gridkit/.
+# PJM pass/fail limits are not set here: they are fixed in
+# agentigrid/gridkit_engine/criteria.py with their sources.
+gridkit:
+  binary_dir: "./applications/gridkit"  # links to GridKit/build/bin
+  dynamicsimulation_binary: null        # defaults to {binary_dir}/DynamicSimulation
+  timeout: 600                          # seconds per GridKit run
+
+  # Written into each run's solver .json; keys are GridKit's own
+  # (GridKit/application/PhasorDynamics/README.md)
+  study:
+    tmax: 15.0                          # simulation length, s (PJM: 10-15 s; damping needs >= 10)
+    dt_monitor: 0.01                    # recording interval, s
+    rel_tol: 1.0e-7
+    abs_tol: 1.0e-9
+    dt_fixed: 0.0                       # 0 = adaptive time step
+    max_steps: 0                        # 0 = IDA default, negative = unlimited
+    max_order: 5                        # IDA method order, 1-5
+
+  fault:                                # used when the goal gives no time
+    start: 1.0                          # fault_on time, s; the clearing time follows
+                                        #   PJM clearing cycles + margin (criteria.py)
diff --git a/agentigrid/configs/local_config.yaml.template b/agentigrid/configs/local_config.yaml.template
index 7442d60e..3f4d5764 100644
--- a/agentigrid/configs/local_config.yaml.template
+++ b/agentigrid/configs/local_config.yaml.template
@@ -8,6 +8,13 @@ exago:
   binary_dir: "./applications/exago"
   env_script: "./configs/env_setup.sh"
   timeout: 120
+  # Solved cases written by OPFLOW/PFLOW (opflowout.m / pflowout.m) in each run folder:
+  #   all     keep every one
+  #   best    single solves kept; a multi-solve action (sweep, explore, boundary,
+  #           contingency, reserve) keeps only its best, or the most recent if it has no best
+  #   newest  single solves kept; a multi-solve action keeps only its most recent
+  #   none    not written (GridKit cannot start from the latest ExaGO steady state)
+  save_solutions: "best"
 
 # Data settings
 data:
@@ -37,3 +44,28 @@ output:
   journal_format: "json"
   save_modified_files: true
   verbose: true
+
+# GridKit settings (used with --tool gridkit). LLM, iteration limit, worker
+# count and output folders come from the sections above; GridKit output goes
+# to {output.workdir}/gridkit/ and {output.logs_dir}/gridkit/.
+# PJM pass/fail limits are not set here: they are fixed in
+# agentigrid/gridkit_engine/criteria.py with their sources.
+gridkit:
+  binary_dir: "./applications/gridkit"  # links to GridKit/build/bin
+  dynamicsimulation_binary: null        # defaults to {binary_dir}/DynamicSimulation
+  timeout: 600                          # seconds per GridKit run
+
+  # Written into each run's solver .json; keys are GridKit's own
+  # (GridKit/application/PhasorDynamics/README.md)
+  study:
+    tmax: 15.0                          # simulation length, s (PJM: 10-15 s; damping needs >= 10)
+    dt_monitor: 0.01                    # recording interval, s
+    rel_tol: 1.0e-7
+    abs_tol: 1.0e-9
+    dt_fixed: 0.0                       # 0 = adaptive time step
+    max_steps: 0                        # 0 = IDA default, negative = unlimited
+    max_order: 5                        # IDA method order, 1-5
+
+  fault:                                # used when the goal gives no time
+    start: 1.0                          # fault_on time, s; the clearing time follows
+                                        #   PJM clearing cycles + margin (criteria.py)
diff --git a/agentigrid/launcher/ARCHITECTURE.md b/agentigrid/launcher/ARCHITECTURE.md
index f8fa76d3..4ffc2f7e 100644
--- a/agentigrid/launcher/ARCHITECTURE.md
+++ b/agentigrid/launcher/ARCHITECTURE.md
@@ -415,13 +415,13 @@ agentigrid/
 │       └── example_goals.yaml       # Preset goal prompts
 │
 ├── agentigrid/                         # Existing — NOT MODIFIED (except callback hooks)
-│   ├── engine/
+│   ├── exago_engine/
 │   │   ├── agent_loop.py            # ◄── Minor addition: callback parameters
 │   │   ├── journal.py               # Used as-is
 │   │   ├── executor.py              # Used as-is
 │   │   └── ...
 │   ├── backends/                    # Used as-is
-│   ├── parsers/                     # Used as-is
+│   ├── exago_parsers/               # Used as-is
 │   ├── config.py                    # Used as-is
 │   └── ...
 │
@@ -894,7 +894,7 @@ The implementation is structured as 9 Claude Code tasks across 3 phases, each bu
 
 OPFLOW reports `DID NOT CONVERGE` for **all** infeasible candidates regardless of the actual internal cause (voltage violation, line overload, numerical divergence, etc.). The only certified information from a non-converging solve is that **no feasible operating point was found**. The solver's last iterate — voltage magnitudes, line loadings, violation count — is uncertified diagnostic data, not a confirmed constraint cause.
 
-**Implementation rule**: the `_infeasible_reason` function in `engine/agent_loop.py` takes only `convergence_status: str` as input. It returns `"constraint violation"` only when the status starts with `"CONVERGED"` (PFLOW-style post-solve infeasibility), and `"did not converge"` for everything else. Scalar iterate metrics are never used to classify the infeasibility cause.
+**Implementation rule**: the `_infeasible_reason` function in `exago_engine/agent_loop.py` takes only `convergence_status: str` as input. It returns `"constraint violation"` only when the status starts with `"CONVERGED"` (PFLOW-style post-solve infeasibility), and `"did not converge"` for everything else. Scalar iterate metrics are never used to classify the infeasibility cause.
 
 **Rendering rule**: the `_certified_reason(v: dict)` helper (duplicated in `app.py` and `report_generator.py`) derives the displayed reason from the `status` field in the candidate dict at render time, overriding whatever string is stored in the `reason` field. This ensures historical journals with old heuristic labels (e.g., "line overload") are rendered correctly without a data migration.
 
diff --git a/agentigrid/launcher/app.py b/agentigrid/launcher/app.py
index 9a49e379..13613f1f 100644
--- a/agentigrid/launcher/app.py
+++ b/agentigrid/launcher/app.py
@@ -36,8 +36,8 @@
     reserve_trajectory_chart,
 )
 
-from agentigrid.engine.journal import describe_contingency_scope
-from agentigrid.parsers import parse_matpower, network_summary
+from agentigrid.exago_engine.journal import describe_contingency_scope
+from agentigrid.exago_parsers import parse_matpower, network_summary
 
 # ── Page Configuration ───────────────────────────────────────────────────────
 
diff --git a/agentigrid/launcher/charts.py b/agentigrid/launcher/charts.py
index 7a7b872f..ef8b61f9 100644
--- a/agentigrid/launcher/charts.py
+++ b/agentigrid/launcher/charts.py
@@ -11,8 +11,8 @@
 
 import plotly.graph_objects as go
 
-from agentigrid.engine.journal import SearchJournal, is_solve_iteration
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine.journal import SearchJournal, is_solve_iteration
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 # ── Color Palette ────────────────────────────────────────────────────────────
 
diff --git a/agentigrid/launcher/report_generator.py b/agentigrid/launcher/report_generator.py
index af99e1b4..8719b60f 100644
--- a/agentigrid/launcher/report_generator.py
+++ b/agentigrid/launcher/report_generator.py
@@ -22,9 +22,9 @@
 from reportlab.pdfbase import pdfmetrics
 from reportlab.pdfbase.ttfonts import TTFont
 
-from agentigrid.engine.agent_loop import SearchSession
-from agentigrid.engine.journal import describe_contingency_scope, is_solve_iteration
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine.agent_loop import SearchSession
+from agentigrid.exago_engine.journal import describe_contingency_scope, is_solve_iteration
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 try:
     from charts import (
@@ -2160,7 +2160,7 @@ def _sopflow_absorption_rows(self, session) -> list:
         # Lazy import to match the codebase's defensive import style and avoid
         # any top-level import cost/cycle.
         from pathlib import Path
-        from agentigrid.parsers import compute_wind_absorption
+        from agentigrid.exago_parsers import compute_wind_absorption
 
         rows = []
         for e in session.journal.entries:
@@ -2203,7 +2203,7 @@ def _sopflow_voltage_spread(self, session):
         save a flat 1.0 profile that has zero spread and is uninformative). Falls
         back to any iteration with a computable spread. Fully guarded."""
         from pathlib import Path
-        from agentigrid.parsers import compute_scenario_voltage_spread
+        from agentigrid.exago_parsers import compute_scenario_voltage_spread
 
         sim_entries = [
             e for e in session.journal.entries
diff --git a/agentigrid/launcher/session_manager.py b/agentigrid/launcher/session_manager.py
index 74503926..bb691eaf 100644
--- a/agentigrid/launcher/session_manager.py
+++ b/agentigrid/launcher/session_manager.py
@@ -15,10 +15,10 @@
 
 from agentigrid.backends import create_backend
 from agentigrid.config import load_config
-from agentigrid.engine.agent_loop import AgentLoopController, SearchSession
-from agentigrid.engine.goal_classifier import build_classification_prompts, parse_goal_classification
-from agentigrid.engine.journal import JournalEntry
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine.agent_loop import AgentLoopController, SearchSession
+from agentigrid.exago_engine.goal_classifier import build_classification_prompts, parse_goal_classification
+from agentigrid.exago_engine.journal import JournalEntry
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 try:
     from config_builder import get_default_config_path
@@ -381,7 +381,7 @@ def save_current_session(self, save_dir: Path | None = None) -> Path | None:
 
         # If search is completed, save from the session object
         if self._session is not None:
-            from agentigrid.engine.session_io import save_session
+            from agentigrid.exago_engine.session_io import save_session
             return save_session(
                 save_dir=save_dir,
                 goal=self._session.goal,
diff --git a/agentigrid/tests/README.md b/agentigrid/tests/README.md
index 189303ab..332826d1 100644
--- a/agentigrid/tests/README.md
+++ b/agentigrid/tests/README.md
@@ -5,13 +5,13 @@ Tests are grouped by the part of AgentiGrid they cover:
 | Folder | Covers |
 |---|---|
 | `llm/` | LLM backends and JSON extraction (`agentigrid/backends/`) |
-| `grid_files/` | MATPOWER reader, writer and network summary (`parsers/matpower_*`, `network_*`) |
-| `commands/` | Grid-change commands, validation and the modifier (`engine/commands.py`, `modifier.py`) |
-| `runner/` | Running simulation binaries and logging their invocations (`engine/executor.py`) |
-| `results/` | Result readers and summaries for the LLM (`parsers/*_parser.py`, `*_summary.py`) |
+| `grid_files/` | MATPOWER reader, writer and network summary (`exago_parsers/matpower_*`, `network_*`) |
+| `commands/` | Grid-change commands, validation and the modifier (`exago_engine/commands.py`, `modifier.py`) |
+| `runner/` | Running simulation binaries and logging their invocations (`exago_engine/executor.py`) |
+| `results/` | Result readers and summaries for the LLM (`exago_parsers/*_parser.py`, `*_summary.py`) |
 | `exago/` | Support for individual ExaGO applications (DCOPFLOW, PFLOW, SCOPFLOW, TCOPFLOW, SOPFLOW) |
 | `gridkit/` | GridKit readers (`gridkit_parsers/`), PJM checks and helpers (`gridkit_engine/`) |
-| `agent_loop/` | Agent loop controller and interactive steering (`engine/agent_loop.py`) |
+| `agent_loop/` | Agent loop controller and interactive steering (`exago_engine/agent_loop.py`) |
 | `journal/` | Search journal, objectives, Pareto front, session save and report regeneration |
 | `analyses/` | Explore, sweeps, boundary search, contingency, relief, reserve and topology |
 | `e2e/` | End-to-end runs through the agent loop |
diff --git a/agentigrid/tests/agent_loop/test_agent_loop.py b/agentigrid/tests/agent_loop/test_agent_loop.py
index 2742af12..c7df4a30 100644
--- a/agentigrid/tests/agent_loop/test_agent_loop.py
+++ b/agentigrid/tests/agent_loop/test_agent_loop.py
@@ -12,9 +12,9 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine.agent_loop import AgentLoopController, SearchSession
-from agentigrid.engine.executor import SimulationResult
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine.agent_loop import AgentLoopController, SearchSession
+from agentigrid.exago_engine.executor import SimulationResult
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 
 # ---------------------------------------------------------------------------
@@ -192,11 +192,11 @@ def test_three_iteration_sequence(self, tmp_path: Path):
         mock_backend = MockBackend(responses)
         sim_result = _make_sim_result(stdout=stdout, success=True)
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend), \
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend), \
              patch.object(
                  AgentLoopController, "_AgentLoopController__class__", create=True
              ) if False else \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
 
             mock_executor = MagicMock()
             mock_executor.run.return_value = sim_result
@@ -240,8 +240,8 @@ def test_invalid_json_then_valid(self, tmp_path: Path):
         mock_backend = MockBackend(responses)
         sim_result = _make_sim_result(stdout=stdout, success=True)
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
 
             mock_executor = MagicMock()
             mock_executor.run.return_value = sim_result
@@ -271,8 +271,8 @@ def test_unknown_action(self, tmp_path: Path):
         mock_backend = MockBackend(responses)
         sim_result = _make_sim_result(stdout=stdout, success=True)
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
 
             mock_executor = MagicMock()
             mock_executor.run.return_value = sim_result
@@ -309,8 +309,8 @@ def test_simulation_failure(self, tmp_path: Path):
         success_result = _make_sim_result(stdout=stdout, success=True)
         fail_result = _make_sim_result(stdout="", success=False)
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
 
             mock_executor = MagicMock()
             mock_executor.run.side_effect = [success_result, fail_result]
@@ -343,8 +343,8 @@ def test_stops_at_max(self, tmp_path: Path):
         mock_backend = MockBackend([modify_response])
         sim_result = _make_sim_result(stdout=stdout, success=True)
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
 
             mock_executor = MagicMock()
             mock_executor.run.return_value = sim_result
@@ -374,8 +374,8 @@ def test_system_prompt_contents(self, tmp_path: Path):
         ])
         sim_result = _make_sim_result(stdout=stdout, success=bool(stdout))
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
 
             mock_executor = MagicMock()
             mock_executor.run.return_value = sim_result
@@ -426,8 +426,8 @@ def test_user_prompt_contains_journal(self, tmp_path: Path):
         mock_backend = MockBackend(responses)
         sim_result = _make_sim_result(stdout=stdout, success=bool(stdout))
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
 
             mock_executor = MagicMock()
             mock_executor.run.return_value = sim_result
@@ -467,8 +467,8 @@ def test_analyze_then_complete(self, tmp_path: Path):
         mock_backend = MockBackend(responses)
         sim_result = _make_sim_result(stdout=stdout, success=True)
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
 
             mock_executor = MagicMock()
             mock_executor.run.return_value = sim_result
@@ -502,8 +502,8 @@ def test_journal_saved_to_workdir(self, tmp_path: Path):
         mock_backend = MockBackend(responses)
         sim_result = _make_sim_result(stdout=stdout, success=True)
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
 
             mock_executor = MagicMock()
             mock_executor.run.return_value = sim_result
diff --git a/agentigrid/tests/agent_loop/test_steering.py b/agentigrid/tests/agent_loop/test_steering.py
index 283eec60..47752a96 100644
--- a/agentigrid/tests/agent_loop/test_steering.py
+++ b/agentigrid/tests/agent_loop/test_steering.py
@@ -9,7 +9,7 @@
 
 import pytest
 
-from agentigrid.engine.agent_loop import AgentLoopController
+from agentigrid.exago_engine.agent_loop import AgentLoopController
 from agentigrid.prompts.exago.user_prompt import build_user_prompt
 
 
@@ -20,8 +20,8 @@ def _make_controller() -> AgentLoopController:
     cfg = MagicMock()
     cfg.llm.backend = "openai"
     cfg.llm.model = "gpt-4o"
-    with patch("agentigrid.engine.agent_loop.create_backend"), \
-         patch("agentigrid.engine.agent_loop.SimulationExecutor"):
+    with patch("agentigrid.exago_engine.agent_loop.create_backend"), \
+         patch("agentigrid.exago_engine.agent_loop.SimulationExecutor"):
         ctrl = AgentLoopController(cfg)
     return ctrl
 
diff --git a/agentigrid/tests/analyses/test_boundary_sweep.py b/agentigrid/tests/analyses/test_boundary_sweep.py
index 174779b0..b6f6b106 100644
--- a/agentigrid/tests/analyses/test_boundary_sweep.py
+++ b/agentigrid/tests/analyses/test_boundary_sweep.py
@@ -21,7 +21,7 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine.agent_loop import (
+from agentigrid.exago_engine.agent_loop import (
     AgentLoopController,
     _ProbeOutcome,
     _bisect_boundary,
@@ -31,9 +31,9 @@
     _system_average_tan_phi,
     _tan_phi_from_pf_spec,
 )
-from agentigrid.engine.executor import SimulationExecutor, SimulationResult
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.opflow_results import (
+from agentigrid.exago_engine.executor import SimulationExecutor, SimulationResult
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.opflow_results import (
     OPFLOWResult, BranchResult, BusResult,
 )
 
@@ -410,8 +410,8 @@ class TestBoundaryHandlerIntegration:
 
     def _controller(self, tmp_path):
         cfg = _make_config(tmp_path)
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=MagicMock()), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=MagicMock()), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
             mock_executor = MagicMock()
             mock_executor.run.return_value = _sim_result()
             # map_callables runs the (patched) bisection callables synchronously
@@ -436,7 +436,7 @@ def fake_bisect(bus, *a, **k):
         controller._bisect_candidate = fake_bisect
 
         feasible_base = _opflow(converged=True)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=feasible_base):
             kind, ok = controller._handle_boundary_sweep(1, {
                 "entity": "load",
@@ -464,7 +464,7 @@ def fake_bisect(bus, *a, **k):
     def test_base_infeasible_aborts(self, tmp_path):
         controller = self._controller(tmp_path)
         infeasible_base = _opflow(converged=False)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=infeasible_base):
             kind, ok = controller._handle_boundary_sweep(1, {
                 "entity": "load",
@@ -488,7 +488,7 @@ def test_invalid_entity_rejected(self, tmp_path):
 # C.1 correction — binding-constraint identification (duals + margin-vs-base)
 # ---------------------------------------------------------------------------
 
-from agentigrid.engine.agent_loop import _identify_binding, _bisect_boundary, _ProbeOutcome
+from agentigrid.exago_engine.agent_loop import _identify_binding, _bisect_boundary, _ProbeOutcome
 
 
 def _branch_ends(fb, tb, sf, st, slim, mult_sf=0.0, mult_st=0.0):
diff --git a/agentigrid/tests/analyses/test_contingency.py b/agentigrid/tests/analyses/test_contingency.py
index bb754a70..d2db1d4b 100644
--- a/agentigrid/tests/analyses/test_contingency.py
+++ b/agentigrid/tests/analyses/test_contingency.py
@@ -25,15 +25,15 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine import contingency as C
-from agentigrid.engine import topology as T
-from agentigrid.engine.commands import parse_command
-from agentigrid.engine.modifier import apply_modifications
-from agentigrid.engine.agent_loop import AgentLoopController
-from agentigrid.engine.executor import SimulationResult
-from agentigrid.parsers.matpower_model import Branch, Bus, Generator, MATNetwork
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine import contingency as C
+from agentigrid.exago_engine import topology as T
+from agentigrid.exago_engine.commands import parse_command
+from agentigrid.exago_engine.modifier import apply_modifications
+from agentigrid.exago_engine.agent_loop import AgentLoopController
+from agentigrid.exago_engine.executor import SimulationResult
+from agentigrid.exago_parsers.matpower_model import Branch, Bus, Generator, MATNetwork
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 IEEE118 = DATA_DIR / "ieee_118_bus_v10.m"
@@ -431,8 +431,8 @@ class TestContingencyHandler:
     def _controller(self, tmp_path):
         cfg = _make_config(tmp_path)
         backend_mock = MagicMock()
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=backend_mock), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=backend_mock), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
             mock_executor = MagicMock()
             mock_executor.run.return_value = _sim_result()
             mock_executor.run_parallel.side_effect = (
@@ -454,7 +454,7 @@ def test_n1_screen_all_pass(self, tmp_path):
         controller, backend_mock = self._controller(tmp_path)
         n = self._n_expected(1, 1)
         calls_before = len(backend_mock.mock_calls)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=_opflow(feasible=True)):
             kind, ok = controller._handle_contingency_sweep(1, {
                 "mode": "contingency", "mutation": {"action": "add_load_at_bus", "bus": 77, "Pd": 50.0},
@@ -489,7 +489,7 @@ def test_n1_screen_all_pass(self, tmp_path):
     def test_n1_screen_all_fail_when_infeasible(self, tmp_path):
         controller, _ = self._controller(tmp_path)
         n = self._n_expected(1, 1)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=_opflow(feasible=False)):
             kind, ok = controller._handle_contingency_sweep(1, {
                 "mode": "contingency", "mutation": {"action": "add_load_at_bus", "bus": 77, "Pd": 50.0},
@@ -512,7 +512,7 @@ def test_n1_screen_all_fail_when_infeasible(self, tmp_path):
     def test_n2_screen_count(self, tmp_path):
         controller, _ = self._controller(tmp_path)
         n = self._n_expected(1, 2)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=_opflow(feasible=True)):
             kind, ok = controller._handle_contingency_sweep(1, {
                 "mode": "contingency", "mutation": {"action": "add_load_at_bus", "bus": 77, "Pd": 50.0},
@@ -527,7 +527,7 @@ def test_n2_screen_count(self, tmp_path):
 
     def test_n2_failures_counted_per_element(self, tmp_path):
         controller, _ = self._controller(tmp_path)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=_opflow(feasible=False)):
             controller._handle_contingency_sweep(1, {
                 "mode": "contingency", "mutation": {"action": "add_load_at_bus", "bus": 77, "Pd": 50.0},
@@ -563,7 +563,7 @@ def test_view_one_failure(self, tmp_path):
 
     def test_default_depth_is_3(self, tmp_path):
         controller, _ = self._controller(tmp_path)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=_opflow(feasible=True)):
             kind, ok = controller._handle_contingency_sweep(1, {
                 "mode": "contingency", "mutation": {"action": "add_load_at_bus", "bus": 77, "Pd": 50.0},
@@ -712,7 +712,7 @@ class TestDescribeScope:
     """The one-line scope text shown in the launcher and PDF report."""
 
     def test_new_meta(self, grid):
-        from agentigrid.engine.journal import describe_contingency_scope
+        from agentigrid.exago_engine.journal import describe_contingency_scope
         a = C.find_affected_elements(grid, LOAD_AT_1, 2)
         text = describe_contingency_scope({
             "changed_element": LOAD_AT_1.to_dict(), "substation_depth": 2, "affected": a.to_dict(),
@@ -723,6 +723,6 @@ def test_new_meta(self, grid):
         )
 
     def test_meta_without_affected_record(self):
-        from agentigrid.engine.journal import describe_contingency_scope
+        from agentigrid.exago_engine.journal import describe_contingency_scope
         text = describe_contingency_scope({"order": 1})
         assert text.startswith("study scope not recorded")
diff --git a/agentigrid/tests/analyses/test_explore.py b/agentigrid/tests/analyses/test_explore.py
index fa9b95f6..f63fd8b4 100644
--- a/agentigrid/tests/analyses/test_explore.py
+++ b/agentigrid/tests/analyses/test_explore.py
@@ -4,7 +4,7 @@
 from unittest.mock import MagicMock, patch
 
 from agentigrid.config import AppConfig, SearchConfig, ExagoConfig, OutputConfig, LLMConfig, DataConfig
-from agentigrid.engine.explore import (
+from agentigrid.exago_engine.explore import (
     ExploreCache,
     VariantResult,
     annotate_cost_equivalent_siblings,
@@ -12,8 +12,8 @@
     compute_pareto_labels,
     format_variant_results,
 )
-from agentigrid.engine.journal import ObjectiveEntry
-from agentigrid.engine.pareto import ParetoCandidate
+from agentigrid.exago_engine.journal import ObjectiveEntry
+from agentigrid.exago_engine.pareto import ParetoCandidate
 
 
 # ---------------------------------------------------------------------------
@@ -50,7 +50,7 @@ def _make_config(**overrides):
 
 def _make_opflow_result(**kwargs):
     """Build a minimal OPFLOWResult for testing."""
-    from agentigrid.parsers.opflow_results import (
+    from agentigrid.exago_parsers.opflow_results import (
         OPFLOWResult, BusResult, BranchResult, GenResult,
     )
     defaults = dict(
@@ -93,8 +93,8 @@ def _make_opflow_result(**kwargs):
 class TestFormatVariantResults:
 
     def _minimal_variant(self, label, feasible=True, cost=10000.0, **kwargs):
-        from agentigrid.engine.executor import SimulationResult
-        from agentigrid.parsers.matpower_model import MATNetwork
+        from agentigrid.exago_engine.executor import SimulationResult
+        from agentigrid.exago_parsers.matpower_model import MATNetwork
         # Minimal mock network
         net = MagicMock(spec=MATNetwork)
         net.gencost = []
@@ -158,7 +158,7 @@ def test_all_pareto_labels_shown(self):
         assert "Pareto-optimal" in result
 
     def test_skipped_commands_displayed(self):
-        from agentigrid.engine.commands import SetGenDispatch
+        from agentigrid.exago_engine.commands import SetGenDispatch
         v = self._minimal_variant("A", feasible=True)
         v.skipped_commands = [
             (SetGenDispatch(bus=189, Pg=500.0), ["Bus 189 is the reference/slack bus"]),
@@ -258,13 +258,13 @@ class TestAllNoOpRejection:
 
     @pytest.fixture
     def net(self):
-        from agentigrid.parsers.matpower_parser import parse_matpower
+        from agentigrid.exago_parsers.matpower_parser import parse_matpower
         return parse_matpower("data/exago/examples/case_ACTIVSg200.m")
 
     def test_all_slack_dispatch_yields_zero_applied(self, net):
         """apply_modifications against slack-only commands → applied is empty."""
-        from agentigrid.engine.commands import SetGenDispatch
-        from agentigrid.engine.modifier import apply_modifications
+        from agentigrid.exago_engine.commands import SetGenDispatch
+        from agentigrid.exago_engine.modifier import apply_modifications
 
         slack_buses = [b.bus_i for b in net.buses if b.type == 3]
         assert slack_buses, "ACTIVSg200 must have a slack bus"
@@ -275,8 +275,8 @@ def test_all_slack_dispatch_yields_zero_applied(self, net):
 
     def test_mixed_effective_and_noop_yields_some_applied(self, net):
         """A variant with one effective command should NOT be rejected."""
-        from agentigrid.engine.commands import SetGenDispatch
-        from agentigrid.engine.modifier import apply_modifications
+        from agentigrid.exago_engine.commands import SetGenDispatch
+        from agentigrid.exago_engine.modifier import apply_modifications
 
         slack_buses = [b.bus_i for b in net.buses if b.type == 3]
         non_slack_gen = next(
@@ -294,8 +294,8 @@ def test_mixed_effective_and_noop_yields_some_applied(self, net):
 
     def test_variant_result_default_not_rejected(self):
         """VariantResult.rejected defaults to False."""
-        from agentigrid.engine.executor import SimulationResult
-        from agentigrid.parsers.matpower_model import MATNetwork
+        from agentigrid.exago_engine.executor import SimulationResult
+        from agentigrid.exago_parsers.matpower_model import MATNetwork
         v = VariantResult(
             label="A",
             description="x",
@@ -309,9 +309,9 @@ def test_variant_result_default_not_rejected(self):
 
     def test_rejected_variant_renders_REJECTED_in_table(self):
         """format_variant_results displays REJECTED for rejected variants."""
-        from agentigrid.engine.commands import SetGenDispatch
-        from agentigrid.engine.executor import SimulationResult
-        from agentigrid.parsers.matpower_model import MATNetwork
+        from agentigrid.exago_engine.commands import SetGenDispatch
+        from agentigrid.exago_engine.executor import SimulationResult
+        from agentigrid.exago_parsers.matpower_model import MATNetwork
 
         net = MagicMock(spec=MATNetwork)
         net.gencost = []
@@ -340,15 +340,15 @@ def test_rejected_variant_renders_REJECTED_in_table(self):
 class TestBuildVariantDescription:
 
     def _cmd(self, bus, pg):
-        from agentigrid.engine.commands import SetGenDispatch
+        from agentigrid.exago_engine.commands import SetGenDispatch
         return SetGenDispatch(bus=bus, Pg=pg)
 
     def _vlim(self, vmin, vmax):
-        from agentigrid.engine.commands import SetAllBusVLimits
+        from agentigrid.exago_engine.commands import SetAllBusVLimits
         return SetAllBusVLimits(Vmin=vmin, Vmax=vmax)
 
     def _scale(self, factor):
-        from agentigrid.engine.commands import ScaleAllLoads
+        from agentigrid.exago_engine.commands import ScaleAllLoads
         return ScaleAllLoads(factor=factor)
 
     def test_all_applied_contains_bus_numbers(self):
@@ -421,9 +421,9 @@ def test_mixed_commands_compact(self):
 class TestAnnotateCostEquivalentSiblings:
 
     def _variant(self, label, cost=None, feasible=True, n_commands=1, *, rejected=False):
-        from agentigrid.engine.executor import SimulationResult
-        from agentigrid.parsers.matpower_model import MATNetwork
-        from agentigrid.engine.commands import SetGenDispatch
+        from agentigrid.exago_engine.executor import SimulationResult
+        from agentigrid.exago_parsers.matpower_model import MATNetwork
+        from agentigrid.exago_engine.commands import SetGenDispatch
         net = MagicMock(spec=MATNetwork)
         net.gencost = []
         if feasible and cost is not None:
@@ -623,7 +623,7 @@ def test_explore_text_none_shows_results(self):
 class TestJournalExploredVariants:
 
     def test_add_from_results_with_explored_variants(self):
-        from agentigrid.engine.journal import SearchJournal
+        from agentigrid.exago_engine.journal import SearchJournal
         journal = SearchJournal()
         opf = _make_opflow_result()
         entry = journal.add_from_results(
@@ -646,7 +646,7 @@ def test_add_from_results_with_explored_variants(self):
         assert entry.explored_variants[2]["feasible"] is False
 
     def test_add_from_results_without_explored_variants(self):
-        from agentigrid.engine.journal import SearchJournal
+        from agentigrid.exago_engine.journal import SearchJournal
         journal = SearchJournal()
         opf = _make_opflow_result()
         entry = journal.add_from_results(
@@ -668,8 +668,8 @@ def test_add_from_results_without_explored_variants(self):
 class TestSessionExplorePersistence:
 
     def test_save_with_explore_cache_info(self, tmp_path):
-        from agentigrid.engine.session_io import save_session, load_session
-        from agentigrid.engine.journal import SearchJournal
+        from agentigrid.exago_engine.session_io import save_session, load_session
+        from agentigrid.exago_engine.journal import SearchJournal
 
         journal = SearchJournal()
         save_dir = tmp_path / "test_session"
@@ -702,8 +702,8 @@ def test_save_with_explore_cache_info(self, tmp_path):
         assert loaded["explore_cache_info"]["variant_labels"] == ["A", "B", "C"]
 
     def test_save_without_explore_cache_info(self, tmp_path):
-        from agentigrid.engine.session_io import save_session, load_session
-        from agentigrid.engine.journal import SearchJournal
+        from agentigrid.exago_engine.session_io import save_session, load_session
+        from agentigrid.exago_engine.journal import SearchJournal
 
         journal = SearchJournal()
         save_dir = tmp_path / "test_session2"
@@ -728,7 +728,7 @@ def test_save_without_explore_cache_info(self, tmp_path):
 
     def test_load_v1_0_session_without_explore(self, tmp_path):
         import json
-        from agentigrid.engine.session_io import load_session
+        from agentigrid.exago_engine.session_io import load_session
 
         session_data = {
             "format_version": "1.0",
@@ -782,12 +782,12 @@ def _make_pflow_config(self, tmp_path, concurrent_pflow=True, max_variants=8):
         )
 
     def test_explore_requires_concurrent_pflow(self, tmp_path):
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         from unittest.mock import MagicMock, patch
 
         cfg = self._make_pflow_config(tmp_path, concurrent_pflow=False)
-        with patch("agentigrid.engine.agent_loop.create_backend") as mock_create, \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor"):
+        with patch("agentigrid.exago_engine.agent_loop.create_backend") as mock_create, \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor"):
             mock_create.return_value = MagicMock()
             controller = AgentLoopController(cfg, quiet=True)
             result_type, should_continue = controller._handle_explore(1, {
@@ -804,12 +804,12 @@ def test_explore_requires_concurrent_pflow(self, tmp_path):
         assert should_continue is True
 
     def test_explore_requires_at_least_2_variants(self, tmp_path):
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         from unittest.mock import MagicMock, patch
 
         cfg = self._make_pflow_config(tmp_path, concurrent_pflow=True)
-        with patch("agentigrid.engine.agent_loop.create_backend") as mock_create, \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor"):
+        with patch("agentigrid.exago_engine.agent_loop.create_backend") as mock_create, \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor"):
             mock_create.return_value = MagicMock()
             controller = AgentLoopController(cfg, quiet=True)
             result_type, should_continue = controller._handle_explore(1, {
@@ -824,12 +824,12 @@ def test_explore_requires_at_least_2_variants(self, tmp_path):
         assert result_type == "error"
 
     def test_select_without_explore_returns_error(self, tmp_path):
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         from unittest.mock import MagicMock, patch
 
         cfg = self._make_pflow_config(tmp_path, concurrent_pflow=True)
-        with patch("agentigrid.engine.agent_loop.create_backend") as mock_create, \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor"):
+        with patch("agentigrid.exago_engine.agent_loop.create_backend") as mock_create, \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor"):
             mock_create.return_value = MagicMock()
             controller = AgentLoopController(cfg, quiet=True)
             result_type, should_continue = controller._handle_select(1, {
@@ -840,13 +840,13 @@ def test_select_without_explore_returns_error(self, tmp_path):
         assert result_type == "error"
 
     def test_select_invalid_label_returns_error(self, tmp_path):
-        from agentigrid.engine.explore import ExploreCache, VariantResult
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.explore import ExploreCache, VariantResult
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         from unittest.mock import MagicMock, patch
 
         cfg = self._make_pflow_config(tmp_path, concurrent_pflow=True)
-        with patch("agentigrid.engine.agent_loop.create_backend") as mock_create, \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor"):
+        with patch("agentigrid.exago_engine.agent_loop.create_backend") as mock_create, \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor"):
             mock_create.return_value = MagicMock()
             controller = AgentLoopController(cfg, quiet=True)
             controller._explore_cache = ExploreCache(
@@ -862,13 +862,13 @@ def test_select_invalid_label_returns_error(self, tmp_path):
         assert result_type == "error"
 
     def test_modify_clears_explore_cache(self, tmp_path):
-        from agentigrid.engine.explore import ExploreCache
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.explore import ExploreCache
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         from unittest.mock import MagicMock, patch
 
         cfg = self._make_pflow_config(tmp_path, concurrent_pflow=True)
-        with patch("agentigrid.engine.agent_loop.create_backend") as mock_create, \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor"):
+        with patch("agentigrid.exago_engine.agent_loop.create_backend") as mock_create, \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor"):
             mock_create.return_value = MagicMock()
             controller = AgentLoopController(cfg, quiet=True)
             controller._explore_cache = ExploreCache(description="test", iteration=1)
@@ -885,7 +885,7 @@ class TestRunParallel:
 
     def test_run_parallel_basic(self, tmp_path):
         from agentigrid.config import ExagoConfig, OutputConfig
-        from agentigrid.engine.executor import SimulationExecutor, SimulationResult
+        from agentigrid.exago_engine.executor import SimulationExecutor, SimulationResult
 
         exago_config = ExagoConfig(
             binary_dir=tmp_path / "bin", opflow_binary=None,
@@ -904,7 +904,7 @@ def test_run_parallel_basic(self, tmp_path):
         assert result == {}
 
     def test_run_parallel_sigature(self):
-        from agentigrid.engine.executor import SimulationExecutor
+        from agentigrid.exago_engine.executor import SimulationExecutor
         import inspect
         sig = inspect.signature(SimulationExecutor.run_parallel)
         params = list(sig.parameters.keys())
@@ -1000,7 +1000,7 @@ class TestExploreJournalEntry:
     """Bug fix: explore actions must create a journal entry."""
 
     def test_add_explore_creates_entry(self):
-        from agentigrid.engine.journal import SearchJournal
+        from agentigrid.exago_engine.journal import SearchJournal
         journal = SearchJournal()
         entry = journal.add_explore(
             iteration=3,
@@ -1023,7 +1023,7 @@ def test_add_explore_creates_entry(self):
         assert len(journal.entries) == 1
 
     def test_add_explore_appears_in_format_for_prompt(self):
-        from agentigrid.engine.journal import SearchJournal
+        from agentigrid.exago_engine.journal import SearchJournal
         journal = SearchJournal()
         journal.add_explore(
             iteration=2,
@@ -1037,7 +1037,7 @@ def test_add_explore_appears_in_format_for_prompt(self):
         assert "EXPLORE" in text
 
     def test_add_explore_appears_in_format_detailed(self):
-        from agentigrid.engine.journal import SearchJournal
+        from agentigrid.exago_engine.journal import SearchJournal
         journal = SearchJournal()
         journal.add_explore(
             iteration=5,
@@ -1056,7 +1056,7 @@ class TestExploredVariantsDescriptions:
     """Bug fix: explored_variants must include description, commands, and is_pareto."""
 
     def test_select_entry_has_variant_descriptions(self):
-        from agentigrid.engine.journal import SearchJournal
+        from agentigrid.exago_engine.journal import SearchJournal
         journal = SearchJournal()
         opf = _make_opflow_result()
         entry = journal.add_from_results(
@@ -1096,7 +1096,7 @@ class TestAutoInjectVlimits:
     """Bug fix: auto-inject set_all_bus_vlimits into variants missing it."""
 
     def test_current_bus_vlimits_uniform(self):
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         net = MagicMock()
         bus1 = MagicMock()
         bus1.Vmin = 0.95
@@ -1109,7 +1109,7 @@ def test_current_bus_vlimits_uniform(self):
         assert result == (0.95, 1.05)
 
     def test_current_bus_vlimits_mixed(self):
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         net = MagicMock()
         bus1 = MagicMock()
         bus1.Vmin = 0.95
@@ -1122,7 +1122,7 @@ def test_current_bus_vlimits_mixed(self):
         assert result is None
 
     def test_variant_has_vlimits(self):
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         cmds = [
             {"action": "set_all_bus_vlimits", "Vmin": 0.95, "Vmax": 1.05},
             {"action": "scale_all_loads", "factor": 1.05},
@@ -1130,12 +1130,12 @@ def test_variant_has_vlimits(self):
         assert AgentLoopController._variant_has_vlimits(cmds) is True
 
     def test_variant_no_vlimits(self):
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         cmds = [{"action": "scale_all_loads", "factor": 1.05}]
         assert AgentLoopController._variant_has_vlimits(cmds) is False
 
     def test_variant_per_bus_vlimits(self):
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         cmds = [{"action": "set_bus_vlimits", "bus": 1, "Vmin": 0.95}]
         assert AgentLoopController._variant_has_vlimits(cmds) is True
 
diff --git a/agentigrid/tests/analyses/test_relief.py b/agentigrid/tests/analyses/test_relief.py
index 6af90492..62269321 100644
--- a/agentigrid/tests/analyses/test_relief.py
+++ b/agentigrid/tests/analyses/test_relief.py
@@ -25,13 +25,13 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine import contingency as C
-from agentigrid.engine import relief
-from agentigrid.engine import topology as T
-from agentigrid.engine.agent_loop import AgentLoopController
-from agentigrid.engine.executor import SimulationResult
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine import contingency as C
+from agentigrid.exago_engine import relief
+from agentigrid.exago_engine import topology as T
+from agentigrid.exago_engine.agent_loop import AgentLoopController
+from agentigrid.exago_engine.executor import SimulationResult
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 IEEE118 = DATA_DIR / "ieee_118_bus_v10.m"
@@ -298,8 +298,8 @@ class TestReliefHandler:
     def _controller(self, tmp_path):
         cfg = _make_config(tmp_path)
         backend_mock = MagicMock()
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=backend_mock), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=backend_mock), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
             mock_executor = MagicMock()
             mock_executor.run.return_value = _sim_result()
             mock_executor.run_parallel.side_effect = (
@@ -339,7 +339,7 @@ def fake_parse(sim, application="opflow", bus_limits=None):
             return _opflow(True)              # relief solves → resolve
 
         calls_before = len(backend_mock.mock_calls)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    side_effect=fake_parse):
             kind, ok = controller._handle_contingency_sweep(1, data)
 
@@ -360,7 +360,7 @@ def fake_parse(sim, application="opflow", bus_limits=None):
     def test_no_relief_without_relief_measures_matches_c5(self, tmp_path, net118):
         """Without relief_measures, summaries carry no 'relief' key (C.5 behavior)."""
         controller, _ = self._controller(tmp_path)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=_opflow(False)):
             kind, ok = controller._handle_contingency_sweep(1, {
                 "mode": "contingency", "mutation": {"action": "add_load_at_bus", "bus": 77, "Pd": 50.0},
@@ -388,7 +388,7 @@ def fake_run(net, *a, **k):
             return real_solve(net, *a, **k)
 
         controller._executor.run = fake_run
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    side_effect=fake_parse):
             controller._handle_contingency_sweep(1, {
                 "mode": "contingency", "mutation": {"action": "add_load_at_bus", "bus": 77, "Pd": 50.0},
@@ -414,7 +414,7 @@ def test_relief_request_not_served_from_plain_screen_cache(self, tmp_path):
     }
 
     def _sweep(self, controller, data):
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=_opflow(False)):
             return controller._handle_sweep(1, dict(data))
 
@@ -478,7 +478,7 @@ def test_relief_budget_exhausted(self, tmp_path, net118):
         # Budget 0 → every failure marked exhausted, none searched.
         new_search = dataclasses.replace(controller._config.search, relief_max_solves=0)
         controller._config = dataclasses.replace(controller._config, search=new_search)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=_opflow(False)):
             kind, ok = controller._handle_contingency_sweep(1, {
                 "mode": "contingency", "mutation": {"action": "add_load_at_bus", "bus": 77, "Pd": 50.0},
diff --git a/agentigrid/tests/analyses/test_reserve.py b/agentigrid/tests/analyses/test_reserve.py
index 889411c8..958f815b 100644
--- a/agentigrid/tests/analyses/test_reserve.py
+++ b/agentigrid/tests/analyses/test_reserve.py
@@ -19,12 +19,12 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine import contingency as C
-from agentigrid.engine import sweep_metrics
-from agentigrid.engine.agent_loop import AgentLoopController
-from agentigrid.engine.executor import SimulationResult
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.opflow_results import GenResult, OPFLOWResult
+from agentigrid.exago_engine import contingency as C
+from agentigrid.exago_engine import sweep_metrics
+from agentigrid.exago_engine.agent_loop import AgentLoopController
+from agentigrid.exago_engine.executor import SimulationResult
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.opflow_results import GenResult, OPFLOWResult
 
 DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 IEEE118 = DATA_DIR / "ieee_118_bus_v10.m"
@@ -188,8 +188,8 @@ class TestReserveHandler:
     def _controller(self, tmp_path):
         cfg = _make_config(tmp_path)
         backend_mock = MagicMock()
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=backend_mock), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=backend_mock), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
             mock_executor = MagicMock()
             mock_executor.run.return_value = _sim_result()
             mock_executor.run_parallel.side_effect = (
@@ -231,9 +231,9 @@ def fake_parse(sim, application="opflow", bus_limits=None):
             return _opflow(k != 2)
 
         calls_before = len(backend_mock.mock_calls)
-        with patch("agentigrid.engine.agent_loop.contingency.all_generator_contingencies",
+        with patch("agentigrid.exago_engine.agent_loop.contingency.all_generator_contingencies",
                    return_value=fake_ctgs), \
-             patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+             patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    side_effect=fake_parse):
             kind, ok = controller._handle_reserve_screen(1, {
                 "mode": "reserve", "feasibility": {"Vmin": 0.9, "Vmax": 1.1},
@@ -279,9 +279,9 @@ def fake_parse(sim, application="opflow", bus_limits=None):
                 return _opflow(True, generators=base_gens)
             return _opflow(True)  # every unit loss feasible
 
-        with patch("agentigrid.engine.agent_loop.contingency.all_generator_contingencies",
+        with patch("agentigrid.exago_engine.agent_loop.contingency.all_generator_contingencies",
                    return_value=fake_ctgs), \
-             patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+             patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    side_effect=fake_parse):
             kind, ok = controller._handle_reserve_screen(1, {
                 "mode": "reserve", "feasibility": {"Vmin": 0.9, "Vmax": 1.1},
@@ -294,7 +294,7 @@ def fake_parse(sim, application="opflow", bus_limits=None):
 
     def test_base_infeasible_errors(self, tmp_path):
         controller, _ = self._controller(tmp_path)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=_opflow(False)):
             kind, ok = controller._handle_reserve_screen(1, {
                 "mode": "reserve", "feasibility": {"Vmin": 0.9, "Vmax": 1.1},
diff --git a/agentigrid/tests/analyses/test_reserve_min.py b/agentigrid/tests/analyses/test_reserve_min.py
index e62c66e2..92896fc9 100644
--- a/agentigrid/tests/analyses/test_reserve_min.py
+++ b/agentigrid/tests/analyses/test_reserve_min.py
@@ -17,7 +17,7 @@
 
 import pytest
 
-from agentigrid.engine import reserve as R
+from agentigrid.exago_engine import reserve as R
 
 
 # ---------------------------------------------------------------------------
@@ -187,11 +187,11 @@ def test_determinism():
 from agentigrid.config import (  # noqa: E402
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine.agent_loop import AgentLoopController  # noqa: E402
-from agentigrid.engine.executor import SimulationResult  # noqa: E402
-from agentigrid.engine import contingency as C  # noqa: E402
-from agentigrid.parsers.matpower_parser import parse_matpower  # noqa: E402
-from agentigrid.parsers.opflow_results import GenResult, OPFLOWResult  # noqa: E402
+from agentigrid.exago_engine.agent_loop import AgentLoopController  # noqa: E402
+from agentigrid.exago_engine.executor import SimulationResult  # noqa: E402
+from agentigrid.exago_engine import contingency as C  # noqa: E402
+from agentigrid.exago_parsers.matpower_parser import parse_matpower  # noqa: E402
+from agentigrid.exago_parsers.opflow_results import GenResult, OPFLOWResult  # noqa: E402
 
 _DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 _IEEE118 = _DATA_DIR / "ieee_118_bus_v10.m"
@@ -250,8 +250,8 @@ def _opf(feasible=True, generators=None):
 def test_handler_minimize_maps_result_and_journals(tmp_path):
     cfg = _cfg(tmp_path)
     backend_mock = MagicMock()
-    with patch("agentigrid.engine.agent_loop.create_backend", return_value=backend_mock), \
-         patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+    with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=backend_mock), \
+         patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
         mock_executor = MagicMock()
         mock_executor.run.return_value = _sim()
         mock_executor.run_parallel.side_effect = (
@@ -281,9 +281,9 @@ def fake_parse(sim, application="opflow", bus_limits=None):
         n1_secure=True, solves_used=42, hit_budget=False,
     )
 
-    with patch("agentigrid.engine.agent_loop.contingency.all_generator_contingencies",
+    with patch("agentigrid.exago_engine.agent_loop.contingency.all_generator_contingencies",
                return_value=fake_ctgs), \
-         patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+         patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                side_effect=fake_parse), \
          patch.object(AgentLoopController, "_run_reserve_minimization",
                       return_value=canned) as mock_min:
diff --git a/agentigrid/tests/analyses/test_sweep_corrections.py b/agentigrid/tests/analyses/test_sweep_corrections.py
index a7ab4141..db51b109 100644
--- a/agentigrid/tests/analyses/test_sweep_corrections.py
+++ b/agentigrid/tests/analyses/test_sweep_corrections.py
@@ -16,11 +16,11 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine.agent_loop import AgentLoopController, _is_certified
-from agentigrid.engine.executor import SimulationResult
-from agentigrid.engine.journal import SearchJournal, JournalEntry
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.opflow_results import OPFLOWResult, BusResult, GenResult
+from agentigrid.exago_engine.agent_loop import AgentLoopController, _is_certified
+from agentigrid.exago_engine.executor import SimulationResult
+from agentigrid.exago_engine.journal import SearchJournal, JournalEntry
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult, BusResult, GenResult
 
 DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 BASE_CASE = DATA_DIR / "case_ACTIVSg200.m"
@@ -79,8 +79,8 @@ def _make_config(tmp_path):
 
 def _controller(tmp_path):
     cfg = _make_config(tmp_path)
-    with patch("agentigrid.engine.agent_loop.create_backend", return_value=MagicMock()), \
-         patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+    with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=MagicMock()), \
+         patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
         ex = MagicMock()
         ex.run.return_value = _sim()
         ex.run_parallel.side_effect = (
@@ -124,7 +124,7 @@ def test_non_converged_metric_is_none(self, tmp_path):
         base = _opflow(buses=[_busres(1, 1.00), _busres(2, 1.00), _busres(99, 1.00)])
         cand1 = _opflow(converged=True,  buses=[_busres(1, 1.01), _busres(2, 1.00), _busres(99, 1.03)])  # ΔV 0.03
         cand2 = _opflow(converged=False, buses=[_busres(1, 1.00), _busres(2, 1.00), _busres(99, 1.09)])  # ΔV 0.09 (uncertified)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    side_effect=[base, cand1, cand2]):
             kind, ok = c._handle_sweep(1, {
                 "mutation": {"action": "add_load_at_bus", "Pd": 100.0},
@@ -151,7 +151,7 @@ def test_all_converged_unchanged(self, tmp_path):
         base = _opflow(buses=[_busres(1, 1.00), _busres(2, 1.00)])
         cand1 = _opflow(converged=True, buses=[_busres(1, 1.02), _busres(2, 1.00)])  # 0.02
         cand2 = _opflow(converged=True, buses=[_busres(1, 1.00), _busres(2, 1.04)])  # 0.04
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    side_effect=[base, cand1, cand2]):
             c._handle_sweep(1, {
                 "mutation": {"action": "add_load_at_bus", "Pd": 100.0},
@@ -266,7 +266,7 @@ def test_dispatched_q_recorded_at_adequate_bus(self, tmp_path):
         c = _controller(tmp_path)
         # added unit solves at Qg == Qmax target (50) at each adequate bus
         g_at = lambda bus: _opflow(converged=True, gens=[_genres(bus, 100.0, 50.0)])
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    side_effect=[g_at(1), g_at(2)]):
             kind, ok = c._handle_sweep(1, {
                 "mutation": {"action": "add_generator_at_bus", "capacity_mw": 100.0, "Qmax": 50.0},
@@ -297,7 +297,7 @@ class TestSweepDedup:
 
     def _run_sweep(self, c, pd=100.0):
         converged = _opflow(converged=True)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=converged):
             return c._handle_sweep(1, {
                 "mutation": {"action": "add_load_at_bus", "Pd": pd},
diff --git a/agentigrid/tests/analyses/test_sweep_llm_view.py b/agentigrid/tests/analyses/test_sweep_llm_view.py
index fa6d40cc..6f0b4d37 100644
--- a/agentigrid/tests/analyses/test_sweep_llm_view.py
+++ b/agentigrid/tests/analyses/test_sweep_llm_view.py
@@ -17,7 +17,7 @@
 
 import pytest
 
-from agentigrid.engine.agent_loop import _build_sweep_llm_view
+from agentigrid.exago_engine.agent_loop import _build_sweep_llm_view
 
 
 # ---------------------------------------------------------------------------
diff --git a/agentigrid/tests/analyses/test_sweep_metrics_dispatch.py b/agentigrid/tests/analyses/test_sweep_metrics_dispatch.py
index ff47d8f2..719c4d28 100644
--- a/agentigrid/tests/analyses/test_sweep_metrics_dispatch.py
+++ b/agentigrid/tests/analyses/test_sweep_metrics_dispatch.py
@@ -15,15 +15,15 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine import sweep_metrics
-from agentigrid.engine.agent_loop import AgentLoopController
-from agentigrid.engine.commands import AddGeneratorAtBus, parse_command
-from agentigrid.engine.executor import SimulationResult
-from agentigrid.engine.modifier import (
+from agentigrid.exago_engine import sweep_metrics
+from agentigrid.exago_engine.agent_loop import AgentLoopController
+from agentigrid.exago_engine.commands import AddGeneratorAtBus, parse_command
+from agentigrid.exago_engine.executor import SimulationResult
+from agentigrid.exago_engine.modifier import (
     apply_modifications, _median_existing_cost_coeffs,
 )
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.opflow_results import OPFLOWResult, BusResult, GenResult
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult, BusResult, GenResult
 
 DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 BASE_CASE = DATA_DIR / "case_ACTIVSg200.m"
@@ -105,7 +105,7 @@ def test_median_existing_is_mid_merit(self, net):
 class TestMedianCostFallback:
 
     def test_fallback_when_no_polynomial_curves(self):
-        from agentigrid.parsers.matpower_model import MATNetwork, GenCost
+        from agentigrid.exago_parsers.matpower_model import MATNetwork, GenCost
         net = MATNetwork(
             casename="x", version="2", baseMVA=100.0, buses=[], generators=[],
             branches=[], gencost=[GenCost(model=1, startup=0, shutdown=0, ncost=2, coeffs=[0, 0, 1, 1])],
@@ -247,8 +247,8 @@ def _make_config(tmp_path, **search_over):
 
 def _controller(tmp_path, **search_over):
     cfg = _make_config(tmp_path, **search_over)
-    with patch("agentigrid.engine.agent_loop.create_backend", return_value=MagicMock()), \
-         patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+    with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=MagicMock()), \
+         patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
         mock_exec_cls.return_value = MagicMock()
         c = AgentLoopController(cfg)
     return c
@@ -312,8 +312,8 @@ class TestSweepHandlerIntegration:
 
     def _controller_with_exec(self, tmp_path):
         cfg = _make_config(tmp_path)
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=MagicMock()), \
-             patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=MagicMock()), \
+             patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
             mock_executor = MagicMock()
             mock_executor.run.return_value = _sim()
             mock_executor.run_parallel.side_effect = (
@@ -349,7 +349,7 @@ def test_max_delta_v_sweep_records_metric(self, tmp_path):
         c = self._controller_with_exec(tmp_path)
         base = _opflow(buses=[_busres(1, 1.0), _busres(2, 1.0)])
         cand = _opflow(buses=[_busres(1, 1.02), _busres(2, 0.97)])  # max ΔV = 0.03
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    side_effect=[base, cand, cand]):  # base solve, then 2 candidates
             kind, ok = c._handle_sweep(1, {
                 "mutation": {"action": "add_load_at_bus", "Pd": 100.0},
@@ -367,7 +367,7 @@ def test_default_sweep_has_no_metric_keys(self, tmp_path):
         """Regression: a sweep with no metric/predicate journals an unchanged payload."""
         c = self._controller_with_exec(tmp_path)
         cand = _opflow(converged=True, violations=0)
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    return_value=cand):
             c._handle_sweep(1, {
                 "mutation": {"action": "add_load_at_bus", "Pd": 100.0},
@@ -385,7 +385,7 @@ def test_dispatchable_sweep_records_pg(self, tmp_path):
         # candidate result includes the added unit (last gen at the bus) dispatching 120 MW
         def _cand_for(bus):
             return _opflow(converged=True, violations=0, gens=[_genres(bus, 120.0)])
-        with patch("agentigrid.engine.agent_loop.parse_simulation_result_for_app",
+        with patch("agentigrid.exago_engine.agent_loop.parse_simulation_result_for_app",
                    side_effect=[_cand_for(1), _cand_for(2)]):
             kind, ok = c._handle_sweep(1, {
                 "mutation": {"action": "add_generator_at_bus", "capacity_mw": 200.0},
diff --git a/agentigrid/tests/analyses/test_sweep_reporting.py b/agentigrid/tests/analyses/test_sweep_reporting.py
index 7de956d2..ddeb3bf9 100644
--- a/agentigrid/tests/analyses/test_sweep_reporting.py
+++ b/agentigrid/tests/analyses/test_sweep_reporting.py
@@ -12,7 +12,7 @@
 
 import pytest
 
-from agentigrid.engine.agent_loop import _infeasible_reason
+from agentigrid.exago_engine.agent_loop import _infeasible_reason
 
 
 # ---------------------------------------------------------------------------
diff --git a/agentigrid/tests/analyses/test_topology.py b/agentigrid/tests/analyses/test_topology.py
index bc7a6e55..cbf4a1ae 100644
--- a/agentigrid/tests/analyses/test_topology.py
+++ b/agentigrid/tests/analyses/test_topology.py
@@ -1,4 +1,4 @@
-"""Tests for agentigrid.engine.topology and the structured topology analyze queries.
+"""Tests for agentigrid.exago_engine.topology and the structured topology analyze queries.
 
 Covers:
 - incident_branches: stable file order, parallel circuits preserved, out-of-service exclusion
@@ -17,10 +17,10 @@
 
 import pytest
 
-from agentigrid.engine import contingency as C
-from agentigrid.engine.topology import format_incident_branches_view, incident_branches
-from agentigrid.parsers.matpower_model import Branch, Bus, MATNetwork
-from agentigrid.parsers.matpower_parser import parse_matpower
+from agentigrid.exago_engine import contingency as C
+from agentigrid.exago_engine.topology import format_incident_branches_view, incident_branches
+from agentigrid.exago_parsers.matpower_model import Branch, Bus, MATNetwork
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
 
 DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 IEEE118 = DATA_DIR / "ieee_118_bus_v10.m"
@@ -151,7 +151,7 @@ class TestHandlerLevel:
 
     def _make_controller(self, net118):
         """Minimal stub that exposes only the attributes _handle_topology_analyze reads."""
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
 
         ctrl = AgentLoopController.__new__(AgentLoopController)
         ctrl._config = MagicMock()
@@ -246,7 +246,7 @@ def test_unknown_query_type_returns_error(self, net118, query_type):
     def test_no_backend_call_made(self, net118):
         """Structured topology query must not invoke any backend."""
         ctrl = self._make_controller(net118)
-        with patch("agentigrid.engine.agent_loop.create_backend") as mock_backend:
+        with patch("agentigrid.exago_engine.agent_loop.create_backend") as mock_backend:
             self._affected(ctrl)
             mock_backend.assert_not_called()
 
diff --git a/agentigrid/tests/commands/test_cow_modifier.py b/agentigrid/tests/commands/test_cow_modifier.py
index 6d7a327f..8b5bb767 100644
--- a/agentigrid/tests/commands/test_cow_modifier.py
+++ b/agentigrid/tests/commands/test_cow_modifier.py
@@ -21,11 +21,11 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine.agent_loop import AgentLoopController
-from agentigrid.engine.executor import SimulationResult
-from agentigrid.engine import modifier as M
-from agentigrid.engine.commands import parse_command
-from agentigrid.engine.modifier import (
+from agentigrid.exago_engine.agent_loop import AgentLoopController
+from agentigrid.exago_engine.executor import SimulationResult
+from agentigrid.exago_engine import modifier as M
+from agentigrid.exago_engine.commands import parse_command
+from agentigrid.exago_engine.modifier import (
     apply_modifications,
     build_index_maps,
     _build_index_maps,
@@ -33,9 +33,9 @@
     _gen_index_in_network,
     _branch_index_in_network,
 )
-from agentigrid.engine.validation import validate_command
-from agentigrid.parsers.matpower_parser import parse_matpower
-from agentigrid.parsers.matpower_writer import write_matpower
+from agentigrid.exago_engine.validation import validate_command
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.matpower_writer import write_matpower
 
 _DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 _IEEE118 = _DATA_DIR / "ieee_118_bus_v10.m"
@@ -235,8 +235,8 @@ def test_sweep_regression(tmp_path):
 
     captured = {"tasks": None}
 
-    with patch("agentigrid.engine.agent_loop.create_backend", return_value=MagicMock()), \
-         patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+    with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=MagicMock()), \
+         patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
         mock_executor = MagicMock()
         mock_executor.run.return_value = _sim()
 
@@ -424,8 +424,8 @@ def test_sweep_builds_maps_once(tmp_path):
     cfg = _make_config(tmp_path, _IEEE118)
     captured = {"tasks": None}
 
-    with patch("agentigrid.engine.agent_loop.create_backend", return_value=MagicMock()), \
-         patch("agentigrid.engine.agent_loop.SimulationExecutor") as mock_exec_cls:
+    with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=MagicMock()), \
+         patch("agentigrid.exago_engine.agent_loop.SimulationExecutor") as mock_exec_cls:
         mock_executor = MagicMock()
         mock_executor.run.return_value = _sim()
 
diff --git a/agentigrid/tests/commands/test_engine.py b/agentigrid/tests/commands/test_engine.py
index 2a3be659..a215d3eb 100644
--- a/agentigrid/tests/commands/test_engine.py
+++ b/agentigrid/tests/commands/test_engine.py
@@ -6,8 +6,8 @@
 
 import pytest
 
-from agentigrid.engine import process_commands
-from agentigrid.engine.commands import (
+from agentigrid.exago_engine import process_commands
+from agentigrid.exago_engine.commands import (
     ScaleAllLoads,
     ScaleLoad,
     SetBranchStatus,
@@ -18,10 +18,10 @@
     SetLoad,
     parse_command,
 )
-from agentigrid.engine.modifier import apply_modifications
-from agentigrid.engine.schema_description import command_schema_text
-from agentigrid.engine.validation import validate_command
-from agentigrid.parsers import parse_matpower
+from agentigrid.exago_engine.modifier import apply_modifications
+from agentigrid.exago_engine.schema_description import command_schema_text
+from agentigrid.exago_engine.validation import validate_command
+from agentigrid.exago_parsers import parse_matpower
 
 DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 ACTIVSG200 = DATA_DIR / "case_ACTIVSg200.m"
diff --git a/agentigrid/tests/e2e/test_e2e.py b/agentigrid/tests/e2e/test_e2e.py
index 5766d4e5..05ae5f1f 100644
--- a/agentigrid/tests/e2e/test_e2e.py
+++ b/agentigrid/tests/e2e/test_e2e.py
@@ -15,7 +15,7 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine.agent_loop import AgentLoopController, SearchSession
+from agentigrid.exago_engine.agent_loop import AgentLoopController, SearchSession
 
 # ---------------------------------------------------------------------------
 # Paths and availability checks
@@ -169,7 +169,7 @@ def test_base_case_then_complete(self, tmp_path: Path):
 
         mock_backend = MockBackend(responses)
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend):
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend):
             controller = AgentLoopController(cfg, quiet=True)
             session = controller.run(BASE_CASE, "Report the base case results")
 
@@ -207,7 +207,7 @@ def test_modify_then_complete(self, tmp_path: Path):
 
         mock_backend = MockBackend(responses)
 
-        with patch("agentigrid.engine.agent_loop.create_backend", return_value=mock_backend):
+        with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=mock_backend):
             controller = AgentLoopController(cfg, quiet=True)
             session = controller.run(BASE_CASE, "Test 5% load increase")
 
diff --git a/agentigrid/tests/exago/test_benchmark.py b/agentigrid/tests/exago/test_benchmark.py
index 9f39fef2..c35296fc 100644
--- a/agentigrid/tests/exago/test_benchmark.py
+++ b/agentigrid/tests/exago/test_benchmark.py
@@ -6,7 +6,7 @@
 from unittest.mock import patch, MagicMock
 from dataclasses import dataclass
 
-from agentigrid.engine.benchmark import (
+from agentigrid.exago_engine.benchmark import (
     BenchmarkResult,
     DispatchComparison,
     LoadabilityResult,
@@ -15,8 +15,8 @@
     _format_benchmark_summary,
     _extract_pflow_max_factor,
 )
-from agentigrid.engine.journal import SearchJournal, JournalEntry
-from agentigrid.parsers.opflow_results import OPFLOWResult, GenResult
+from agentigrid.exago_engine.journal import SearchJournal, JournalEntry
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult, GenResult
 
 
 # ---------------------------------------------------------------------------
@@ -332,16 +332,16 @@ def test_with_loadability(self):
 # ---------------------------------------------------------------------------
 
 class TestBenchmarkIntegration:
-    @patch("agentigrid.engine.benchmark.SimulationExecutor")
+    @patch("agentigrid.exago_engine.benchmark.SimulationExecutor")
     def test_successful_benchmark(self, MockExecutor, opflow_result_converged, pflow_result_feasible):
         mock_instance = MagicMock()
         MockExecutor.return_value = mock_instance
         mock_instance.run.return_value = MagicMock(success=True, error_message=None)
 
-        with patch("agentigrid.engine.benchmark.parse_simulation_result_for_app") as mock_parse:
+        with patch("agentigrid.exago_engine.benchmark.parse_simulation_result_for_app") as mock_parse:
             mock_parse.return_value = opflow_result_converged
 
-            with patch("agentigrid.engine.benchmark.parse_matpower") as mock_net:
+            with patch("agentigrid.exago_engine.benchmark.parse_matpower") as mock_net:
                 mock_net.return_value = MagicMock(gencost=[])
 
                 result = run_pflow_vs_opflow_benchmark(
@@ -357,13 +357,13 @@ def test_successful_benchmark(self, MockExecutor, opflow_result_converged, pflow
         assert result.opflow_converged is True
         assert result.opflow_objective == 27557.57
 
-    @patch("agentigrid.engine.benchmark.SimulationExecutor")
+    @patch("agentigrid.exago_engine.benchmark.SimulationExecutor")
     def test_opflow_failure(self, MockExecutor):
         mock_instance = MagicMock()
         MockExecutor.return_value = mock_instance
         mock_instance.run.return_value = MagicMock(success=False, error_message="OPFLOW failed")
 
-        with patch("agentigrid.engine.benchmark.parse_matpower") as mock_net:
+        with patch("agentigrid.exago_engine.benchmark.parse_matpower") as mock_net:
             mock_net.return_value = MagicMock(gencost=[])
 
             result = run_pflow_vs_opflow_benchmark(
@@ -378,13 +378,13 @@ def test_opflow_failure(self, MockExecutor):
         assert result.error is not None
         assert "failed" in result.error.lower()
 
-    @patch("agentigrid.engine.benchmark.SimulationExecutor")
+    @patch("agentigrid.exago_engine.benchmark.SimulationExecutor")
     def test_with_pflow_best_result(self, MockExecutor, opflow_result_converged, pflow_result_feasible):
         mock_instance = MagicMock()
         MockExecutor.return_value = mock_instance
         mock_instance.run.return_value = MagicMock(success=True, error_message=None)
 
-        with patch("agentigrid.engine.benchmark.parse_simulation_result_for_app") as mock_parse:
+        with patch("agentigrid.exago_engine.benchmark.parse_simulation_result_for_app") as mock_parse:
             mock_parse.return_value = opflow_result_converged
 
             mock_gencost = MagicMock()
@@ -395,7 +395,7 @@ def test_with_pflow_best_result(self, MockExecutor, opflow_result_converged, pfl
             mock_net = MagicMock()
             mock_net.gencost = mock_gencost
 
-            with patch("agentigrid.engine.benchmark.parse_matpower") as mock_parse_net:
+            with patch("agentigrid.exago_engine.benchmark.parse_matpower") as mock_parse_net:
                 mock_parse_net.return_value = mock_net
 
                 result = run_pflow_vs_opflow_benchmark(
diff --git a/agentigrid/tests/exago/test_dcopflow.py b/agentigrid/tests/exago/test_dcopflow.py
index f2cae22b..eec9e46c 100644
--- a/agentigrid/tests/exago/test_dcopflow.py
+++ b/agentigrid/tests/exago/test_dcopflow.py
@@ -5,13 +5,13 @@
 import pytest
 from pathlib import Path
 
-from agentigrid.parsers.opflow_parser import parse_opflow_output
-from agentigrid.parsers.dcopflow_summary import dcopflow_results_summary
-from agentigrid.parsers import results_summary_for_app, parse_simulation_result_for_app
-from agentigrid.engine.metric_extractor import available_metrics, available_metrics_for_app
-from agentigrid.engine.commands import SetGenVoltage, SetBusVLimits, SetAllBusVLimits, ScaleAllLoads
-from agentigrid.engine.modifier import apply_modifications
-from agentigrid.parsers.matpower_model import MATNetwork, Bus, Generator, Branch, GenCost
+from agentigrid.exago_parsers.opflow_parser import parse_opflow_output
+from agentigrid.exago_parsers.dcopflow_summary import dcopflow_results_summary
+from agentigrid.exago_parsers import results_summary_for_app, parse_simulation_result_for_app
+from agentigrid.exago_engine.metric_extractor import available_metrics, available_metrics_for_app
+from agentigrid.exago_engine.commands import SetGenVoltage, SetBusVLimits, SetAllBusVLimits, ScaleAllLoads
+from agentigrid.exago_engine.modifier import apply_modifications
+from agentigrid.exago_parsers.matpower_model import MATNetwork, Bus, Generator, Branch, GenCost
 
 
 # ---------------------------------------------------------------------------
@@ -311,7 +311,7 @@ class TestDCOPFLOWModifier:
 
     def test_set_gen_voltage_skipped(self, minimal_network):
         """set_gen_voltage should be skipped with warning for dcopflow."""
-        from agentigrid.engine.commands import SetGenVoltage
+        from agentigrid.exago_engine.commands import SetGenVoltage
         cmd = SetGenVoltage(bus=1, Vg=1.05)
         _, report = apply_modifications(minimal_network, [cmd], application="dcopflow")
         assert len(report.applied) == 0
@@ -320,7 +320,7 @@ def test_set_gen_voltage_skipped(self, minimal_network):
 
     def test_set_bus_vlimits_skipped(self, minimal_network):
         """set_bus_vlimits should be skipped with warning for dcopflow."""
-        from agentigrid.engine.commands import SetBusVLimits
+        from agentigrid.exago_engine.commands import SetBusVLimits
         cmd = SetBusVLimits(bus=1, Vmin=0.95, Vmax=1.05)
         _, report = apply_modifications(minimal_network, [cmd], application="dcopflow")
         assert len(report.applied) == 0
@@ -328,7 +328,7 @@ def test_set_bus_vlimits_skipped(self, minimal_network):
 
     def test_set_all_bus_vlimits_skipped(self, minimal_network):
         """set_all_bus_vlimits should be skipped with warning for dcopflow."""
-        from agentigrid.engine.commands import SetAllBusVLimits
+        from agentigrid.exago_engine.commands import SetAllBusVLimits
         cmd = SetAllBusVLimits(Vmin=0.95, Vmax=1.05)
         _, report = apply_modifications(minimal_network, [cmd], application="dcopflow")
         assert len(report.applied) == 0
@@ -336,7 +336,7 @@ def test_set_all_bus_vlimits_skipped(self, minimal_network):
 
     def test_load_commands_still_work(self, minimal_network):
         """Non-voltage commands should work normally for dcopflow."""
-        from agentigrid.engine.commands import ScaleAllLoads
+        from agentigrid.exago_engine.commands import ScaleAllLoads
         cmd = ScaleAllLoads(factor=1.1)
         modified, report = apply_modifications(minimal_network, [cmd], application="dcopflow")
         assert len(report.applied) == 1
@@ -346,7 +346,7 @@ def test_load_commands_still_work(self, minimal_network):
 
     def test_voltage_cmds_applied_for_opflow(self, minimal_network):
         """Voltage commands should still be applied for opflow (not skipped)."""
-        from agentigrid.engine.commands import SetAllBusVLimits
+        from agentigrid.exago_engine.commands import SetAllBusVLimits
         cmd = SetAllBusVLimits(Vmin=0.95, Vmax=1.05)
         _, report = apply_modifications(minimal_network, [cmd], application="opflow")
         assert len(report.applied) == 1
diff --git a/agentigrid/tests/exago/test_pflow.py b/agentigrid/tests/exago/test_pflow.py
index ec433e21..6594051c 100644
--- a/agentigrid/tests/exago/test_pflow.py
+++ b/agentigrid/tests/exago/test_pflow.py
@@ -6,23 +6,23 @@
 from pathlib import Path
 from unittest.mock import MagicMock
 
-from agentigrid.parsers.pflow_parser import parse_pflow_output, parse_pflow_simulation_result
-from agentigrid.parsers.pflow_summary import pflow_results_summary
-from agentigrid.parsers import (
+from agentigrid.exago_parsers.pflow_parser import parse_pflow_output, parse_pflow_simulation_result
+from agentigrid.exago_parsers.pflow_summary import pflow_results_summary
+from agentigrid.exago_parsers import (
     results_summary_for_app,
     parse_simulation_result_for_app,
     parse_pflow_metadata,
 )
-from agentigrid.parsers.opflow_results import OPFLOWResult, BusResult, GenResult
-from agentigrid.parsers.matpower_model import MATNetwork, Bus, Generator, Branch, GenCost
-from agentigrid.engine.commands import (
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult, BusResult, GenResult
+from agentigrid.exago_parsers.matpower_model import MATNetwork, Bus, Generator, Branch, GenCost
+from agentigrid.exago_engine.commands import (
     SetTapRatio, SetShuntSusceptance, SetPhaseShiftAngle,
     SetGenVoltage, ScaleAllLoads, SetAllBusVLimits,
 )
-from agentigrid.engine.modifier import apply_modifications
-from agentigrid.engine.validation import validate_command
-from agentigrid.engine.metric_extractor import available_metrics_for_app
-from agentigrid.engine.goal_classifier import build_classification_prompts
+from agentigrid.exago_engine.modifier import apply_modifications
+from agentigrid.exago_engine.validation import validate_command
+from agentigrid.exago_engine.metric_extractor import available_metrics_for_app
+from agentigrid.exago_engine.goal_classifier import build_classification_prompts
 from agentigrid.prompts.exago.system_prompt import build_system_prompt, _app_section
 
 
@@ -433,7 +433,7 @@ class TestPFLOWCommands:
     """Test new PFLOW-specific commands: SetTapRatio, SetShuntSusceptance, SetPhaseShiftAngle."""
 
     def test_parse_set_tap_ratio(self):
-        from agentigrid.engine.commands import parse_command, SetTapRatio
+        from agentigrid.exago_engine.commands import parse_command, SetTapRatio
         cmd = parse_command({"action": "set_tap_ratio", "fbus": 1, "tbus": 3, "ratio": 1.05})
         assert isinstance(cmd, SetTapRatio)
         assert cmd.fbus == 1
@@ -441,14 +441,14 @@ def test_parse_set_tap_ratio(self):
         assert cmd.ratio == 1.05
 
     def test_parse_set_shunt_susceptance(self):
-        from agentigrid.engine.commands import parse_command, SetShuntSusceptance
+        from agentigrid.exago_engine.commands import parse_command, SetShuntSusceptance
         cmd = parse_command({"action": "set_shunt_susceptance", "bus": 2, "Bs": 0.5})
         assert isinstance(cmd, SetShuntSusceptance)
         assert cmd.bus == 2
         assert cmd.Bs == 0.5
 
     def test_parse_set_phase_shift_angle(self):
-        from agentigrid.engine.commands import parse_command, SetPhaseShiftAngle
+        from agentigrid.exago_engine.commands import parse_command, SetPhaseShiftAngle
         cmd = parse_command({"action": "set_phase_shift_angle", "fbus": 2, "tbus": 3, "angle": 5.0})
         assert isinstance(cmd, SetPhaseShiftAngle)
         assert cmd.fbus == 2
@@ -456,12 +456,12 @@ def test_parse_set_phase_shift_angle(self):
         assert cmd.angle == 5.0
 
     def test_parse_set_tap_ratio_with_ckt(self):
-        from agentigrid.engine.commands import parse_command
+        from agentigrid.exago_engine.commands import parse_command
         cmd = parse_command({"action": "set_tap_ratio", "fbus": 1, "tbus": 3, "ratio": 1.05, "ckt": 0})
         assert cmd.ckt == 0
 
     def test_command_map_has_pflow_commands(self):
-        from agentigrid.engine.commands import _COMMAND_MAP
+        from agentigrid.exago_engine.commands import _COMMAND_MAP
         assert "set_tap_ratio" in _COMMAND_MAP
         assert "set_shunt_susceptance" in _COMMAND_MAP
         assert "set_phase_shift_angle" in _COMMAND_MAP
@@ -719,14 +719,14 @@ class TestPFLOWSchemaDescription:
     """Test that the command schema includes PFLOW-specific commands."""
 
     def test_schema_has_pflow_commands(self):
-        from agentigrid.engine.schema_description import command_schema_text
+        from agentigrid.exago_engine.schema_description import command_schema_text
         schema = command_schema_text()
         assert "set_tap_ratio" in schema
         assert "set_shunt_susceptance" in schema
         assert "set_phase_shift_angle" in schema
 
     def test_schema_set_gen_voltage_mentions_pflow(self):
-        from agentigrid.engine.schema_description import command_schema_text
+        from agentigrid.exago_engine.schema_description import command_schema_text
         schema = command_schema_text()
         assert "PFLOW" in schema
         assert "set_gen_voltage" in schema
diff --git a/agentigrid/tests/exago/test_scopflow.py b/agentigrid/tests/exago/test_scopflow.py
index 4ca69c1b..a35f72b4 100644
--- a/agentigrid/tests/exago/test_scopflow.py
+++ b/agentigrid/tests/exago/test_scopflow.py
@@ -6,14 +6,14 @@
 from pathlib import Path
 from unittest.mock import MagicMock
 
-from agentigrid.parsers.scopflow_parser import parse_scopflow_output, parse_scopflow_simulation_result
-from agentigrid.parsers.scopflow_summary import scopflow_results_summary
-from agentigrid.parsers import (
+from agentigrid.exago_parsers.scopflow_parser import parse_scopflow_output, parse_scopflow_simulation_result
+from agentigrid.exago_parsers.scopflow_summary import scopflow_results_summary
+from agentigrid.exago_parsers import (
     results_summary_for_app,
     parse_simulation_result_for_app,
     parse_scopflow_metadata,
 )
-from agentigrid.parsers.opflow_parser import parse_opflow_output
+from agentigrid.exago_parsers.opflow_parser import parse_opflow_output
 from agentigrid.config import SearchConfig
 
 
diff --git a/agentigrid/tests/exago/test_sopflow.py b/agentigrid/tests/exago/test_sopflow.py
index ac221e64..2f67ef54 100644
--- a/agentigrid/tests/exago/test_sopflow.py
+++ b/agentigrid/tests/exago/test_sopflow.py
@@ -7,31 +7,31 @@
 from pathlib import Path
 from unittest.mock import MagicMock
 
-from agentigrid.parsers.sopflow_parser import (
+from agentigrid.exago_parsers.sopflow_parser import (
     parse_sopflow_output,
     parse_sopflow_simulation_result,
 )
-from agentigrid.parsers.sopflow_summary import sopflow_results_summary
-from agentigrid.parsers import (
+from agentigrid.exago_parsers.sopflow_summary import sopflow_results_summary
+from agentigrid.exago_parsers import (
     results_summary_for_app,
     parse_simulation_result_for_app,
     parse_sopflow_metadata as dispatch_sopflow_metadata,
 )
-from agentigrid.parsers.opflow_parser import parse_opflow_output
+from agentigrid.exago_parsers.opflow_parser import parse_opflow_output
 from agentigrid.config import SearchConfig
-from agentigrid.engine.metric_extractor import available_metrics, available_metrics_for_app
-from agentigrid.engine.commands import ScaleWindScenario, parse_command
-from agentigrid.engine.modifier import (
+from agentigrid.exago_engine.metric_extractor import available_metrics, available_metrics_for_app
+from agentigrid.exago_engine.commands import ScaleWindScenario, parse_command
+from agentigrid.exago_engine.modifier import (
     apply_modifications,
     scale_wind_scenario_csv,
     scale_load_profile_csv,
     ModificationReport,
 )
-from agentigrid.parsers.matpower_model import MATNetwork, Bus, Generator, Branch, GenCost
-from agentigrid.engine.journal import SearchJournal, JournalEntry
+from agentigrid.exago_parsers.matpower_model import MATNetwork, Bus, Generator, Branch, GenCost
+from agentigrid.exago_engine.journal import SearchJournal, JournalEntry
 from agentigrid.prompts.exago.system_prompt import build_system_prompt
-from agentigrid.engine.schema_description import command_schema_text
-from agentigrid.engine.goal_classifier import build_classification_prompts
+from agentigrid.exago_engine.schema_description import command_schema_text
+from agentigrid.exago_engine.goal_classifier import build_classification_prompts
 
 
 # ---------------------------------------------------------------------------
@@ -756,7 +756,7 @@ def test_scale_wind_scenario_cumulative(self, tmp_path):
         assert float(lines[1].split(",")[1]) == pytest.approx(12.0, abs=0.1)
 
     def test_scale_load_profile_skipped_for_sopflow(self, tmp_path):
-        from agentigrid.engine.commands import ScaleLoadProfile
+        from agentigrid.exago_engine.commands import ScaleLoadProfile
         p_path = tmp_path / "load_P.csv"
         q_path = tmp_path / "load_Q.csv"
         p_path.write_text("T,B1\n0,100.0\n")
@@ -814,7 +814,7 @@ def test_num_scenarios_set(self):
 
     def test_add_from_results_with_num_scenarios(self):
         journal = SearchJournal()
-        from agentigrid.parsers.opflow_results import OPFLOWResult
+        from agentigrid.exago_parsers.opflow_results import OPFLOWResult
         result = OPFLOWResult(
             converged=True, objective_value=100.0, convergence_status="CONVERGED",
             solver="IPOPT", model="POWER_BALANCE_POLAR",
@@ -942,13 +942,13 @@ def test_match_scenarios_no_match(self, tmp_path):
 
 class TestScenarioRowCount:
     def test_count_scenario_rows_single_period(self, tmp_path):
-        from agentigrid.engine.agent_loop import _count_scenario_rows
+        from agentigrid.exago_engine.agent_loop import _count_scenario_rows
         csv_path = tmp_path / "case9_10_scenarios.csv"
         csv_path.write_text("scenario_nr,3_Wind_1,weight\n1,85.0,0.1\n2,105.0,0.1\n")
         assert _count_scenario_rows(csv_path) == 2
 
     def test_count_scenario_rows_multi_period(self, tmp_path):
-        from agentigrid.engine.agent_loop import _count_scenario_rows
+        from agentigrid.exago_engine.agent_loop import _count_scenario_rows
         csv_path = tmp_path / "case9_scenarios.csv"
         csv_path.write_text(
             "sim_timestamp,scenario_nr,3_Wind_1\n"
@@ -959,7 +959,7 @@ def test_count_scenario_rows_multi_period(self, tmp_path):
         assert _count_scenario_rows(csv_path) == 3
 
     def test_count_scenario_rows_missing_file(self, tmp_path):
-        from agentigrid.engine.agent_loop import _count_scenario_rows
+        from agentigrid.exago_engine.agent_loop import _count_scenario_rows
         csv_path = tmp_path / "nonexistent.csv"
         assert _count_scenario_rows(csv_path) == 1
 
@@ -970,7 +970,7 @@ class TestSOPFLOWAnalyzeHandler:
 
     @pytest.fixture
     def sopflow_loop(self):
-        from agentigrid.engine.agent_loop import AgentLoopController
+        from agentigrid.exago_engine.agent_loop import AgentLoopController
         result, _ = parse_sopflow_output(SAMPLE_SOPFLOW_OUTPUT)
         loop = MagicMock(spec=AgentLoopController)
         loop._latest_opflow = result
diff --git a/agentigrid/tests/exago/test_sopflow_empar_masking.py b/agentigrid/tests/exago/test_sopflow_empar_masking.py
index f9b5e708..7cac98bc 100644
--- a/agentigrid/tests/exago/test_sopflow_empar_masking.py
+++ b/agentigrid/tests/exago/test_sopflow_empar_masking.py
@@ -18,11 +18,11 @@
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
     load_config,
 )
-from agentigrid.parsers import all_scenarios_converged
-from agentigrid.parsers.opflow_results import OPFLOWResult
-import agentigrid.parsers.sopflow_parser as SP
-from agentigrid.parsers.sopflow_parser import parse_sopflow_simulation_result
-from agentigrid.parsers.sopflow_summary import sopflow_results_summary
+from agentigrid.exago_parsers import all_scenarios_converged
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
+import agentigrid.exago_parsers.sopflow_parser as SP
+from agentigrid.exago_parsers.sopflow_parser import parse_sopflow_simulation_result
+from agentigrid.exago_parsers.sopflow_summary import sopflow_results_summary
 
 _DATA = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 _ACTIVSG200 = _DATA / "case_ACTIVSg200.m"
@@ -237,7 +237,7 @@ def test_config_flag_override_false():
 
 
 def _controller(tmp_path, application="sopflow", flag=True):
-    from agentigrid.engine.agent_loop import AgentLoopController
+    from agentigrid.exago_engine.agent_loop import AgentLoopController
     cfg = AppConfig(
         exago=ExagoConfig(binary_dir=tmp_path/"bin", opflow_binary=None, scopflow_binary=None,
             tcopflow_binary=None, sopflow_binary=None, dcopflow_binary=None, pflow_binary=None,
@@ -250,14 +250,14 @@ def _controller(tmp_path, application="sopflow", flag=True):
         output=OutputConfig(workdir=tmp_path/"wd", logs_dir=tmp_path/"logs", save_journal=False,
             journal_format="json", save_modified_files=False, verbose=False),
     )
-    with patch("agentigrid.engine.agent_loop.create_backend", return_value=MagicMock()), \
-         patch("agentigrid.engine.agent_loop.SimulationExecutor"):
+    with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=MagicMock()), \
+         patch("agentigrid.exago_engine.agent_loop.SimulationExecutor"):
         return AgentLoopController(cfg)
 
 
 @pytest.mark.skipif(not _ACTIVSG200.exists(), reason="case_ACTIVSg200.m not available")
 def test_partb_lowers_wind_pmin_when_on(tmp_path):
-    from agentigrid.parsers.matpower_parser import parse_matpower
+    from agentigrid.exago_parsers.matpower_parser import parse_matpower
     ctrl = _controller(tmp_path, flag=True)
     ctrl._base_network = parse_matpower(_ACTIVSG200)
     ctrl._normalize_sopflow_wind_base()
@@ -270,7 +270,7 @@ def test_partb_lowers_wind_pmin_when_on(tmp_path):
 
 @pytest.mark.skipif(not _ACTIVSG200.exists(), reason="case_ACTIVSg200.m not available")
 def test_partb_noop_when_off(tmp_path):
-    from agentigrid.parsers.matpower_parser import parse_matpower
+    from agentigrid.exago_parsers.matpower_parser import parse_matpower
     ctrl = _controller(tmp_path, flag=False)
     ctrl._base_network = parse_matpower(_ACTIVSG200)
     before = {g.bus: g.Pmin for g in ctrl._base_network.generators}
@@ -281,7 +281,7 @@ def test_partb_noop_when_off(tmp_path):
 
 @pytest.mark.skipif(not _ACTIVSG200.exists(), reason="case_ACTIVSg200.m not available")
 def test_partb_noop_for_non_sopflow(tmp_path):
-    from agentigrid.parsers.matpower_parser import parse_matpower
+    from agentigrid.exago_parsers.matpower_parser import parse_matpower
     ctrl = _controller(tmp_path, application="opflow", flag=True)
     ctrl._base_network = parse_matpower(_ACTIVSG200)
     before = {id(g): g.Pmin for g in ctrl._base_network.generators}
diff --git a/agentigrid/tests/exago/test_sopflow_report_absorption.py b/agentigrid/tests/exago/test_sopflow_report_absorption.py
index 4a6448b4..37be09f7 100644
--- a/agentigrid/tests/exago/test_sopflow_report_absorption.py
+++ b/agentigrid/tests/exago/test_sopflow_report_absorption.py
@@ -59,7 +59,7 @@ def _session(entries, application="sopflow", num_scenarios=5):
 
 def test_absorption_rows_from_argv():
     session = _session([_entry(1), _entry(2)])
-    with patch("agentigrid.parsers.compute_wind_absorption", return_value=_WA) as m:
+    with patch("agentigrid.exago_parsers.compute_wind_absorption", return_value=_WA) as m:
         rows = ReportGenerator()._sopflow_absorption_rows(session)
     assert len(rows) == 2
     assert [e.iteration for e, _ in rows] == [1, 2]
@@ -73,7 +73,7 @@ def test_absorption_rows_fallback_to_command_string():
     # argv lacks -scenfile; the flat command string carries it instead.
     e = _entry(1, argv_has_scenfile=False,
                command="exago -netfile x.m -scenfile /wd/from_cmd.csv")
-    with patch("agentigrid.parsers.compute_wind_absorption", return_value=_WA) as m:
+    with patch("agentigrid.exago_parsers.compute_wind_absorption", return_value=_WA) as m:
         rows = ReportGenerator()._sopflow_absorption_rows(_session([e]))
     assert len(rows) == 1
     assert str(m.call_args[0][1]).endswith("from_cmd.csv")
@@ -81,28 +81,28 @@ def test_absorption_rows_fallback_to_command_string():
 
 def test_absorption_rows_skip_non_simulation_modes():
     session = _session([_entry(1, mode="sweep"), _entry(2, mode="explore")])
-    with patch("agentigrid.parsers.compute_wind_absorption", return_value=_WA):
+    with patch("agentigrid.exago_parsers.compute_wind_absorption", return_value=_WA):
         rows = ReportGenerator()._sopflow_absorption_rows(session)
     assert rows == []
 
 
 def test_absorption_rows_skip_missing_command():
     e = SimpleNamespace(iteration=1, mode="fresh", exago_command=None)
-    with patch("agentigrid.parsers.compute_wind_absorption", return_value=_WA):
+    with patch("agentigrid.exago_parsers.compute_wind_absorption", return_value=_WA):
         rows = ReportGenerator()._sopflow_absorption_rows(_session([e]))
     assert rows == []
 
 
 def test_absorption_rows_none_result_skipped():
     # workdir gone / files missing → compute returns None → no row.
-    with patch("agentigrid.parsers.compute_wind_absorption", return_value=None):
+    with patch("agentigrid.exago_parsers.compute_wind_absorption", return_value=None):
         rows = ReportGenerator()._sopflow_absorption_rows(_session([_entry(1)]))
     assert rows == []
 
 
 def test_absorption_rows_exception_guarded():
     # A bad workdir must never propagate out of report rendering.
-    with patch("agentigrid.parsers.compute_wind_absorption",
+    with patch("agentigrid.exago_parsers.compute_wind_absorption",
                side_effect=RuntimeError("bad workdir")):
         rows = ReportGenerator()._sopflow_absorption_rows(_session([_entry(1)]))
     assert rows == []
@@ -118,7 +118,7 @@ def _para_texts(elements):
 
 def test_section_renders_absorption_table():
     session = _session([_entry(1), _entry(2)])
-    with patch("agentigrid.parsers.compute_wind_absorption", return_value=_WA):
+    with patch("agentigrid.exago_parsers.compute_wind_absorption", return_value=_WA):
         elements = ReportGenerator()._build_sopflow_stochastic_section(session, 5)
 
     tables = [el for el in elements if isinstance(el, Table)]
@@ -140,7 +140,7 @@ def test_section_renders_absorption_table():
 
 def test_section_graceful_when_no_rows():
     session = _session([_entry(1)])
-    with patch("agentigrid.parsers.compute_wind_absorption", return_value=None):
+    with patch("agentigrid.exago_parsers.compute_wind_absorption", return_value=None):
         elements = ReportGenerator()._build_sopflow_stochastic_section(session, 5)
 
     tables = [el for el in elements if isinstance(el, Table)]
@@ -152,7 +152,7 @@ def test_section_graceful_when_no_rows():
 
 def test_section_never_raises_on_bad_workdir():
     session = _session([_entry(1, cwd="/definitely/not/here")])
-    with patch("agentigrid.parsers.compute_wind_absorption",
+    with patch("agentigrid.exago_parsers.compute_wind_absorption",
                side_effect=OSError("gone")):
         elements = ReportGenerator()._build_sopflow_stochastic_section(session, 5)
     # Falls back to the "not available" caption, no exception.
diff --git a/agentigrid/tests/exago/test_tcopflow.py b/agentigrid/tests/exago/test_tcopflow.py
index ecf7bcca..72e6e818 100644
--- a/agentigrid/tests/exago/test_tcopflow.py
+++ b/agentigrid/tests/exago/test_tcopflow.py
@@ -7,28 +7,28 @@
 from pathlib import Path
 from unittest.mock import MagicMock
 
-from agentigrid.parsers.tcopflow_parser import (
+from agentigrid.exago_parsers.tcopflow_parser import (
     parse_tcopflow_output,
     parse_tcopflow_simulation_result,
     parse_tcopflow_period_files,
     parse_tcopflow_metadata,
 )
-from agentigrid.parsers.tcopflow_summary import tcopflow_results_summary
-from agentigrid.parsers import (
+from agentigrid.exago_parsers.tcopflow_summary import tcopflow_results_summary
+from agentigrid.exago_parsers import (
     results_summary_for_app,
     parse_simulation_result_for_app,
     parse_tcopflow_metadata as dispatch_tcopflow_metadata,
 )
-from agentigrid.parsers.opflow_parser import parse_opflow_output
+from agentigrid.exago_parsers.opflow_parser import parse_opflow_output
 from agentigrid.config import SearchConfig
-from agentigrid.engine.metric_extractor import available_metrics, available_metrics_for_app
-from agentigrid.engine.commands import ScaleLoadProfile, parse_command
-from agentigrid.engine.modifier import apply_modifications, scale_load_profile_csv, ModificationReport
-from agentigrid.parsers.matpower_model import MATNetwork, Bus, Generator, Branch, GenCost
-from agentigrid.engine.journal import SearchJournal, JournalEntry
+from agentigrid.exago_engine.metric_extractor import available_metrics, available_metrics_for_app
+from agentigrid.exago_engine.commands import ScaleLoadProfile, parse_command
+from agentigrid.exago_engine.modifier import apply_modifications, scale_load_profile_csv, ModificationReport
+from agentigrid.exago_parsers.matpower_model import MATNetwork, Bus, Generator, Branch, GenCost
+from agentigrid.exago_engine.journal import SearchJournal, JournalEntry
 from agentigrid.prompts.exago.system_prompt import build_system_prompt
-from agentigrid.engine.schema_description import command_schema_text
-from agentigrid.engine.goal_classifier import build_classification_prompts
+from agentigrid.exago_engine.schema_description import command_schema_text
+from agentigrid.exago_engine.goal_classifier import build_classification_prompts
 
 
 # ---------------------------------------------------------------------------
@@ -675,7 +675,7 @@ def test_num_steps_set(self):
 
     def test_add_from_results_with_num_steps(self):
         journal = SearchJournal()
-        from agentigrid.parsers.opflow_results import OPFLOWResult
+        from agentigrid.exago_parsers.opflow_results import OPFLOWResult
         result = OPFLOWResult(
             converged=True, objective_value=100.0, convergence_status="CONVERGED",
             solver="IPOPT", model="POWER_BALANCE_POLAR",
diff --git a/agentigrid/tests/grid_files/test_parsers.py b/agentigrid/tests/grid_files/test_parsers.py
index 3f772e00..189b5af3 100644
--- a/agentigrid/tests/grid_files/test_parsers.py
+++ b/agentigrid/tests/grid_files/test_parsers.py
@@ -7,7 +7,7 @@
 
 import pytest
 
-from agentigrid.parsers import (
+from agentigrid.exago_parsers import (
     Branch,
     Bus,
     GenCost,
@@ -208,7 +208,7 @@ def test_minimal_case(self, tmp_path: Path):
 # Network metadata (Task 3) — static facts injected into the system prompt
 # ===========================================================================
 
-from agentigrid.parsers import network_metadata
+from agentigrid.exago_parsers import network_metadata
 
 
 @pytest.mark.skipif(not _has_test_file, reason="case_ACTIVSg200.m not in data/exago/examples/")
diff --git a/agentigrid/tests/gridkit/test_config.py b/agentigrid/tests/gridkit/test_config.py
new file mode 100644
index 00000000..0c8e3605
--- /dev/null
+++ b/agentigrid/tests/gridkit/test_config.py
@@ -0,0 +1,117 @@
+"""Tests for the gridkit: section of the shared config and how the GridKit
+code uses it (settings, solver .json, fault-study defaults, schema text)."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import pytest
+import yaml
+
+from agentigrid.config import GridkitConfig, load_config
+from agentigrid.gridkit_engine import criteria
+from agentigrid.gridkit_engine.commands import parse_fault_study
+from agentigrid.gridkit_engine.executor import RunJob, solver_file_content
+from agentigrid.gridkit_engine.schema_description import command_schema_text
+from agentigrid.gridkit_engine.settings import GridkitSettings
+
+CONFIGS = Path(__file__).resolve().parents[2] / "configs"
+SOLVER_KEYS = {"rel_tol", "abs_tol", "dt_fixed", "max_steps", "max_order"}
+
+
+def _write(tmp_path: Path, gridkit: dict) -> Path:
+    path = tmp_path / "config.yaml"
+    path.write_text(yaml.safe_dump({"gridkit": gridkit}))
+    return path
+
+
+class TestGridkitSection:
+    def test_defaults_match_current_code(self):
+        gk = load_config(None).gridkit
+        assert gk.timeout == 600
+        assert gk.study.tmax == criteria.SIM_LENGTH_S
+        assert gk.fault.start == criteria.FAULT_START_S
+        assert gk.study.dt_monitor == 0.01
+        assert gk.binary_dir.name == "gridkit"
+
+    @pytest.mark.parametrize("name", ["default_config.yaml.template", "local_config.yaml.template"])
+    def test_templates_have_both_tools(self, name):
+        raw = yaml.safe_load((CONFIGS / name).read_text())
+        assert "exago" in raw and "gridkit" in raw
+        gk = load_config(CONFIGS / name).gridkit
+        assert gk.study == GridkitConfig().study
+        assert gk.fault == GridkitConfig().fault
+
+    def test_partial_section_keeps_other_defaults(self, tmp_path):
+        gk = load_config(_write(tmp_path, {"study": {"tmax": 12.0}, "timeout": 90})).gridkit
+        assert gk.study.tmax == 12.0
+        assert gk.study.max_order == 5
+        assert gk.timeout == 90
+        assert gk.fault.start == 1.0
+
+    def test_empty_subsection_keeps_defaults(self, tmp_path):
+        path = tmp_path / "config.yaml"
+        path.write_text("gridkit:\n  study:\n  fault:\n")
+        gk = load_config(path).gridkit
+        assert gk.study == GridkitConfig().study
+        assert gk.fault == GridkitConfig().fault
+
+    def test_paths_resolved(self, tmp_path):
+        gk = load_config(_write(tmp_path, {"dynamicsimulation_binary": "bin/DS"})).gridkit
+        assert gk.binary_dir.is_absolute()
+        assert gk.dynamicsimulation_binary == (Path.cwd() / "bin/DS").resolve()
+
+    def test_unknown_key_warns(self, tmp_path, caplog):
+        # GridKit itself ignores a misspelled solver key without a word.
+        with caplog.at_level(logging.WARNING, logger="agentigrid.config"):
+            load_config(_write(tmp_path, {"study": {"rel_tool": 1e-6}}))
+        assert "rel_tool" in caplog.text
+
+    def test_bad_max_order_warns(self, tmp_path, caplog):
+        with caplog.at_level(logging.WARNING, logger="agentigrid.config"):
+            load_config(_write(tmp_path, {"study": {"max_order": 9}}))
+        assert "max_order" in caplog.text
+
+
+class TestSettingsFromConfig:
+    def test_values_carried(self, tmp_path):
+        cfg = load_config(_write(tmp_path, {
+            "timeout": 90, "study": {"tmax": 12.0, "rel_tol": 1e-6}, "fault": {"start": 0.5},
+        }))
+        s = GridkitSettings.from_config(cfg)
+        assert s.timeout_s == 90.0
+        assert s.tmax_s == 12.0
+        assert s.fault_start_s == 0.5
+        assert s.solver_options["rel_tol"] == 1e-6
+        assert set(s.solver_options) == SOLVER_KEYS
+        assert s.study_defaults() == {"start_s": 0.5, "tmax_s": 12.0, "dt_monitor_s": 0.01}
+
+    def test_binary_override(self, tmp_path):
+        cfg = load_config(_write(tmp_path, {"dynamicsimulation_binary": "/opt/gk/DS"}))
+        assert GridkitSettings.from_config(cfg).dynamic_simulation == Path("/opt/gk/DS")
+        assert GridkitSettings.from_config(load_config(None)).dynamic_simulation.name == "DynamicSimulation"
+
+    def test_keyword_override_wins(self):
+        s = GridkitSettings.from_config(load_config(None), binary_dir=Path("/x"), max_iterations=3)
+        assert s.binary_dir == Path("/x") and s.max_iterations == 3
+
+
+class TestUse:
+    def test_solver_file_has_config_keys(self, tmp_path):
+        job = RunJob(tmp_path / "run", tmp_path / "case.json", 15.0, 0.01, element_id=3,
+                     start_s=1.0, clear_s=1.1)
+        content = solver_file_content(job, GridkitSettings().solver_options)
+        assert SOLVER_KEYS <= set(content)
+        assert content["tmax"] == 15.0 and len(content["events"]) == 2
+        assert SOLVER_KEYS.isdisjoint(solver_file_content(job))
+
+    def test_fault_study_defaults(self):
+        s = parse_fault_study({"poi": 2}, {"start_s": 0.5, "tmax_s": 12.0, "dt_monitor_s": 0.02})
+        assert (s.start_s, s.tmax_s, s.dt_monitor_s) == (0.5, 12.0, 0.02)
+        s = parse_fault_study({"poi": 2, "tmax_s": 14.0}, {"tmax_s": 12.0})
+        assert s.tmax_s == 14.0      # the LLM's value wins over the config default
+
+    def test_schema_shows_config_defaults(self):
+        text = command_schema_text(start_s=0.5, tmax_s=12.0)
+        assert "start_s (0.5)" in text and "tmax_s (12.0)" in text
diff --git a/agentigrid/tests/gridkit/test_from_exago.py b/agentigrid/tests/gridkit/test_from_exago.py
new file mode 100644
index 00000000..74427fb5
--- /dev/null
+++ b/agentigrid/tests/gridkit/test_from_exago.py
@@ -0,0 +1,196 @@
+"""Tests for starting GridKit from the most recent ExaGO steady state."""
+
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+
+import pytest
+
+from agentigrid.exago_engine.executor import _CMD_BUILDERS
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.gridkit_engine.from_exago import (
+    SteadyStateError,
+    apply_steady_state,
+    find_latest_steady_state,
+    goal_wants_steady_state,
+)
+from agentigrid.gridkit_parsers.case_parser import MACHINE_CLASSES
+
+ROOT = Path(__file__).resolve().parents[2]
+EXAGO_200 = ROOT / "data" / "exago" / "examples" / "case_ACTIVSg200.m"
+GRIDKIT_200 = ROOT / "data" / "gridkit" / "examples" / "ACTIVSg200.case.json"
+needs_cases = pytest.mark.skipif(
+    not (EXAGO_200.exists() and GRIDKIT_200.exists()),
+    reason="ACTIVSg200 ExaGO/GridKit cases not linked",
+)
+
+
+# ---------------------------------------------------------------------------
+# Goal phrase and ExaGO command
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("goal", [
+    "Please use the most recent steady state simulation results and fault bus 5",
+    "start from the latest steady-state solution",
+    "Use the last steady state",
+])
+def test_goal_asks_for_steady_state(goal):
+    assert goal_wants_steady_state(goal)
+
+
+@pytest.mark.parametrize("goal", ["Fault every bus", "steady state check of bus 3", ""])
+def test_goal_does_not_ask(goal):
+    assert not goal_wants_steady_state(goal)
+
+
+@pytest.mark.parametrize("app,saves", [("opflow", True), ("pflow", True), ("dcopflow", False),
+                                       ("scopflow", False)])
+def test_exago_saves_steady_state(app, saves):
+    cmd = _CMD_BUILDERS[app](Path("/bin/x"), Path("/wd/case.m"), None)
+    assert ("-save_output" in cmd) == saves
+
+
+# ---------------------------------------------------------------------------
+# Finding the most recent steady state
+# ---------------------------------------------------------------------------
+
+def _entry(it, run_dir, app="opflow", status="CONVERGED", mode="single", desc="d"):
+    return {
+        "iteration": it, "description": desc, "convergence_status": status,
+        "exago_command": {"mode": mode, "application": app,
+                          "argv": [f"/bin/{app}", "-netfile", str(run_dir / "case.m"), "-print_output"]},
+    }
+
+
+def _workdir(tmp_path, entries, name="journal_20261007_120000.json", solved=("opflowout.m",)):
+    for e in entries:
+        if e.get("exago_command"):
+            d = Path(e["exago_command"]["argv"][2]).parent
+            d.mkdir(parents=True, exist_ok=True)
+            for f in solved:
+                (d / f).write_text("")
+    (tmp_path / name).write_text(json.dumps({"entries": entries}))
+    return tmp_path
+
+
+def test_last_simulation_of_newest_journal(tmp_path):
+    _workdir(tmp_path, [_entry(0, tmp_path / "old")], name="journal_20261007_100000.json")
+    _workdir(tmp_path, [_entry(0, tmp_path / "a"), _entry(1, tmp_path / "b", desc="gen off"),
+                        {"iteration": 2, "description": "Search completed", "exago_command": None}])
+    src = find_latest_steady_state(tmp_path)
+    assert src.iteration == 1 and src.run_dir == tmp_path / "b"
+    assert src.solved_file == tmp_path / "b" / "opflowout.m"
+    assert "gen off" in src.describe()
+
+
+def test_pflow_uses_journal_status(tmp_path):
+    # PFLOW's saved file says converged = 0 even when it converged.
+    _workdir(tmp_path, [_entry(0, tmp_path / "a", app="pflow", status="CONVERGED")],
+             solved=("pflowout.m",))
+    assert find_latest_steady_state(tmp_path).application == "pflow"
+
+
+@pytest.mark.parametrize("entry,match", [
+    (dict(status="DID NOT CONVERGE"), "did not converge"),
+    (dict(mode="sweep"), "not a single steady state"),
+    (dict(app="dcopflow"), "only"),
+])
+def test_most_recent_must_be_usable(tmp_path, entry, match):
+    # An older usable iteration exists, but there is no fallback to it.
+    _workdir(tmp_path, [_entry(0, tmp_path / "a"), _entry(1, tmp_path / "b", **entry)])
+    with pytest.raises(SteadyStateError, match=match):
+        find_latest_steady_state(tmp_path)
+
+
+def test_missing_solution_file(tmp_path):
+    _workdir(tmp_path, [_entry(0, tmp_path / "a")], solved=())
+    with pytest.raises(SteadyStateError, match="missing"):
+        find_latest_steady_state(tmp_path)
+
+
+def test_no_journal(tmp_path):
+    with pytest.raises(SteadyStateError, match="No ExaGO journal"):
+        find_latest_steady_state(tmp_path)
+
+
+# ---------------------------------------------------------------------------
+# Conversion (ACTIVSg200: same bus numbers in both cases)
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def pair():
+    return json.loads(GRIDKIT_200.read_text()), parse_matpower(EXAGO_200)
+
+
+def _devices(case, cls):
+    return [d for d in case["devices"] if d["class"] == cls]
+
+
+@needs_cases
+def test_operating_point_copied(pair):
+    case, net = pair
+    out, _ = apply_steady_state(case, net)
+    bus = {b["number"]: b for b in out["buses"]}[135]
+    mb = {b.bus_i: b for b in net.buses}[135]
+    assert math.hypot(bus["init"]["Vr"], bus["init"]["Vi"]) == pytest.approx(mb.Vm)
+    assert math.degrees(math.atan2(bus["init"]["Vi"], bus["init"]["Vr"])) == pytest.approx(mb.Va)
+    gen = next(g for g in net.generators if g.bus == 135)
+    m = next(d for d in _devices(out, "Genrou") if d["ports"]["bus"] == 135)
+    assert m["params"]["p0"] == pytest.approx(gen.Pg / net.baseMVA)
+    assert m["params"]["q0"] == pytest.approx(gen.Qg / net.baseMVA)
+    load2 = next(d for d in _devices(out, "LoadZIP") if d["ports"]["bus"] == 2)
+    assert load2["params"]["Pnom"] == pytest.approx(7.39 / 100)
+    assert case["buses"][0]["init"] != out["buses"][0]["init"]   # input case not changed
+
+
+@needs_cases
+def test_offline_machines_removed_with_controls(pair):
+    case, net = pair
+    out, notes = apply_steady_state(case, net)
+    ids = {d["id"] for d in out["devices"]}
+    for unit in ("161_1", "197_1"):
+        assert not any(i.startswith(unit) for i in ids)
+    used = {v for d in out["devices"] for k, v in d["ports"].items() if not k.startswith("bus")}
+    assert {s["signal_id"] for s in out["signals"]} == used
+    assert any("161_1_genrou" in n for n in notes)
+
+
+@needs_cases
+def test_generator_outage_removes_its_machine(pair):
+    case, net = pair
+    next(g for g in net.generators if g.bus == 135).status = 0
+    out, _ = apply_steady_state(case, net)
+    assert not any(d["ports"].get("bus") == 135 for d in out["devices"] if d["class"] in MACHINE_CLASSES)
+
+
+@needs_cases
+def test_shunts_and_branches_from_exago(pair):
+    case, net = pair
+    net.branches[0].status = 0
+    out, notes = apply_steady_state(case, net)
+    shunts = {d["ports"]["bus"]: d for d in _devices(out, "LoadZIP") if d["id"].startswith("shunt_")}
+    assert sorted(shunts) == [15, 95, 100, 194]
+    vm = {b.bus_i: b.Vm for b in net.buses}[15]
+    assert shunts[15]["params"]["Qnom"] == pytest.approx(-30 * vm * vm / 100)
+    assert len(_devices(out, "Branch")) == sum(1 for b in net.branches if b.status)
+    assert any("64-82" in n for n in notes)
+
+
+@needs_cases
+def test_generator_without_model_is_an_error(pair):
+    case, net = pair
+    machine_buses = {d["ports"]["bus"] for d in case["devices"] if d["class"] in MACHINE_CLASSES}
+    g = next(g for g in net.generators if g.bus not in machine_buses)
+    g.status = 1
+    with pytest.raises(SteadyStateError, match=f"bus\\(es\\) \\[{g.bus}\\].*no dynamic model"):
+        apply_steady_state(case, net)
+
+
+@needs_cases
+def test_bus_mismatch_is_an_error(pair):
+    case, net = pair
+    case["buses"] = case["buses"][1:]
+    with pytest.raises(SteadyStateError, match="Bus numbers differ"):
+        apply_steady_state(case, net)
diff --git a/agentigrid/tests/gridkit/test_screen_options.py b/agentigrid/tests/gridkit/test_screen_options.py
new file mode 100644
index 00000000..fdabf112
--- /dev/null
+++ b/agentigrid/tests/gridkit/test_screen_options.py
@@ -0,0 +1,177 @@
+"""Fault-screen options: start_from (case / latest ExaGO steady state) and
+application (DynamicSimulation / ContingencyAnalysis)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from agentigrid.exago_parsers.matpower_parser import parse_matpower
+from agentigrid.exago_parsers.matpower_writer import write_matpower
+from agentigrid.gridkit_engine.commands import parse_fault_study
+from agentigrid.gridkit_engine.modifier import prepare_fault_case
+from agentigrid.gridkit_parsers.case_parser import build_element_map
+
+from tests.gridkit.test_agent_loop import BINARY_DIR, IEEE39, _loop
+
+ROOT = Path(__file__).resolve().parents[2]
+EXAGO_200 = ROOT / "data" / "exago" / "examples" / "case_ACTIVSg200.m"
+GRIDKIT_200 = ROOT / "data" / "gridkit" / "examples" / "ACTIVSg200.case.json"
+
+needs_gridkit = pytest.mark.skipif(
+    not ((BINARY_DIR / "DynamicSimulation").exists() and IEEE39.exists()),
+    reason="GridKit DynamicSimulation or IEEE39 case not linked",
+)
+needs_ca = pytest.mark.skipif(
+    not ((BINARY_DIR / "ContingencyAnalysis").exists() and IEEE39.exists()),
+    reason="GridKit ContingencyAnalysis or IEEE39 case not linked",
+)
+needs_200 = pytest.mark.skipif(
+    not ((BINARY_DIR / "DynamicSimulation").exists() and EXAGO_200.exists()
+         and GRIDKIT_200.exists()),
+    reason="GridKit or ACTIVSg200 ExaGO/GridKit cases not linked",
+)
+
+COMPLETE = {"action": "complete", "summary": "VERDICT: ...", "details": "none"}
+
+
+# ---------------------------------------------------------------------------
+# Parsing
+# ---------------------------------------------------------------------------
+
+def test_defaults():
+    study = parse_fault_study({"action": "fault_screen", "buses": [3]})
+    assert study.start_from == "case" and study.application == "DynamicSimulation"
+
+
+@pytest.mark.parametrize("field,value", [("start_from", "yesterday"),
+                                         ("application", "PowerFlow")])
+def test_unknown_values_rejected(field, value):
+    with pytest.raises(ValueError, match=field):
+        parse_fault_study({"action": "fault_screen", "buses": [3], field: value})
+
+
+# ---------------------------------------------------------------------------
+# Case copy: other fault devices
+# ---------------------------------------------------------------------------
+
+@needs_gridkit
+@pytest.mark.parametrize("only,n_faults", [(False, 39), (True, 2)])
+def test_other_faults_in_case_copy(only, n_faults):
+    # IEEE39 ships a fault device at every bus.
+    case = json.loads(IEEE39.read_text())
+    emap = build_element_map(case)
+    study = parse_fault_study({"buses": [16, 3]})
+    work, wmap, fault_ids, _ = prepare_fault_case(case, study, emap, only_study_faults=only)
+    assert len(wmap["bus_faults"]) == n_faults
+    assert set(fault_ids) == {16, 3}
+    # element ids point at the right devices
+    by_id = {f["element_id"]: f["bus"] for f in wmap["bus_faults"]}
+    assert all(by_id[eid] == bus for bus, eid in fault_ids.items())
+
+
+# ---------------------------------------------------------------------------
+# ContingencyAnalysis gives the same results as DynamicSimulation
+# ---------------------------------------------------------------------------
+
+def _screen_rows(session):
+    journal = json.loads(session.journal_path.read_text())
+    return next(e for e in journal["entries"] if e["action"] == "fault_screen")
+
+
+@needs_ca
+def test_contingency_analysis_matches_dynamic_simulation(tmp_path):
+    screen = {"action": "fault_screen", "buses": [16, 3], "tmax_s": 4.0,
+              "checks": ["angle_stability", "voltage_recovery"]}
+    results = {}
+    for app in ("DynamicSimulation", "ContingencyAnalysis"):
+        loop, backend = _loop(tmp_path / app, [{**screen, "application": app}, COMPLETE])
+        session = loop.run(IEEE39, "Fault buses 16 and 3.")
+        assert session.termination_reason == "completed"
+        results[app] = _screen_rows(session)
+        assert f"GridKit {app}" in results[app]["verdict"]
+
+    ca = results["ContingencyAnalysis"]
+    run_dir = Path(ca["run_dir"]) / "contingency"
+    case_copy = json.loads((Path(ca["run_dir"]) / "case.json").read_text())
+    assert sorted(d["ports"]["bus"] for d in case_copy["devices"] if d["class"] == "BusFault") == [3, 16]
+    assert sorted(p.name for p in run_dir.glob("output_*.csv")) == ["output_0.csv", "output_1.csv"]
+
+    def values(entry):
+        return {r["bus"]: (r["solved"], r["status"]) for r in entry["rows"]}
+
+    assert values(ca) == values(results["DynamicSimulation"])
+    assert all(solved for solved, _ in values(ca).values())
+    assert ca["verdict"].split("(")[0] == results["DynamicSimulation"]["verdict"].split("(")[0]
+
+
+# ---------------------------------------------------------------------------
+# start_from: latest_steady_state
+# ---------------------------------------------------------------------------
+
+def _exago_workdir(root: Path, solved_from: Path) -> Path:
+    """An ExaGO workdir whose newest journal ends with a converged OPFLOW run
+    (its "solution" is *solved_from*, a case whose stored state is steady)."""
+    run_dir = root / "iter_001"
+    run_dir.mkdir(parents=True)
+    write_matpower(parse_matpower(solved_from), run_dir / "opflowout.m")
+    entry = {"iteration": 1, "description": "gen out", "convergence_status": "CONVERGED",
+             "exago_command": {"mode": "single", "application": "opflow",
+                               "argv": ["/bin/opflow", "-netfile", str(run_dir / "case.m")]}}
+    (root / "journal_20261008_120000.json").write_text(json.dumps({"entries": [entry]}))
+    return root
+
+
+def _loop_with_exago(tmp_path, replies, exago_dir):
+    from dataclasses import replace
+    loop, backend = _loop(tmp_path, replies)
+    loop._settings = replace(loop._settings, exago_workdir=exago_dir)
+    return loop, backend
+
+
+@needs_200
+def test_latest_steady_state_chosen_by_llm(tmp_path):
+    exago_dir = _exago_workdir(tmp_path / "exago", EXAGO_200)
+    screen = {"action": "fault_screen", "buses": [135], "tmax_s": 3.0,
+              "checks": ["angle_stability"], "start_from": "latest_steady_state"}
+    loop, backend = _loop_with_exago(tmp_path, [screen, COMPLETE], exago_dir)
+    session = loop.run(GRIDKIT_200, "Fault bus 135.")
+
+    assert session.termination_reason == "completed"
+    assert session.steady_state and "OPFLOW iteration 1" in session.steady_state
+    journal = json.loads(session.journal_path.read_text())
+    actions = [e["action"] for e in journal["entries"]]
+    # case base run, ExaGO start, its own base run, the screen
+    assert actions[:4] == ["base_case", "steady_state", "base_case", "fault_screen"]
+    assert (session.session_dir / "from_exago.case.json").exists()
+    copy = json.loads((Path(journal["entries"][3]["run_dir"]) / "case.json").read_text())
+    machines = {d["id"] for d in copy["devices"] if d["class"] in ("Genrou", "Gensal", "GenClassical")}
+    # ExaGO has generators 161 and 197 off: their machines are not in the copy
+    assert not any(m.startswith(("161_", "197_")) for m in machines)
+    assert any(m.startswith("135_") for m in machines)
+    assert "starting from the latest ExaGO steady state" in journal["entries"][3]["verdict"]
+    # what the LLM was told it may choose
+    assert "latest_steady_state" in backend.prompts[0][0]
+
+
+@needs_gridkit
+def test_goal_asking_for_steady_state_needs_start_from(tmp_path):
+    loop, backend = _loop_with_exago(tmp_path, [
+        {"action": "fault_screen", "buses": [16], "tmax_s": 2.0, "checks": ["angle_stability"]},
+        COMPLETE,
+    ], tmp_path / "no_exago")
+    session = loop.run(IEEE39, "Use the most recent steady state and fault bus 16.")
+    assert session.termination_reason == "completed"
+    assert '"start_from": "latest_steady_state"' in backend.prompts[1][1]
+
+
+@needs_gridkit
+def test_unusable_steady_state_is_reported_not_run(tmp_path):
+    screen = {"action": "fault_screen", "buses": [16], "tmax_s": 2.0,
+              "checks": ["angle_stability"], "start_from": "latest_steady_state"}
+    loop, backend = _loop_with_exago(tmp_path, [screen, COMPLETE], tmp_path / "no_exago")
+    session = loop.run(IEEE39, "Fault bus 16.")
+    assert session.termination_reason == "completed"
+    assert "NOT run" in backend.prompts[1][1] and "No ExaGO journal" in backend.prompts[1][1]
diff --git a/agentigrid/tests/gridkit/test_status_parser.py b/agentigrid/tests/gridkit/test_status_parser.py
index ad447f2a..25908bda 100644
--- a/agentigrid/tests/gridkit/test_status_parser.py
+++ b/agentigrid/tests/gridkit/test_status_parser.py
@@ -48,6 +48,12 @@ def test_clean_run(self, tmp_path):
         assert s.stderr_empty and not s.errors
         assert s.reason == "solved: reached t = 2 s in 1.33 s"
 
+    def test_contingency_analysis_complete_line(self, tmp_path):
+        # ContingencyAnalysis prints the duration as "<s>s", not "<s> seconds".
+        s = parse_run_status(0, _WARN + "\n\nComplete in 1.91939s\n", "",
+                             _csv(tmp_path / "o.csv", [0.0, 2.0]), tmax=2.0)
+        assert s.solved and s.runtime_s == pytest.approx(1.91939)
+
     def test_warnings_kept_once(self, tmp_path):
         s = parse_run_status(0, OK_STDOUT, "", _csv(tmp_path / "o.csv", [2.0]), tmax=2.0)
         assert s.warnings == [
diff --git a/agentigrid/tests/journal/test_journal.py b/agentigrid/tests/journal/test_journal.py
index 78ca87f5..7961d120 100644
--- a/agentigrid/tests/journal/test_journal.py
+++ b/agentigrid/tests/journal/test_journal.py
@@ -8,8 +8,8 @@
 
 import pytest
 
-from agentigrid.engine.journal import JournalEntry, SearchJournal
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine.journal import JournalEntry, SearchJournal
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 
 def _make_entry(iteration: int, obj: float = 1000.0, feasible: bool = True, **kw) -> JournalEntry:
@@ -248,7 +248,7 @@ class TestAddFromResultsPFLOWCost:
     rather than the misleading 0.0 sentinel."""
 
     def _pflow_result(self, gen_pgs: list[float]) -> OPFLOWResult:
-        from agentigrid.parsers.opflow_results import GenResult
+        from agentigrid.exago_parsers.opflow_results import GenResult
         gens = [
             GenResult(
                 bus=i + 1, status=1, fuel="COAL", Pg=pg, Qg=0.0,
@@ -265,7 +265,7 @@ def _pflow_result(self, gen_pgs: list[float]) -> OPFLOWResult:
         )
 
     def _gencost(self, tuples: list[tuple[float, float, float]]):
-        from agentigrid.parsers.matpower_model import GenCost
+        from agentigrid.exago_parsers.matpower_model import GenCost
         return [
             GenCost(model=2, startup=0.0, shutdown=0.0, ncost=3, coeffs=list(t))
             for t in tuples
@@ -330,7 +330,7 @@ def test_pflow_no_gencost_falls_through_to_zero(self):
 
     def test_pflow_offline_generators_yield_none(self):
         """If all generators are offline, computed cost is 0.0 → entry sees None."""
-        from agentigrid.parsers.opflow_results import GenResult
+        from agentigrid.exago_parsers.opflow_results import GenResult
         opf = _make_opflow_result(
             objective_value=0.0,
             solver="POWER_FLOW",
diff --git a/agentigrid/tests/journal/test_multi_objective.py b/agentigrid/tests/journal/test_multi_objective.py
index b4b4cb41..812372f2 100644
--- a/agentigrid/tests/journal/test_multi_objective.py
+++ b/agentigrid/tests/journal/test_multi_objective.py
@@ -5,12 +5,12 @@
 import json
 import pytest
 
-from agentigrid.engine.journal import (
+from agentigrid.exago_engine.journal import (
     JournalEntry, SearchJournal, ObjectiveEntry, ObjectiveRegistry,
 )
-from agentigrid.engine.metric_extractor import extract_metric, extract_all_metrics, available_metrics
-from agentigrid.engine.objective_parser import parse_objective_extraction
-from agentigrid.parsers.opflow_results import OPFLOWResult, BusResult, BranchResult, GenResult
+from agentigrid.exago_engine.metric_extractor import extract_metric, extract_all_metrics, available_metrics
+from agentigrid.exago_engine.objective_parser import parse_objective_extraction
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult, BusResult, BranchResult, GenResult
 
 
 # ── Fixtures ──────────────────────────────────────────────────────────────────
diff --git a/agentigrid/tests/journal/test_pareto.py b/agentigrid/tests/journal/test_pareto.py
index 390ce9c5..6de6eb43 100644
--- a/agentigrid/tests/journal/test_pareto.py
+++ b/agentigrid/tests/journal/test_pareto.py
@@ -2,8 +2,8 @@
 
 import pytest
 
-from agentigrid.engine.journal import ObjectiveEntry
-from agentigrid.engine.pareto import ParetoCandidate, _dominates, pareto_filter
+from agentigrid.exago_engine.journal import ObjectiveEntry
+from agentigrid.exago_engine.pareto import ParetoCandidate, _dominates, pareto_filter
 
 
 # ---------------------------------------------------------------------------
diff --git a/agentigrid/tests/journal/test_regenerate_report.py b/agentigrid/tests/journal/test_regenerate_report.py
index d47a96f8..cad099ed 100644
--- a/agentigrid/tests/journal/test_regenerate_report.py
+++ b/agentigrid/tests/journal/test_regenerate_report.py
@@ -23,8 +23,8 @@
 from agentigrid.config import (
     AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
 )
-from agentigrid.engine.journal import SearchJournal
-from agentigrid.engine.regenerate_report import (
+from agentigrid.exago_engine.journal import SearchJournal
+from agentigrid.exago_engine.regenerate_report import (
     load_journal_export,
     build_session_stub,
     regenerate_from_journal,
@@ -123,7 +123,7 @@ def test_classification_digest_keeps_best_and_worst():
 
 @pytest.mark.skipif(not _IEEE118.exists(), reason="ieee_118_bus_v10.m not available")
 def test_finalize_uses_digest(tmp_path):
-    from agentigrid.engine.agent_loop import AgentLoopController, SearchSession
+    from agentigrid.exago_engine.agent_loop import AgentLoopController, SearchSession
 
     cfg = _cfg(tmp_path, base_case=_IEEE118)
     backend_mock = MagicMock()
@@ -132,8 +132,8 @@ def test_finalize_uses_digest(tmp_path):
         raw_text='```json\n{"goal_type": "cost_minimization", '
                  '"best_iteration": 1, "best_iteration_rationale": "r"}\n```'
     )
-    with patch("agentigrid.engine.agent_loop.create_backend", return_value=backend_mock), \
-         patch("agentigrid.engine.agent_loop.SimulationExecutor"):
+    with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=backend_mock), \
+         patch("agentigrid.exago_engine.agent_loop.SimulationExecutor"):
         controller = AgentLoopController(cfg)
 
     controller._journal = _big_sweep_journal(50, best_bus=10)
@@ -168,7 +168,7 @@ def spy_detailed(self, *a, **k):
 # ---------------------------------------------------------------------------
 
 def test_load_session_preserves_sweep_fields(tmp_path):
-    from agentigrid.engine.session_io import save_session, load_session
+    from agentigrid.exago_engine.session_io import save_session, load_session
 
     journal = SearchJournal()
     journal.add_sweep(
@@ -312,7 +312,7 @@ def generate(self, session, summary_text=None, base_result=None,
             captured["session"] = session
             return b"%PDF-1.4\nfake pdf bytes\n%%EOF"
 
-    with patch("agentigrid.engine.regenerate_report._import_report_generator",
+    with patch("agentigrid.exago_engine.regenerate_report._import_report_generator",
                return_value=_SpyGenerator):
         pdf_path = regenerate_from_journal(
             journal_json_path=export_path, config=cfg, backend=backend,
diff --git a/agentigrid/tests/journal/test_session_io.py b/agentigrid/tests/journal/test_session_io.py
index 1c7797ef..824b15fc 100644
--- a/agentigrid/tests/journal/test_session_io.py
+++ b/agentigrid/tests/journal/test_session_io.py
@@ -6,8 +6,8 @@
 import pytest
 from pathlib import Path
 
-from agentigrid.engine.session_io import save_session, load_session, SESSION_FORMAT_VERSION
-from agentigrid.engine.journal import (
+from agentigrid.exago_engine.session_io import save_session, load_session, SESSION_FORMAT_VERSION
+from agentigrid.exago_engine.journal import (
     JournalEntry, SearchJournal, ObjectiveEntry, ObjectiveRegistry,
 )
 
diff --git a/agentigrid/tests/journal/test_solve_iteration_counting.py b/agentigrid/tests/journal/test_solve_iteration_counting.py
index 5c801abc..05cb02c0 100644
--- a/agentigrid/tests/journal/test_solve_iteration_counting.py
+++ b/agentigrid/tests/journal/test_solve_iteration_counting.py
@@ -13,9 +13,9 @@
 
 import pytest
 
-from agentigrid.engine.journal import SearchJournal, is_solve_iteration
-from agentigrid.engine.goal_classifier import build_classification_prompts
-from agentigrid.parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_engine.journal import SearchJournal, is_solve_iteration
+from agentigrid.exago_engine.goal_classifier import build_classification_prompts
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent / "launcher"))
 from charts import convergence_chart, voltage_range_chart  # noqa: E402
diff --git a/agentigrid/tests/results/test_opflow_parser.py b/agentigrid/tests/results/test_opflow_parser.py
index 712c20db..0259a315 100644
--- a/agentigrid/tests/results/test_opflow_parser.py
+++ b/agentigrid/tests/results/test_opflow_parser.py
@@ -6,9 +6,9 @@
 
 import pytest
 
-from agentigrid.parsers.opflow_parser import parse_opflow_output, parse_simulation_result
-from agentigrid.parsers.opflow_results import OPFLOWResult
-from agentigrid.parsers.results_summary import results_summary
+from agentigrid.exago_parsers.opflow_parser import parse_opflow_output, parse_simulation_result
+from agentigrid.exago_parsers.opflow_results import OPFLOWResult
+from agentigrid.exago_parsers.results_summary import results_summary
 
 SAMPLE = Path(__file__).resolve().parent.parent / "fixtures" / "sample_opflow_output.txt"
 _has_sample = SAMPLE.exists()
diff --git a/agentigrid/tests/results/test_prompt_size_bounded.py b/agentigrid/tests/results/test_prompt_size_bounded.py
index c8379fa6..3d54d7dc 100644
--- a/agentigrid/tests/results/test_prompt_size_bounded.py
+++ b/agentigrid/tests/results/test_prompt_size_bounded.py
@@ -12,18 +12,18 @@
 import pytest
 
 from agentigrid.config import load_config
-from agentigrid.parsers.matpower_model import (
+from agentigrid.exago_parsers.matpower_model import (
     Bus, Branch, Generator, GenCost, MATNetwork,
 )
-from agentigrid.parsers.network_summary import network_summary
-from agentigrid.parsers.opflow_results import (
+from agentigrid.exago_parsers.network_summary import network_summary
+from agentigrid.exago_parsers.opflow_results import (
     OPFLOWResult, BusResult, BranchResult, GenResult,
 )
-from agentigrid.parsers.results_summary import results_summary
-from agentigrid.parsers.pflow_summary import pflow_results_summary
-from agentigrid.parsers.scopflow_summary import scopflow_results_summary
-from agentigrid.parsers.dcopflow_summary import dcopflow_results_summary
-from agentigrid.parsers.tcopflow_summary import tcopflow_results_summary
+from agentigrid.exago_parsers.results_summary import results_summary
+from agentigrid.exago_parsers.pflow_summary import pflow_results_summary
+from agentigrid.exago_parsers.scopflow_summary import scopflow_results_summary
+from agentigrid.exago_parsers.dcopflow_summary import dcopflow_results_summary
+from agentigrid.exago_parsers.tcopflow_summary import tcopflow_results_summary
 
 
 # ---------------------------------------------------------------------------
diff --git a/agentigrid/tests/results/test_scenario_voltage_spread.py b/agentigrid/tests/results/test_scenario_voltage_spread.py
index 694ebfa3..cb1f745c 100644
--- a/agentigrid/tests/results/test_scenario_voltage_spread.py
+++ b/agentigrid/tests/results/test_scenario_voltage_spread.py
@@ -17,7 +17,7 @@
 
 import pytest
 
-from agentigrid.parsers import compute_scenario_voltage_spread
+from agentigrid.exago_parsers import compute_scenario_voltage_spread
 
 # report_generator lives in the (non-package) launcher/ dir.
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent / "launcher"))
@@ -197,7 +197,7 @@ def _controller(tmp_path, application="sopflow"):
     from agentigrid.config import (
         AppConfig, ExagoConfig, DataConfig, LLMConfig, SearchConfig, OutputConfig,
     )
-    from agentigrid.engine.agent_loop import AgentLoopController
+    from agentigrid.exago_engine.agent_loop import AgentLoopController
 
     cfg = AppConfig(
         exago=ExagoConfig(binary_dir=tmp_path/"bin", opflow_binary=None, scopflow_binary=None,
@@ -211,13 +211,13 @@ def _controller(tmp_path, application="sopflow"):
         output=OutputConfig(workdir=tmp_path/"wd", logs_dir=tmp_path/"logs", save_journal=False,
             journal_format="json", save_modified_files=False, verbose=False),
     )
-    with patch("agentigrid.engine.agent_loop.create_backend", return_value=MagicMock()), \
-         patch("agentigrid.engine.agent_loop.SimulationExecutor"):
+    with patch("agentigrid.exago_engine.agent_loop.create_backend", return_value=MagicMock()), \
+         patch("agentigrid.exago_engine.agent_loop.SimulationExecutor"):
         return AgentLoopController(cfg)
 
 
 def _push_sim_entry(ctrl, cwd, iteration=1):
-    from agentigrid.engine.journal import JournalEntry
+    from agentigrid.exago_engine.journal import JournalEntry
     ctrl._journal._entries.append(JournalEntry(
         iteration=iteration, description="sopflow", commands=[], objective_value=1.0,
         feasible=True, convergence_status="CONVERGED", violations_count=0,
diff --git a/agentigrid/tests/runner/test_exago_command_logging.py b/agentigrid/tests/runner/test_exago_command_logging.py
index 55a2468e..f8d6c956 100644
--- a/agentigrid/tests/runner/test_exago_command_logging.py
+++ b/agentigrid/tests/runner/test_exago_command_logging.py
@@ -18,10 +18,10 @@
 import pytest
 
 from agentigrid.config import ExagoConfig, OutputConfig
-from agentigrid.engine.agent_loop import _single_call_record, _multi_call_record
-from agentigrid.engine.executor import SimulationExecutor, SimulationResult
-from agentigrid.engine.journal import SearchJournal
-from agentigrid.parsers import parse_matpower
+from agentigrid.exago_engine.agent_loop import _single_call_record, _multi_call_record
+from agentigrid.exago_engine.executor import SimulationExecutor, SimulationResult
+from agentigrid.exago_engine.journal import SearchJournal
+from agentigrid.exago_parsers import parse_matpower
 
 DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 ACTIVSG200 = DATA_DIR / "case_ACTIVSg200.m"
@@ -64,7 +64,7 @@ def test_argv_and_cwd_captured(self, tmp_path):
         exago, output = _make_config(tmp_path, tmp_path / "bin")
         ex = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             res = ex.run(net, application="opflow", iteration=0)
         assert res.argv and res.argv[0].endswith("opflow")
@@ -79,7 +79,7 @@ def test_thread_limit_env_overrides_captured(self, tmp_path):
         exago, output = _make_config(tmp_path, tmp_path / "bin")
         ex = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             res = ex.run(net, application="opflow", iteration=1, thread_limit=1)
         assert res.env_overrides is not None
@@ -90,7 +90,7 @@ def test_mpirun_prefix_captured_in_argv(self, tmp_path):
         exago, output = _make_config(tmp_path, tmp_path / "bin", mpi_np=4)
         ex = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             res = ex.run(net, application="scopflow", iteration=0)
         assert res.argv[:3] == ["mpirun", "-np", "4"]
@@ -102,7 +102,7 @@ def test_env_script_shell_command_captured(self, tmp_path):
         exago, output = _make_config(tmp_path, tmp_path / "bin", env_script=env_script)
         ex = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             res = ex.run(net, application="opflow", iteration=2, thread_limit=1)
         assert res.shell_command is not None
diff --git a/agentigrid/tests/runner/test_executor.py b/agentigrid/tests/runner/test_executor.py
index bc258a40..6a201622 100644
--- a/agentigrid/tests/runner/test_executor.py
+++ b/agentigrid/tests/runner/test_executor.py
@@ -9,8 +9,8 @@
 import pytest
 
 from agentigrid.config import ExagoConfig, OutputConfig
-from agentigrid.engine.executor import SimulationExecutor, SimulationResult
-from agentigrid.parsers import parse_matpower
+from agentigrid.exago_engine.executor import SimulationExecutor, SimulationResult
+from agentigrid.exago_parsers import parse_matpower
 
 DATA_DIR = Path(__file__).resolve().parent.parent.parent / "data" / "exago" / "examples"
 APP_DIR = Path(__file__).resolve().parent.parent.parent / "applications" / "exago"
@@ -242,7 +242,7 @@ def test_no_mpirun_for_opflow(self, tmp_path: Path):
         executor = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
 
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             executor.run(net, application="opflow", iteration=0)
             cmd_arg = mock_sub.call_args[0][0]
@@ -255,7 +255,7 @@ def test_no_mpirun_for_tcopflow(self, tmp_path: Path):
         executor = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
 
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             executor.run(net, application="tcopflow", iteration=0)
             cmd_arg = mock_sub.call_args[0][0]
@@ -268,7 +268,7 @@ def test_no_mpirun_for_dcopflow(self, tmp_path: Path):
         executor = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
 
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             executor.run(net, application="dcopflow", iteration=0)
             cmd_arg = mock_sub.call_args[0][0]
@@ -281,7 +281,7 @@ def test_mpirun_for_scopflow_with_mpi_np(self, tmp_path: Path):
         executor = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
 
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             executor.run(net, application="scopflow", iteration=0)
             cmd_arg = mock_sub.call_args[0][0]
@@ -296,7 +296,7 @@ def test_no_mpirun_for_scopflow_with_mpi_np_1(self, tmp_path: Path):
         executor = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
 
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             executor.run(net, application="scopflow", iteration=0)
             cmd_arg = mock_sub.call_args[0][0]
@@ -309,7 +309,7 @@ def test_mpirun_for_sopflow_with_mpi_np(self, tmp_path: Path):
         executor = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
 
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             executor.run(net, application="sopflow", iteration=0)
             cmd_arg = mock_sub.call_args[0][0]
@@ -324,7 +324,7 @@ def test_no_mpirun_for_sopflow_with_mpi_np_1(self, tmp_path: Path):
         executor = SimulationExecutor(exago, output)
         net = parse_matpower(ACTIVSG200)
 
-        with patch("agentigrid.engine.executor.subprocess.run") as mock_sub:
+        with patch("agentigrid.exago_engine.executor.subprocess.run") as mock_sub:
             mock_sub.return_value = MagicMock(stdout="OK", stderr="", returncode=0)
             executor.run(net, application="sopflow", iteration=0)
             cmd_arg = mock_sub.call_args[0][0]
diff --git a/agentigrid/tests/runner/test_save_solutions.py b/agentigrid/tests/runner/test_save_solutions.py
new file mode 100644
index 00000000..244fccb7
--- /dev/null
+++ b/agentigrid/tests/runner/test_save_solutions.py
@@ -0,0 +1,189 @@
+"""exago.save_solutions: which solved cases (opflowout.m / pflowout.m) are kept."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from agentigrid.config import load_config
+from agentigrid.exago_engine.agent_loop import AgentLoopController
+from agentigrid.exago_engine.executor import SOLUTION_FILES, SimulationExecutor
+from agentigrid.exago_parsers.matpower_model import MATNetwork
+
+# Stands in for opflow/pflow: writes the solved case only when asked to.
+FAKE_APP = """#!/bin/sh
+for a in "$@"; do
+  if [ "$a" = "-save_output" ]; then echo "mpc.converged = 1;" > {out}; fi
+done
+echo "fake solve"
+"""
+
+
+def _executor(tmp_path: Path, mode: str) -> SimulationExecutor:
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir(exist_ok=True)
+    for app, out in (("opflow", "opflowout.m"), ("pflow", "pflowout.m"), ("tcopflow", "tcopflowout")):
+        exe = bin_dir / app
+        exe.write_text(FAKE_APP.format(out=out))
+        exe.chmod(0o755)
+    cfg = load_config(None, cli_overrides={
+        "exago.binary_dir": str(bin_dir), "exago.save_solutions": mode,
+        "output.workdir": str(tmp_path / "work"),
+    })
+    return SimulationExecutor(cfg.exago, cfg.output)
+
+
+def _net() -> MATNetwork:
+    return MATNetwork(casename="case", version="2", baseMVA=100.0, buses=[], generators=[],
+                      branches=[], gencost=[], header_comments="")
+
+
+def _solve_batch(ex: SimulationExecutor, n: int, first_tag: int = 1) -> list[Path]:
+    # Distinct tags: run folders are named iter_<tag>_<time to the second>.
+    ex.begin_batch()
+    for i in range(n):
+        ex.run(_net(), "opflow", iteration=-(first_tag + i))
+    return ex.end_batch()
+
+
+def _saved(dirs: list[Path]) -> list[Path]:
+    return [d for d in dirs if any((d / f).exists() for f in SOLUTION_FILES)]
+
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+def test_default_is_best():
+    assert load_config(None).exago.save_solutions == "best"
+
+
+def test_set_on_command_line():
+    cfg = load_config(None, cli_overrides={"exago.save_solutions": "newest"})
+    assert cfg.exago.save_solutions == "newest"
+
+
+def test_unknown_value_warns(caplog):
+    with caplog.at_level(logging.WARNING, logger="agentigrid.config"):
+        load_config(None, cli_overrides={"exago.save_solutions": "some"})
+    assert "save_solutions" in caplog.text
+
+
+@pytest.mark.parametrize("name", ["default_config.yaml.template", "local_config.yaml.template"])
+def test_templates_set_best(name):
+    path = Path(__file__).resolve().parents[2] / "configs" / name
+    assert load_config(path).exago.save_solutions == "best"
+
+
+# ---------------------------------------------------------------------------
+# Writing
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("mode,written", [("all", True), ("best", True), ("newest", True),
+                                          ("none", False)])
+@pytest.mark.parametrize("app,out", [("opflow", "opflowout.m"), ("pflow", "pflowout.m")])
+def test_written_unless_none(tmp_path, mode, written, app, out):
+    res = _executor(tmp_path, mode).run(_net(), app, iteration=0)
+    assert (res.workdir / out).exists() == written
+    assert ("-save_output" in res.argv) == written
+
+
+def test_none_leaves_other_applications_alone(tmp_path):
+    # TCOPFLOW needs -save_output for its own per-period results.
+    res = _executor(tmp_path, "none").run(_net(), "tcopflow", iteration=0)
+    assert "-save_output" in res.argv
+
+
+# ---------------------------------------------------------------------------
+# Pruning one batch
+# ---------------------------------------------------------------------------
+
+def test_batch_records_runs_in_order(tmp_path):
+    ex = _executor(tmp_path, "best")
+    dirs = _solve_batch(ex, 3)
+    assert len(dirs) == 3 and len(set(dirs)) == 3
+    ex.run(_net(), "opflow", iteration=9)            # outside a batch: not recorded
+    assert ex.end_batch() == []
+
+
+def test_best_keeps_best(tmp_path):
+    ex = _executor(tmp_path, "best")
+    dirs = _solve_batch(ex, 3)
+    assert ex.prune_solutions(dirs, best=dirs[0]) == dirs[0]
+    assert _saved(dirs) == [dirs[0]]
+    assert all((d / "case.m").exists() for d in dirs)    # input cases stay
+
+
+def test_best_without_best_keeps_most_recent(tmp_path):
+    ex = _executor(tmp_path, "best")
+    dirs = _solve_batch(ex, 3)
+    assert ex.prune_solutions(dirs, best=None) == dirs[-1]
+    assert _saved(dirs) == [dirs[-1]]
+
+
+def test_newest_ignores_best(tmp_path):
+    ex = _executor(tmp_path, "newest")
+    dirs = _solve_batch(ex, 3)
+    ex.prune_solutions(dirs, best=dirs[0])
+    assert _saved(dirs) == [dirs[-1]]
+
+
+def test_all_keeps_everything(tmp_path):
+    ex = _executor(tmp_path, "all")
+    dirs = _solve_batch(ex, 3)
+    assert ex.prune_solutions(dirs, best=dirs[0]) is None
+    assert _saved(dirs) == dirs
+
+
+# ---------------------------------------------------------------------------
+# Agent loop: which run is "best", and explore -> select
+# ---------------------------------------------------------------------------
+
+def _loop(ex):
+    return SimpleNamespace(_executor=ex, _pending_explore=None, _batch_best=None)
+
+
+def test_single_solve_action_is_kept(tmp_path):
+    ex = _executor(tmp_path, "newest")
+    loop = _loop(ex)
+    dirs = _solve_batch(ex, 1)
+    AgentLoopController._prune_saved_solutions(loop, "modify", dirs)
+    assert _saved(dirs) == dirs
+
+
+def test_sweep_keeps_marked_best(tmp_path):
+    ex = _executor(tmp_path, "best")
+    loop = _loop(ex)
+    dirs = _solve_batch(ex, 4)
+    loop._batch_best = dirs[1]
+    AgentLoopController._prune_saved_solutions(loop, "sweep", dirs)
+    assert _saved(dirs) == [dirs[1]]
+
+
+def test_explore_waits_and_select_keeps_choice(tmp_path):
+    ex = _executor(tmp_path, "best")
+    loop = _loop(ex)
+    variants = _solve_batch(ex, 3)
+    loop._batch_best = variants[0]                           # Pareto-best variant
+    AgentLoopController._prune_saved_solutions(loop, "explore", variants)
+    assert _saved(variants) == variants                      # nothing pruned yet
+    loop._batch_best = variants[2]                           # the LLM selects another one
+    AgentLoopController._prune_saved_solutions(loop, "select", [])
+    assert _saved(variants) == [variants[2]]
+    assert loop._pending_explore is None
+
+
+def test_explore_followed_by_other_action_keeps_pareto_best(tmp_path):
+    ex = _executor(tmp_path, "best")
+    loop = _loop(ex)
+    variants = _solve_batch(ex, 3)
+    loop._batch_best = variants[1]
+    AgentLoopController._prune_saved_solutions(loop, "explore", variants)
+    loop._batch_best = None
+    later = _solve_batch(ex, 1, first_tag=100)
+    AgentLoopController._prune_saved_solutions(loop, "modify", later)
+    assert _saved(variants) == [variants[1]]
+    assert _saved(later) == later