DEV Community: Emilien Mottet

From MITM to Agentic Design: Automating Sports Nutrition with Claude, n8n, and Hexis

Emilien Mottet — Mon, 29 Dec 2025 01:44:12 +0000

Automating sports nutrition is the Holy Grail for many amateur athletes. We want the precision of a nutritionist without the mental load.

My goal was simple: synchronize my workouts (Intervals.icu / nolio.io) with my nutritional needs (Hexis.live) and generate automatic meal plans.

For those unfamiliar, Hexis is an intelligent nutrition platform that calculates your real-time energy needs (carbs, proteins, fats) based on the intensity of your past and future workouts. The problem? Hexis does not have a public API for meal creation.

Here is how I combined Reverse Engineering, Man-in-the-Middle, Advanced Agentic Design, Meta-MCP, and n8n to build an autonomous and cost-effective system.

1. The Hack: Reverse Engineering & Man-in-the-Middle

Since the front door was locked, I went through the window. To automate meal logging, I set up a Man-in-the-Middle (MITM) attack to listen to traffic between the mobile app and the servers.

Unexpectedly, this interception proved easier to set up on iPhone than on Android, allowing me to quickly map the structure of the private APIs.

I discovered that the API doesn't just settle for a food ID. It requires a specific refCode (a Base64 string hidden in search results) to validate the log. Without this key, the API returns a silent error.

I encapsulated this complexity (search + refCode extraction + formatting) in a custom MCP server. For my AI agents, the operation becomes transparent: they ask to "add a banana", and the server handles the cryptography backstage.

2. Crew Architecture: 2 Pipelines and 10 Agents

Once data access was solved, I built the system's "brain" with CrewAI. The architecture is split into two distinct pipelines to ensure precision and reliability.

🧠 Pipeline 1: Data Analysis

This first group defines the nutritional strategy:

HEXIS_DATA_SUPERVISOR: The Strategist. Plans which data to retrieve (training load, recovery status). Pure "Thinking" model, no tool access.
HEXIS_ANALYSIS_REVIEWER: The Nutritionist. Analyzes raw data to define precise macro targets (e.g., "Tomorrow is a big session, we need 400g of carbs").

🍳 Pipeline 2: Meal Generation

This is where magic happens to turn numbers into recipes:

MEAL_PLANNING_SUPERVISOR (The Chef): Designs the structure of the 4 daily meals respecting energy codes (Low/Medium/High Carb) and ensuring culinary variety.
INGREDIENT_VALIDATION_EXECUTOR (The Commis): The only agent allowed to talk to the database. Uses parallel execution to quickly validate ingredient existence in the Passio/Hexis database.
MEAL_RECIPE_REVIEWER (The Controller): Performs final mathematical calculations. If the Chef planned too much chicken, the Reviewer adjusts the portion to the gram to hit ±5% of targets.

This structure relies on a key principle: Reasoning/Action Separation. "Intelligent" models (Supervisors) never touch tools to avoid hallucinations. They delegate technical execution to simpler, faster models (Executors).

Support Agents

Other agents (Weekly Structure, Nutritional Validation, Integration) ensure overall weekly consistency and final synchronization to the app.

3. MCP Infrastructure: Why Meta-MCP?

I use Meta-MCP, an essential abstraction layer. Why? Mainly for security and modularity.

It allows me to group tools by domain (Sports, Nutrition, Weather) and distribute to each agent only what it strictly needs. Thus, my "Hexis Executor" doesn't risk accidentally deleting a Strava activity. It's a least privilege principle applied to AI agents.

4. Cost Optimization: Smart AI Pricing

Running autonomous agents 24/7 has a cost. To avoid an astronomical bill, I implemented an aggressive strategy:

Reverse Proxies & Alternative Models

I use OpenAI-compatible Reverse Proxies (like CLIProxyAPI) to access high-performance alternative models. Special mention to DeepSeek and GLM-4.6 (via z.ai) which now offer performance close to Claude 4.5 Sonnet for a fraction of the price.

Using specialized "Coder" models for structured tasks (JSON) also drastically reduces costs without quality loss.

Automatic Rotation

My system manages a model cascade. If the "Premium" model (Claude 4.5 Sonnet) hits its quota or rate-limit, the system automatically switches to an "Eco" model (GPT-4o-mini or GLM-4) to finish the task. It's transparent to the user and saves production.

5. Orchestration with n8n

Having intelligent agents isn't enough; they need to live over time. That's where n8n comes in.

I set up a workflow (meal-planning-weekly) that runs every Sunday evening:

