optim-agent

optim-agent

Act as the sampler inside any coding-agent session: Claude Code, Codex,

OpenCode/OpenClaw, or another agent that can read project files and run shell

commands. Read the project to understand parameter meaning and interactions,

propose one configuration, run the real evaluator, and record the result

through optim-agent's ask/tell API. Let the measured objective, not the agent's

intuition, decide what works.

Load the workflow

Use this file as the operating guide for the active coding agent. In Codex, it

can be installed directly from GitHub:

$skill-installer install https://github.com/Optim-Agent/optim-agent

In Claude Code, OpenCode/OpenClaw, or another coding-agent environment, place

this repository or SKILL.md in the agent-visible workspace and ask the agent

to follow the optim-agent workflow. The workflow does not depend on Codex-only

APIs; it needs file access, shell access, and Python.

Ensure the Python package is importable. Choose one source; do not install both:

# Stable release from PyPI
python -m pip install optim-agent

# Latest source from GitHub
python -m pip install "optim-agent @ git+https://github.com/Optim-Agent/optim-agent.git"

For a reproducible GitHub install, append @<tag-or-commit> after .git.

Workflow

1. Understand the system. Read the evaluation entry point and every file

that defines the target parameters. Record each parameter's type, legal

range, semantics, interactions, and operational constraints.

1. Define the experiment. Confirm the scalar objective, minimize or

maximize, trial budget, evaluation command, runtime/cost limit, and fixed

workload or seed. For multiple metrics or hard constraints, agree on one

scalar feasibility or penalty rule before running trials.

1. Establish a baseline. Evaluate the current/default configuration with the

same command and environment used for every later trial.

1. Initialize or resume. Keep artifacts in the repository's ignored

.optim-agent-runs/ directory:

   if git rev-parse --git-dir >/dev/null 2>&1 && ! git check-ignore -q .optim-agent-runs/; then
     printf '/.optim-agent-runs/\n' >> "$(git rev-parse --git-path info/exclude)"
   fi

   from pathlib import Path
   import optim_agent as oa

   run_dir = Path(".optim-agent-runs")
   run_dir.mkdir(exist_ok=True)
   study = oa.create_study(
       direction="minimize",
       storage=run_dir / "skill-study.json",
       seed=0,
   )
   print([(t.params, t.value, t.state) for t in study.trials])

1. Run one informed trial. Choose parameters from code understanding and all

completed history, then use explicit ask/tell:

   params = {"threshold": 0.72, "budget": 80}
   trial = study.ask(params)
   try:
       value = evaluate_system(**trial.params)
   except Exception:
       study.tell(trial, state="failed")
       raise
   else:
       study.tell(trial, value)

For a deliberately stopped trial, report the latest valid intermediate

metric first, then call study.tell(trial, state="pruned").

1. Select the next point. Avoid accidental repeats, explore broadly before

exploiting, respect bounds and constraints, and treat failed regions as

evidence. If the evaluator is noisy, repeat promising configurations under

the same workload before declaring a winner.

1. Stop and report. Stop at the approved budget or stopping condition.

Report the baseline, best value and parameters, trial count, failed/pruned

trials, convergence trend, and exact reproduction command.

Recovery

JSON storage records a trial when study.tell runs. Before launching an

expensive external evaluation, save its parameters, command, and output path in

a per-trial directory under .optim-agent-runs/. After interruption, inspect

that output before rerunning: if a valid result exists, recreate the same point

with study.ask(params) and record it; otherwise rerun it deliberately.

Use SQLite storage (skill-study.db) only when the user explicitly wants

multiple processes. Sequential trials are the default because each proposal

should use the complete prior history.

Rules

• Use ask/tell in skill mode; do not delegate proposal selection to

AgentSampler when the session agent is meant to read and reason over code.

• Keep evaluation inputs and outputs isolated from production configuration.
• Never fabricate, infer, or manually improve an objective value.
• Record crashes as failed; record intentional early stops as pruned.
• Preserve the study and trial artifacts so the result is auditable and resumable.
• Do not tune secrets, credentials, or unbounded parameters.