There is no shortage of AI workout plan generators now. Most of them work the same way. You fill in a form, you pick a goal, you say what equipment you have, and thirty seconds later you get a plan. It usually looks pretty good.
Then you go and train, and reality shows up. You sleep badly. You miss a set. You go on holiday for ten days. You get to the gym with twenty minutes to spare instead of an hour. And the plan, which was generated once and never looked at you again, carries on as though none of that happened.
That gap is the thing we set out to close with Korvi’s training engine. This post is a look under the bonnet at how it works, and at one design decision in particular that we think matters more than any other: we don’t let the AI decide how heavy you lift.
Two brains, on purpose
The engine is split in half, deliberately.
A language model decides what you do. Which exercises, what split, how the week is structured, when you need a deload. This is contextual judgement, and it’s the kind of thing large language models are genuinely good at. It weighs up your training history, your schedule, the kit you actually have access to, and how you’ve been performing lately.
Deterministic code decides how heavy. Every single weight in your plan is calculated by our own maths, not generated by the AI. This is a deliberate boundary, drawn before a line of the engine was written.
That second half is the part we get asked about most, so it’s worth explaining why.
Why the AI never sets your weights
Language models hallucinate. That’s not a criticism, it’s just a property of how they work. Most of the time it doesn’t matter much. If a model invents a slightly odd film recommendation, you shrug and move on.
But a hallucinated number in a strength app is a different thing entirely. If a model confidently tells someone who benches 40kg to load 80kg, that’s not an amusing glitch. That’s someone getting hurt under a bar.
So we took weights off the table. Instead, every load in your plan is derived from your own measured strength, using a chain of deterministic steps that we can inspect, test, and explain. It starts from an estimate of your one-rep max for that specific lift, gets scaled according to where you are in your training block, gets adjusted for the set and the rep target, and then gets held inside safe bounds before being rounded to the plates your gym actually has.
None of that is guesswork, and none of it is generated text. It is arithmetic, and it produces the same answer every time. If you ever want to know why Korvi asked you to lift a particular weight on a particular day, there is a real answer, and we can give it to you.
There is a nice division of labour in this. Intelligence lives in what you do. Safety and consistency live in how heavy.
Where your weights actually come from
The number underneath everything is your estimated one-rep max, or E1RM. It’s the amount you could theoretically lift once, for a given exercise, worked out from sets you’ve actually done rather than from a max attempt you’d rather not do on a Tuesday evening.
Korvi estimates it using the Epley formula, which is a long-established equation in strength training that turns a set (the weight you lifted and how many reps you got) into a one-rep max estimate. It’s the same maths behind most of the 1RM calculators you’ll find online. The difference is that Korvi is doing it continuously, for every working set, for every exercise you perform, and using the result to set your loads for next time.
A few design choices matter here.
Your strength model doesn’t fall off a cliff after one bad session. The store that feeds your prescribed weights only ratchets upward. A single rough day, when you slept badly and everything felt heavy, never drags your numbers down. The only thing that moves your loads down is a confirmed downward trend over time, which is a real signal rather than noise.
Failed sets don’t inflate your strength. If you grind out a horrible set and fail it, that set is honestly recorded as a failure. It informs how the plan adapts, but it never counts toward a PR and it never pushes your estimated max upward.
Every variation carries its own number. Flat bench, incline bench, paused bench and a close grip are not the same lift, and Korvi doesn’t treat them as though they are. Once you’ve performed a variation, it holds its own strength estimate.
If you want the longer version of why this measurement matters, we wrote about the underlying idea in how to know when to increase weight at the gym.
The cold start problem
Here’s a wrinkle that falls straight out of the above. If every weight is a percentage of your measured strength for that exact lift, what happens the first time the plan gives you an exercise you’ve never done?
The naive answer is to treat you as a total beginner on that movement, which is both wrong and annoying. If you’ve been benching for three years, you should not be starting your first incline bench session with an empty bar.
So Korvi seeds new lifts from what it already knows about you, working from the most reliable source available down to the least. If you’ve done the exact variation, it uses that. If you haven’t, but you’ve done a close relative of it, it estimates from the sibling. Failing that, it works from your average across that movement pattern, scaled down for safety. And only as a last resort does it fall back on a model estimate, which gets clamped against your known lifts so it can’t run away.
The important guardrail is that a guess never sticks. Any cold-start estimate is treated as low confidence and temporary. It doesn’t get written into your permanent strength model, so a first-session guess can’t lock in a load you never actually earned. The first real set you perform replaces it.
Onboarding, calibration, then training that doesn’t end
The user journey has three phases.
Onboarding is a short conversation rather than a form. It covers who you are, how and when you want to train, what equipment you can actually get to, and any movements you’d rather leave out. The most consequential thing you pick is your training archetype, which is essentially your coaching style. It shapes how long your training blocks run, what phases they contain, what rep ranges and effort targets you work at, and how volume is distributed across your muscle groups. We currently have seven archetypes in the app, covering everything from pure strength through physique work and athletic performance to a bodyweight-focused path and a keep-it-varied option. We’re still refining that list.
Calibration comes next, and it’s the phase most apps skip. For your first handful of workouts, Korvi deliberately keeps your loads conservative while it learns what you can actually do. It’s not being timid for the sake of it. It’s gathering evidence. Every working set you complete sharpens the estimate, and the ceiling on your intensity stays in place until the engine is confident it knows your strength. More experienced lifters graduate faster, because they arrive with better information and their estimates converge more quickly. In the app you’ll see this as a simple line telling you it’s dialling in your weights.
Active training then runs indefinitely. This is a real periodised programme, not a twelve week block that expires and dumps you back at the start. Your training is structured into blocks, the phases inside them wave intensity and volume across the weeks, and deloads arrive when they’re needed. The clock is training-aware, so if you disappear for two weeks the block freezes rather than burning through phases you never trained.
Automatic progressive overload and periodisation, without anyone having to maintain a spreadsheet, is most of what a good coach does with a programme. It’s just that most people don’t have a coach.
A plan that reacts to reality
This is the part we’re most pleased with, and the reason the engine exists at all.
After every workout you complete, the engine compares what actually happened against what the plan asked for, and adjusts the next few days accordingly. Not the whole programme, and not permanently. Just the near horizon.
There are a few ways this plays out.
You miss most of your working sets in a session. The next day that trains the same muscles gets eased off a little, with a cooldown so the adjustments can’t stack up on top of each other and spiral.
You do a load of extra volume. Maybe you added an unplanned session, or went well beyond what was written. An upcoming day that hits the same muscles will back off, but only on the overlapping work, not the whole session.
You go on holiday. The block clock freezes for a recognised gap, so you come back to your mesocycle where you left it rather than three phases further on. Your first session back ramps in sensibly rather than picking up exactly where you stopped.
You’re short on time. You can tell Korvi to shorten a day, and the sets you free up don’t just evaporate. They get redistributed through a capped process: some of them land on later sessions that week which have room for them, and anything that doesn’t fit gets carried forward as volume debt rather than being crammed in. It’s never a one-for-one swap, it never pushes you past your weekly target for a muscle, and it’s skipped entirely if you’re deloading. You see the whole proposal and approve it before anything changes.
Every one of these adjustments is bounded, undoable with one tap, and visible. Korvi tells you what it changed and why. Nothing happens to your plan silently.
Was that a bad plan, or a bad day?
There’s a subtlety here that took us a while to get right, and it’s probably the single most interesting problem in the whole engine.
Suppose you fail most of your sets on Tuesday. What should the plan conclude?
If the plan was genuinely too hard, the right response is to lighten things. But if you’d slept four hours and were coming down with something, lightening your programme is exactly the wrong response. You’d be permanently penalising your training because of one bad night. Do that repeatedly and the plan slowly ratchets down toward nothing.
So Korvi separates every signal into two categories. Persistent changes are real changes in your capacity, and they should update the model. Transient states are temporary, and they should only affect the moment.
Working out which is which is a judgement call, and it’s the one place we do let a language model into the loop. It looks at the context and classifies what happened: was this a plan problem, or a life problem? Crucially, it only classifies. It doesn’t touch a single weight. Code enforces what happens next, and the deterministic engine still sets every load.
And it’s safe by default. Only a confident verdict of “this was just a bad day” will suppress the adjustment. If there’s any doubt, Korvi takes the cautious route, eases your next session slightly, and keeps an eye on how you’re recovering. When in doubt, hold the model and watch.
What’s live, and what isn’t
We try to be straight about this sort of thing.
The foundations are shipped and working: onboarding, the calibration phase, the periodisation engine, the strength model, and the deterministic weight engine that prescribes every load in your plan. If you’re using the Korvi app today, all of that is what’s generating your training.
The reactive layer, the part that adjusts your plan after each workout, is built and is currently rolling out behind feature flags while we finish backend deployment and testing on real devices. It works, but we’d rather it work quietly and correctly for a while before we make noise about it.
And we’ll keep saying this: the plan is not the point. The point is the progress you can actually feel, and see, and check. A training plan is table stakes. What we’re building toward is a system that knows what your body actually did, which is a much bigger question, and one we’ve written about in the context of bench press bar path and bar speed.
Where the sensors come in
Everything above runs on what you tell the app. You log a weight, you log your reps, you tag the set with an effort rating, and the engine reasons from there. That works, and it’s how essentially every strength app operates.
But look closely at the inputs and you’ll notice something. The weight is objective. The rep count is mostly objective. The effort rating is a number you invented, in the ninety seconds after a hard set, while out of breath. It’s the single softest input in the whole system, and a surprising amount rests on it.
This is where the sensors change the picture.
Your strength estimate stops depending on a self-report. Bar speed on a working set is a direct, measured readout of how hard that load actually was for you. Rather than asking you to rate a set, Korvi will be able to see it. That feeds a strength estimate built on measurement instead of memory, which makes every weight downstream of it sharper.
Rep counts become observed rather than entered. The sensors see the reps happen, including the ones you’d have rounded up or forgotten to log.
Fatigue becomes something we can watch rather than infer. Right now, “is this person tired?” is pieced together from training history and how sessions have been going. With sensor data, velocity decay within a set and across a session is measurable in real time. The bad-day-versus-bad-plan question gets a lot easier to answer when you can see a lifter’s bar speed falling off in a way it didn’t last week.
And there’s a whole class of signal the app simply cannot see today. Whether your form held together on the last two reps. Whether your left side is quietly doing less work than your right. Whether your range of motion shrank as the set went on. None of that shows up in a log of weights and reps, and all of it matters for what you should do next.
The engine was built with this in mind. Every input it relies on is designed to be replaced by a better one as it becomes available, without rebuilding the thing from scratch. Sensor data doesn’t bolt onto the side; it flows into the same strength model, the same adaptation logic, the same weight calculations, just with far less guesswork underneath.
The training engine is the part of it we could build first. The sensors are the part that makes it properly good.
Korvi is building wearable sensors for strength training, with full 3D motion tracking, the potential for bar path analysis, and AI-powered coaching. The app is free and available now on the App Store and Google Play. The sensor system is in development, with a Kickstarter launch planned for 2027.