Optimizer · Waitlist

Algorithmic rewrites,
not just micro-opts.

ACENLY doesn't add caching or swap libraries. It finds a fundamentally better algorithm — O(n²) to O(n) — then proves it works on your actual data.

Join the waitlist →

Early access · No commitment · We'll reach out personally

Example optimization — deduplicate_users()

Before — O(n²)

def deduplicate_users(users):
    seen = []
    result = []
    for user in users:
        if user['id'] not in seen:
            seen.append(user['id'])
            result.append(user)
    return result

# list.append + "in" scan = O(n²)
# 2.81 ms at n=10,000

After — O(n)

def deduplicate_users(users):
    seen = {}
    result = []
    for user in users:
        uid = user['id']
        if uid not in seen:
            seen[uid] = True
            result.append(user)
    return result

# dict lookup = O(1) per item = O(n)
# 1.24 ms at n=10,000 ✓ identical output

2.3× faster Pure Python · Standard library only · Identical output on all test cases · O(n²) → O(n)

How the optimizer works

Not a magic box. A disciplined process.

AST Analysis

ACENLY parses your function's abstract syntax tree, identifies the complexity class, and maps data structures being used.

Evolution Engine

Generates a population of candidate rewrites using an LLM. Tests them against each other in tournament rounds — survivors breed the next generation.

Oracle Coordinator

An LLM coordinator observes what strategies are working and directs the engine toward promising directions — no random searching.

Correctness Check

Every candidate is run against your test cases. Outputs must be identical. If they're not, the candidate is discarded — speed without correctness is worthless.

Benchmark Proof

The winning function is benchmarked head-to-head against the original using the same statistical rigor as the benchmark tool. The speedup you see is real.

Clean Output

You get back pure Python — standard library only. No compiled extensions, no new dependencies. Drops in as a replacement.

What it works on

Any function with a measurable runtime.

Works best on CPU-bound functions with deterministic output. Not suited for I/O-heavy code.

Data deduplication Search & lookup Aggregation Graph traversal String manipulation Sorting & ranking Set operations Frequency counting Nested loops Matrix operations

FAQ

Common questions.

Every candidate is verified to produce identical output on your test cases before it's accepted. We also run the full benchmark to confirm the speedup is real. That said, we recommend reviewing the output yourself before deploying — the tool is a collaborator, not a replacement for engineering judgment.

In the current local version, no — everything runs on your machine. The SaaS version (coming soon) will send function code to our server for optimization. We will never store or use your code for any purpose other than running the optimization you requested.

The local version uses your own API key — Claude, GPT-4, or local models via Ollama. The SaaS version will handle the LLM costs on our side, included in the subscription price.

Typically 5–15 minutes depending on the function complexity and the number of candidates generated. The engine runs multiple generations of candidates and benchmarks all of them rigorously.

Algorithmic rewrites,not just micro-opts.