Retrieve training load: The workflow queries Intervals.icu (or nolio.io) to know my upcoming sessions for the week.
Schedule optimization: A JS script reorganizes my slots (e.g., "If big bike ride on Saturday -> High carb meal on Friday night").
Asynchronous Call to AI: n8n triggers my CrewAI Python script via an HTTP webhook.
Callback Pattern: Since meal generation takes time (several minutes of thinking for the agents), n8n doesn't block. It waits for a return "ping" (callback) once the agents have finished their work.
Distribution: The final result (shopping list + menu) is sent directly to Telegram.

Conclusion

This project demonstrates that with thoughtful architecture, we can bypass closed API limits and create AI systems that are truly useful in daily life.

By combining the reasoning power of "Thinking" models, the execution precision of MCP servers, and the robust orchestration of n8n, we are no longer in gadget territory, but dealing with a real personal assistant.

The code is available on my GitHub. Next step? Automating grocery ordering via a drive-thru API... the next reverse engineering challenge!

👉 https://github.com/EmilienMottet/crew-coach

A journey into the depths of gitlab-ci

Emilien Mottet — Wed, 03 Mar 2021 21:48:03 +0000

The beginning of an adventure

After spending a lot of time on the awesome exercism.io platform, I was able to learn a lot of new languages and received great advice. After having accumulated a lot of exercism, I tried to automate and industrialize it. I was able to discover advanced features proposed by gitlab-ci. Here is my feedback

Exercism

Exercism is a community site, where people wishing to learn a new language can receive expert advice from volunteer mentors.
To learn a language, it is advisable to follow a path that corresponds to a logical sequence of exercises to have a regular progression in the language.

Here is the list of all the tracks (learning paths) available on the platform.

Exercism offers a cli to download and upload these exercises. This system is good but does not replace a versioning with git. So I use git to version my exercises.

The exercism folder is composed of subfolders for each language, and each language contains a folder for each exercism.

Here is an example of the architecture of an exercism folder.

exercism
+-- c
|   +-- hello-world
|       +-- hello-world.c
|       +-- hello-world-test.c
+-- go
|   +-- leap
|   |   +-- leap.go
|   |   +-- leap_test.go
|   +-- hamming
|       +-- hamming.go
|       +-- hamming_test.go
+-- ruby
    +-- sieve
        +-- sieve.rb
        +-- sieve_test.rb

Each exercise has tests to validate. The exercises use the TDD method. Once the tests have been validated, the solution can be submitted and the return of a mentor is requested.

After accumulating many solutions, I wanted to have an IC that would allow me to stabilize and keep my exercises up to date if new tests were added.

Moreover, the way of executing the tests is similar depending on the tracks/languages. For example the exercises in go will be tested with the command go test or for java exercises gradle test.

Wanting to follow the DRY principle, I would like to have a CI template that I could apply to all the exercises in the same language and add this CI to all the new exercises.

I compared the different continuous integration solutions available for open source projects (Jenkins, CircleCI, Travis CI, Codeship Gitlab CI). I chose gitlab-ci because it offers the most interesting specifications and features.

🦊 The Powerful Feature : Parent Child Pipelines

Gitlab offers a free CI, which can be easily integrated into a git project and even integrated into a Github project. Cool, my repo is on github

Parent Child Pipelines

They allow to execute a CI from a CI. It is therefore possible to create a meta-CI. Despite some limitations that we will see later, Parent Child Pipelines allow me to spread my CI over 3 nested levels :

At the root of the exercises folder which will execute a CI for each language. The simplest file, it just has to trigger the ci of the languages:

