Optimize ECC Agent Harness Performance for Claude, Codex & Cursor | desplega.ai

Speed up your ECC agent harness for Claude Code, Codex, and Cursor with targeted config tweaks, parallelism tuning, and automated E2E test coverage.

Before touching a single config knob, run your existing ECC agent harness suite end-to-end and capture timing metrics. Without a concrete baseline you cannot prove that later changes actually improved anything — and you risk celebrating a variance blip. Export results as JSON so the desplega diff tool can compare runs later.

npx desplega run --suite ecc-agent --reporter json --output baseline-report.json

The default harness runs agent steps serially so failures are easy to trace. Once you have a baseline, crank concurrency to match your CPU thread count. Claude Code, Codex, and Cursor calls are almost entirely I/O-bound, so oversubscribing threads by 1.5x is usually safe and can shave minutes off longer suites.

// desplega.config.ts
export default {
  agent: {
    concurrency: 8,          // match your CPU thread count
    timeout: 30_000,         // ms per agent step
    retryOnFlake: 2
  }
};

Each provider has its own quirks — Claude's tool-use blocks, Codex's function calling, and Cursor's IDE-scoped endpoints all need dedicated adapters. Register them explicitly so the harness routes prompts correctly and applies per-provider token budgets instead of a global lowest-common-denominator setting.

// desplega.config.ts  (extend the object above)
import { claudeAdapter, codexAdapter, cursorAdapter } from '@desplega/adapters';

export default {
  agent: { concurrency: 8, timeout: 30_000, retryOnFlake: 2 },
  providers: [
    claudeAdapter({ model: 'claude-3-5-sonnet-20241022', maxTokens: 4096 }),
    codexAdapter({ model: 'gpt-4o',                     maxTokens: 4096 }),
    cursorAdapter({ endpoint: process.env.CURSOR_API_URL })
  ]
};

Most ECC suites re-execute nearly identical prompts across runs — same fixtures, same seed, same model. Turning on the built-in prompt cache converts those redundant round-trips into zero-cost local reads. Use the filesystem driver for local dev and Redis in CI so parallel runners share the same warm cache.

// desplega.config.ts  (add cache block)
export default {
  agent: { concurrency: 8, timeout: 30_000, retryOnFlake: 2 },
  cache: {
    enabled: true,
    driver: 'filesystem',    // 'redis' for CI clusters
    ttl: 3600,               // seconds
    keyFields: ['prompt', 'model', 'temperature']
  },
  providers: [ /* ... */ ]
};

Full-suite reruns on every commit are almost never worth it. desplega's impact-analysis flag walks the dependency graph from your git diff and executes only the tests that touch changed agent code. On mature repos this alone typically drops CI time from 20+ minutes to under 3.

npx desplega run --suite ecc-agent --changed-only --base origin/main

Performance wins mean nothing if agent output quality regresses. Write desplega specs that assert on structured outputs — code diffs, file edits, tool-call payloads — instead of raw text. That way a subtle behavior drift in Claude Code, Codex, or Cursor is caught by CI rather than by a customer.

// tests/ecc-agent.spec.ts
import { test, expect } from '@desplega/test';

test('Claude Code applies the suggested refactor', async ({ agent }) => {
  const result = await agent.run('Refactor this function to use async/await', {
    provider: 'claude',
    context: { file: 'src/utils.ts' }
  });
  expect(result.edits).toContainKey('src/utils.ts');
  expect(result.edits['src/utils.ts']).toMatch(/async.*await/);
});

Re-run the optimized harness, generate a second JSON report, and diff it against your baseline. desplega surfaces per-provider latency deltas and any newly failing assertions in a single view so you can approve or roll back changes with confidence before merging.

npx desplega run --suite ecc-agent --reporter json --output optimized-report.json
npx desplega diff baseline-report.json optimized-report.json