Tools

What You'll Build

A personal AI coach that does what a good endurance coach actually does. Reads your daily data. Adjusts the week's training plan when life changes. Tells you to back off when you need to. Talks to you like a coach, not like an app.

James Eastwood (who runs Coach Cadence on OpenClaw as part of a small fleet of personal agents) built the version we're looking at here. The fleet, in his words: a PA that runs his other bots and admin, a trader for his investments, an endurance coach (Coach Cadence), a home assistant, and a Catalan teacher.

Coach Cadence is the one that earned the most love in his showcase. The reason: it does the boring middle work that a $200/month human coach does, without the scheduling friction, the texting back-and-forth, and the wait time between adjustments.

The architecture is the part that matters more than the use case. James called out the hardest part himself: getting the balance right between agent autonomy and an engine that prevents hallucinations. That's the lesson worth keeping, whether you're using it for endurance training, strength programming, marathon prep, or anything else where wrong-in-confident-tone could hurt you.

Why This Works

Endurance training is a data-rich, advice-poor problem. You have:

What you don't have: someone who watches all of it daily and adjusts. Most amateur athletes get advice from a generic plan they bought on a PDF, a coach they check in with weekly (if they have a coach at all), or a community on Strava that's louder than it is helpful. The data is great. The advice loop is broken.

A well-built AI coach closes the loop. It reads the data every morning. It sees that you slept five hours and your HRV is in the basement. It moves your hard Tuesday session to Wednesday. It tells you why. You go run an easy thirty minutes instead of trying to hit intervals.

What makes the OpenClaw version different from a generic LLM is the engine layer. The agent is not freelancing. It is proposing changes against a structured training plan, and a deterministic engine validates each proposed change against the science before it tells you to do anything.

The Architecture That Makes It Safe

This is the core lesson from Coach Cadence and the part worth stealing for any "AI in charge of something physical" build.

Layer 1: The Engine

The engine is a deterministic system that knows the rules of endurance training. Not an LLM. Real code that encodes:

The engine is the bottom layer. It is deterministic. It does not hallucinate. It says yes or no to any proposed plan change.

Layer 2: The Agent

The agent (Claude through OpenClaw) is the conversational and proposal layer. It does the things engines are bad at:

The agent never writes directly to the training plan. Every change it proposes goes through the engine.

Layer 3: The Validator

When the agent proposes a change, the engine validates:

If the proposed change passes, the engine writes it to the plan. If it fails, the engine sends the failure back to the agent with the reason. The agent tries again with the new constraint information. This is the loop James called out as the hardest part: agent autonomy bounded by an engine that prevents hallucinations.

Layer 4: The Memory

Per-athlete memory the agent loads every time it talks to you:

The memory makes the coach feel like a coach who knows you. Without it, every conversation starts from scratch and the advice feels generic.

How to Build the Same Pattern (Adapted)

You don't have to ship Coach Cadence. The pattern works for any health-data domain. Here's how to build your own.

Step 1: Pick the Data Sources

For endurance training:

For strength training, you'd swap intervals.icu for Hevy or a similar log. For running, you might use Stryd plus a GPS watch. The data sources change; the pattern doesn't.

Step 2: Build the Engine

This is the part that takes the most time and the part where most "AI coach" projects fail. The engine is real software that encodes the rules of your sport.

For endurance, start with:

There are open-source endurance training libraries you can borrow from. Don't write this from scratch unless you're an exercise physiologist.

Step 3: Wire the Agent

The OpenClaw agent layer has three jobs:

The agent's tool layer includes:

Step 4: Encode the Hard Rules

Before you let the agent run live, write the hard rules:

These are in the system prompt and in the engine's validation rules. Either layer alone is not safe enough.

Step 5: Run It on Past Data

Before you let it manage your training going forward, replay it on the last 60-90 days of your data. Read what the agent would have proposed on each day. Compare it to what you actually did. Where the agent would have been wrong, dig into why. Tune the engine, tune the agent prompt, run it again.

Step 6: Live for One Microcycle, in Advisory Mode

The first week of live operation, the agent only proposes. It does not write to your training plan. You review every proposal and execute or override.

After a week of advisory mode, you have a feel for how often the agent is right vs. wrong. Tune until the agent is right 90%+ of the time on simple decisions.

Step 7: Hand Over the Steering Wheel

Once the agent is reliably right on simple decisions, let it write to the plan automatically. You still review the week's plan on Sunday night, but the daily adjustments run automatically.

The override switch is always available. You can revert any plan change with one message. The agent learns from your overrides over time.

Adapting This for Other Health Domains

The same pattern works wherever you have:

Strength and hypertrophy programming. Engine encodes progressive overload, deload weeks, and exercise sequencing. Agent reads your daily readiness and adjusts the day's lifts.

Marathon training. Engine encodes the specific demands of marathon prep. Agent reads sleep, soreness, and your subjective fatigue.

Triathlon prep. Engine handles the multi-sport balance across swim, bike, and run. Agent adjusts the week when one sport is more taxed than the others.

Weight management. Engine encodes caloric balance and the trade-offs between aggressive and sustainable deficits. Agent reads your daily weight, your tracked food, and your activity, and adjusts the calorie target for the week.

Recovery from injury or illness. Engine knows the safe return-to-training progression. Agent reads your daily indicators (pain scale, fatigue, energy) and either advances or holds the plan.

Sleep optimization. Engine encodes the inputs that drive sleep quality (light exposure, caffeine timing, training timing, evening routine). Agent reads last night's sleep and proposes one targeted change for tonight.

The architecture is the same every time. Engine. Agent. Validator. Memory. The domain rules change. The shape doesn't.

Gotchas and Tips

What This Replaces

Before this stack:

After this stack:

For a serious amateur athlete, the cost of bad training decisions is real. Missed races, injuries, plateaus, burnout. A 24/7 coach that reads your data and adjusts your plan is the highest-leverage personal AI build a fitness-minded person can run.

It is also one of the cleanest demonstrations of the broader pattern: AI is at its best when it watches a stream of data you generate, and proposes changes against an engine that knows the rules. Endurance training is one example. The same pattern is going to remake personal finance, nutrition, sleep, and a dozen other slices of life where data flows but advice doesn't.

James shipped Coach Cadence as one of five personal agents he runs. The longer-term story is the fleet, not the single agent. Coaches, advisors, assistants, tutors — each one a specialist that watches your data, makes proposals against a real engine, and only does what it's allowed to do.

This is what "AI runs my life" actually looks like when it's done well. Not one giant assistant that does everything badly. Small, specialist agents that each do one thing inside a rule system that keeps them safe.

Keep Reading