emacs-lisp:
  stage: test
  trigger:
    project: EmilienMottet/exercism-emacs-lisp-sol
    strategy: depend
  rules:
    - changes:
        - emacs-lisp/*

x86-64-assembly:
  stage: test
  trigger:
    project: EmilienMottet/exercism-x86-64-assembly-sol
    strategy: depend
  rules:
    - changes:
        - x86-64-assembly/*

Full file

At the root of each language that will execute a CI for each exercise:

{
   "generate_c_gitlab_ci": {
      "artifacts": {
         "paths": [
            ".c-*-gitlab-ci.yml"
         ]
      },
      "image": {
         "entrypoint": [
            ""
         ],
         "name": "bitnami/jsonnet:latest"
      },
      "needs": [
         {
            "job": "build_vars",
            "pipeline": "$PARENT_PIPELINE_ID"
         }
      ],
      "script": [
         "jsonnet -m . --ext-str exercism_projects=\"$( echo $DIR_TO_BE_TESTED | sed -En 's/ /\\n/p' )\" --ext-str lang=\"c\" \".c-gitlab-ci.jsonnet\""
      ],
      "stage": "build"
   },
   "test_c_armstrong-numbers": {
      "stage": "test",
      "trigger": {
         "include": [
            {
               "artifact": ".c-armstrong-numbers-gitlab-ci.yml",
               "job": "generate_c_gitlab_ci"
            }
         ],
         "strategy": "depend"
      }
   },
   "test_c_hello-world": {
      "stage": "test",
      "trigger": {
         "include": [
            {
               "artifact": ".c-hello-world-gitlab-ci.yml",
               "job": "generate_c_gitlab_ci"
            }
         ],
         "strategy": "depend"
      }
   }
}

Template file

At the root of each exercise to run the tests provided by the platform :

{
   "default": {
      "image": "gcc:latest"
   },
   "test-c-armstrong-numbers-exercism": {
      "script": [
         "cd armstrong-numbers",
         "make"
      ]
   }
}

Template file

Note the use of the rules field which allows each new push to execute the CI task only if there has been a modification in the given path.

To be DRY, I need to templating my CI, an example is proposed with jsonnet. Here is an example proposed by the gitlab team: https://gitlab.com/gitlab-org/project-templates/jsonnet.

A template for each situation

A gitlab-ci.yml file can be described in jsonnet format.

For example :

local exercism_projects = std.map(function(x) std.strReplace(x, '/', ''), std.split(std.extVar('exercism_projects'), '\n'));
local lang = std.extVar('lang');

local CTestJob(name) = {
  ['.' + lang + '-' + name + '-gitlab-ci.yml']: {
    default: {
      image: 'gcc:latest',
    },
    ['test-' + lang + '-' + name + '-exercism']: {
      script: [
        'cd ' + name,
        'make',
      ],
    },
  },
};


std.foldl(function(x, y) x + y, std.map(CTestJob, exercism_projects), {})

This template allows you to describe gitlab-ci.yml for C exercisms.

Morality, jsonnet templates to avoid repetition, it's perfect!

The almost perfect IC, multi project pipeline

Parent Child Pipeline are awesome but have several flaws, 2 were notable to me:

Only 2 levels for Nested child pipelines. In my case I need 3 levels. The limitation can be bypassed by using multi-project pipelines.
Management of files modified by the last commit to avoid rebuilding all exercisms.

For the management of modified files, it is possible to recalculate the modified files using a pre-step.

build_vars:
  stage: .pre
  script:
    - |
      if [ "$CI_PIPELINE_TRIGGERED" = "true" ]; then
        DIR_TO_BE_TESTED=$(ls -d */)
      else
        DIR_TO_BE_TESTED=$(git diff --name-only $CI_COMMIT_SHA^ $CI_COMMIT_SHA */ | cut -d'/' -f1 | sort | uniq)
        if [ -z $DIR_TO_BE_TESTED ]; then
          DIR_TO_BE_TESTED=$(ls -d */)
        fi
      fi
    - echo DIR_TO_BE_TESTED=$DIR_TO_BE_TESTED >> build.env
    - cat build.env
  artifacts:
    reports:
      dotenv: build.env

Once the exercisms has been modified, it can be exported to artifact to share it with the job that will be generated afterwards.

Submodule vs subtree

Because of the limitation of the number of nested and also a wish to separate the different tracks, I created a git repository for each track (manual action that could be automated with ansible).

The classic way to manage these nested projects would be to use the git submodule. However, keeping a consistent set of git submodule up to date can become quite restrictive.

There is an alternative ! The subtree :

git-subtree - Merge subtrees together and split repository into subtrees

The advantage I found in subtrees is that I can mirror only the tracks and automate this one simply with the git hooks. And this without modifying my existing one.

To create a subtree nothing could be simpler :

git subtree add --prefix=clojure --squash git@github.com:EmilienMottet/exercism-clojure-sol.git master

Then to make sure the subtrees is up to date, just add a hook to the post-commit..

Here is my hook file .git/hooks/post-commit :

#!/bin/sh

subtree_push(){
    git subtree push -P "$1" git@github.com:EmilienMottet/exercism-"$1"-sol.git master
}

for dir in */; do
    subtree_push "$( basename "$dir" )" 2> /dev/null &
done


for dir in */; do
    wait
done &

At each commit, each subtree is updated in the background.

Conclusion

I hope this article has made you want to try exercism.io and, why not, join this community.

Industrialize, as quickly as possible. Exercism has a version management system, however, complementing it with git allows you to go further:

For example, I can do my exercises on several machines
The automated tasks save me a lot of time
have a backup system
Just manage the history
share my work and make it visible on github.com.

Test yourself, the basis of exercise is the TDD. It is important to test yourself and your code all the time. Moreover, I want to keep my exercism compatible with the latest version of each language and in the future with new tests added by the community. Having up to date exercism allows you to always have up to date exercism that make a very good example, and it allows you to have a lot of stars ;)

DRY ! Do not repeat, Do not repeat (oops)! At first, factorized allows to gain clarity. Allows for sanctuarisation and transmission of knowledge. How many times you make a set of commands that are almost automatic, but after several months without doing them, you end up forgetting them. Taking the time to template, this time is quickly gained!

Thank you for reading :)