Results for “autonomous-optimization”

Runs an autonomous optimization loop that iteratively improves an artifact against an objective and evaluator using Hypothesis Tree Refinement, with subagent executors in isolated git worktrees.

Designs and governs recursive self-improvement loops where an agent mines its own failures and proposes edits to its own harness, prompts, or workflow, covering acceptance gates, diversity preservation, and the optimization ladder.

Clade goal-driven autonomous improvement loop (Blueprint architecture — deterministic pre/post phases + LLM supervisor/worker nodes, converges when goal met or max-iter hit). NOT the Claude Code built-in /loop (which polls a prompt on an interval like `/loop 5m /foo`) — if the user wants interval polling, route to the built-in.

Reduces AI API costs by 30-75% by classifying task complexity, checking prompt quality, and routing tasks to the most cost-efficient model tier before execution.

Give your agent a budget, a target, and a deadline — it does the rest. Orchestrates DSL + Opportunity Scanner + Emerging Movers into a full autonomous trading loop on Hyperliquid. Race condition prevention, conviction collapse cuts, cross-margin buffer math, speed filter. 3 risk profiles: conservative, moderate, aggressive. Use when setting up autonomous trading, creating a trading strategy, or running a scan-evaluate-trade-protect loop.

Transform the agent into a performance engineer. Apply methodologies for measuring, profiling, and optimizing code (caching, algorithm complexity, resource usage).

Run automated hyperparameter optimization for NVIDIA TAO models using AutoMLRunner, supporting multiple search algorithms and experiment tracking.

Orchestrates end-to-end autonomous AI research projects using a two-loop architecture. The inner loop runs rapid experiment iterations with clear optimization targets. The outer loop synthesizes results, identifies patterns, and steers research direction. Routes to domain-specific skills for execution, supports continuous agent operation via Claude Code /loop and OpenClaw heartbeat, and produces research presentations and papers. Use when starting a research project, running autonomous experiments, or managing a multi-hypothesis research effort.

Orchestrates end-to-end autonomous AI research projects using a two-loop architecture for rapid experimentation and synthesis, producing papers and presentations.

Autonomous experiment loop that optimizes any file by a measurable metric. Inspired by Karpathy's autoresearch. The agent edits a target file, runs a fixed evaluation, keeps improvements (git commit), discards failures (git reset), and loops indefinitely. Use when: user wants to optimize code speed, reduce bundle/image size, improve test pass rate, optimize prompts, improve content quality (headlines, copy, CTR), or run any measurable improvement loop. Requires: a target file, an evaluation command that outputs a metric, and a git repo.

Improves AI skills for activation, clarity, and cross-model reliability through benchmarking, salience tuning, and regression triage.

Solve single and multi-objective optimization problems using NSGA-II/III, MOEA/D, and other evolutionary algorithms with customizable operators, constraint handling, and benchmark problems.

Defines the architecture and orchestration primitives for multi-agent teams, covering role allocation, conflict resolution, reward routing, and the operational lifecycle of agent collectives.

Autonomously optimize any Claude Code skill by running it repeatedly, scoring outputs against binary evals, mutating the prompt, and keeping improvements. Based on Karpathy's autoresearch methodology. Use when: optimize this skill, improve this skill, run autoresearch on, make this skill better, self-improve skill, benchmark skill, eval my skill, run evals on. Outputs: an improved SKILL.md, a results log, and a changelog of every mutation tried.

Reduce OpenClaw token usage and API costs through smart model routing, heartbeat optimization, budget tracking, and native 2026.2.15 features (session pruning, bootstrap size limits, cache TTL alignment). Use when token costs are high, API rate limits are being hit, or hosting multiple agents at scale. The 4 executable scripts (context_optimizer, model_router, heartbeat_optimizer, token_tracker) are local-only — no network requests, no subprocess calls, no system modifications. Reference files (PROVIDERS.md, config-patches.json) document optional multi-provider strategies that require external API keys and network access if you choose to use them. See SECURITY.md for full breakdown.

Designing and evaluating AI/ML systems: prompt engineering, RAG design, LLM application patterns, AI safety, evaluation frameworks, MLOps, cost optimization. Use for AI pipelines or eval harnesses.

Orchestrating specialist AI agent teams as a meta-coordinator: decomposes requests into minimum viable chains, spawns each as an independent session, drives to final output. For multi-domain tasks.

Solves single- and multi-objective optimization problems with NSGA-II/III, MOEA/D, and other evolutionary algorithms, including constraint handling, Pareto front analysis, and benchmark problems.

Analyzes algorithm time and space complexity, classifies problems by complexity classes, proves NP-completeness, and designs approximation algorithms.

Continuously monitors system performance, identifies improvement opportunities, and orchestrates skill discovery and creation to autonomously evolve capabilities.

Autonomous experiment loop that optimizes any file by a measurable metric. Inspired by Karpathy's autoresearch. The agent edits a target file, runs a fixed evaluation, keeps improvements (git commit), discards failures (git reset), and loops indefinitely. Use when: user wants to optimize code speed, reduce bundle/image size, improve test pass rate, optimize prompts, improve content quality (headlines, copy, CTR), or run any measurable improvement loop. Requires: a target file, an evaluation command that outputs a metric, and a git repo.

Builds reliable browser automation skills by iteratively running a browsing task, reading the trace, and improving the navigation strategy until it passes consistently.