AMUSTAS deploys swarms of software agents that rewrite your code against the metrics you actually care about — searching the space of possible algorithms until they land on one that's measurably faster, cheaper, and better. Hand-tuning is slow and expert-only. The search isn't.
Illustrative discovery run — agents optimizing a sample latency objective.
Finding the most effective algorithm for a given problem usually demands extensive experimentation and rare, specialized expertise. The discovery engine does that searching for you — and it doesn't get tired, doesn't get bored, and doesn't stop at the first answer that works.
At its heart, AMUSTAS is an engine that deploys a large number of software agents in parallel to improve your code. They don't optimize toward a vague sense of "better" — they iterate against concrete, measurable performance metrics, refining candidate after candidate until your solution actually meets the objective you defined.
Hundreds of agents explore the solution space at once, each chasing a different idea for how your code could run faster. Promising directions get reinforced; dead ends get pruned. Parallel breadth is what lets the engine cover ground a single engineer — however brilliant — never could in the same wall-clock time.
Because the search is driven by explicit metrics rather than general heuristics, it can chase a well-defined goal precisely: lower latency, higher throughput, less memory, faster convergence. The number you choose is the number it optimizes — and the run keeps going until that objective is met.
Every candidate is real, runnable code — not a suggestion. Agents reshape your implementation, benchmark it against your objective, keep what wins, and discard what doesn't. What comes back is the version that survived thousands of measured rounds.
The engine treats algorithm design as a search problem. It branches into many possible implementations, measures each, and follows the lines that pay off — converging on a high-performing algorithm tailored to your specific objective.
Point the engine at your code and the metric that matters — speed, cost, memory, accuracy, or a constraint to hold.
A large fleet of agents fans out in parallel, each proposing and testing a different way to make the code better.
Every candidate is benchmarked against your real metric. Winners advance; the rest are pruned without ceremony.
The engine returns the surviving algorithm — measurably improved, reproducible, and ready to drop into your stack.
The same metric-driven search applies across a broad range of domains. Two of the hardest — and most valuable — sit at opposite ends of the compute world. Switch between them.
Training large models is one of the most expensive things an organization does. AMUSTAS targets the algorithms underneath it — the kernels, schedules, and routines that decide how many GPU-hours a run actually costs — and searches for versions that reach the same objective in less time and less compute.
Combinatorial optimization sits among the hardest categories of computational problems there is — routing, scheduling, packing, allocation, assignment. Good solutions are worth real money, and the search space is brutal. The engine hunts it for you, refining candidate algorithms against your objective to find better solutions than hand-built heuristics tend to reach.
Anywhere a measurable algorithm decides how fast, how cheap, or how good your result is, there's a target for the search. A sample of the territory — from kernel-level acceleration to combinatorial search.
Don't see your problem? If it has a metric, it has a target. Tell us what you're optimizing.
We're opening access to the discovery engine gradually. Join the waitlist to get early access, tell us about the workload you'd point it at, and be among the first teams to let the search do the tuning.
Request early accessTell us what you're trying to make faster, cheaper, or better. We'll be in touch as the pre-launch waitlist opens up — and if there's a workload worth pointing the engine at first, we want to hear about it.
We're early, pre-launch, and building both the engine and the team. If you're a researcher or engineer who wants in, say so — there's room on the front line.
Optimization is only useful if it runs efficiently on the hardware you actually have. AMUSTAS has announced integrations with major hardware manufacturers and cloud computing providers, with a deliberate emphasis on executing its search workloads efficiently on advanced computing infrastructure — so the engine scales out across accelerators and nodes instead of choking on a single box.
That matters because the search itself is heavy: hundreds of agents, thousands of candidate evaluations, all benchmarked for real. Spreading that across modern accelerators and clusters is what keeps discovery fast enough to be practical.
AMUSTAS keeps a working notebook on how the technology actually behaves. The principles below are the load-bearing ones — the reasons a metric-driven search beats hand-tuning, and where it earns its keep.
General heuristics optimize toward a guess about what "good" looks like. Explicit metrics optimize toward the exact number you'll be judged on. When the search is anchored to a real, measurable objective, it can target well-defined goals — and prove it hit them — instead of approximating.
Read the noteThe engine's power comes from running a large number of agents in parallel, each improving the code along a different line. Breadth turns a sequential, expert-bound process into a wide search — and parallelism is what makes that search finish in time to be useful.
Read the noteFinding the most effective algorithm by hand takes extensive experimentation and specialized expertise that few teams have to spare. That's the bottleneck AMUSTAS exists to remove: the orgs that most need high-performance algorithms are usually the ones with the least time to hand-tune them.
Read the noteAccelerating AI model training and solving complex combinatorial optimization problems look nothing alike — but both reduce to "find a better algorithm against a metric." One method spans a remarkably broad range of domains because the engine optimizes the objective, not the surface details.
Read the noteA discovery engine is only as good as the compute it rides on. Integrations with major hardware makers and cloud providers let the search spread across advanced infrastructure efficiently — turning a compute-hungry process into something that finishes on a schedule teams can plan around.
Read the noteAMUSTAS grows out of research in algorithm discovery and scientific computing — the same lineage behind well-known breakthroughs in automatically finding better algorithms. The engine is the productized form of that work, aimed at teams who need its results more than its papers.
Read the noteThe full technical notebook deepens as AMUSTAS approaches launch. Join the waitlist to follow along.