CodeMode + Graph in KAOS

KAOS now shows multi-agent systems in visual graphs that allow you to manage advanced concepts like Anthropic's code-mode: We have extended KAOS to support an interactive graph-visualisation screen that allows you to create and manage agentic resources intuitively. This enables advanced functionality such as introducing code-mode sandboxes which are now growing in popularity as an effective way to improve agent-to-mcp performance by aggregating multiple MCP servers and exposing them as local functions. We have extended support for Port-of-Context which is one of the first code mode implementations, providing a typescript code engine in rust, which is now exposed in KAOS as a native runtime that can be spinned up. To provide some intuition on how code mode works, traditionally an agent would have to make multiple MCP round trips as follows:

LLM: "I'll call add(42, 8)"      > Call -> Result
LLM: "Now I'll call multiply"    > Call -> Result
LLM: "Now I'll call power"       > Call -> Result
LLM: "Now I'll call uppercase"   > Call -> Result
LLM: "Now I'll call word count"  > Call -> Result
LLM: "Here's the final answer"

Now instead we can have a "code-mode" abstraction that converts all mcp servers into a unified set of functions, such that the agent just makes one call that is simple code - same example above would look like this:

LLM: "I'll call the following set of mcpservers through the code mode execution sandbox:
'''

  sum = await calc.add(...);

  product = await calc.multiply(...);

  squared = await calc.power(...);

  wordCount = await text.word_count(...);

  return result = await text.uppercase(...);


'''
  -> Call -> Result


LLM: "Here's the final answer"

This basically reduces the round-trips significantly and enables for a much more controlled experience to the LLM itself. There are various exciting initiatives also exploring this, including the recent announcement from the Pydantic team releasing a new Python runtime in Rust that will serve as the first Python code-mode environment. Check out the article for more details.

Building TikTok RecSys from Scratch

Build TikTok's Personalized Real-Time Recommendation System from Scratch. This is a fantastic talk from Jim Dowling's Hopsworks on basically how to build a TikTok-style personalized real-time recommender in Python using Hopsworks as the ML platform layer (e.g. feature store, vector index, model registry, and serving). It is particularly interesting to see such a practical example that demonstrates the theoretical foundations on what is one of the most impressive (and scariest) instant learning systems out there. The real time nature of retraining and capturing fresh features from user actions (eg views/likes/watch time), and making them available for inference is now a critical architectural requirement for any consumer facing teams. This is a pretty meaty talk/workshop which walks through an end to end architecture split into a feature / training pipeline that learns a two-tower embedding model from interaction data (e.g. user/query + video/candidate), and an online inference pipeline that embeds the latest user context + retrieves similar candidate videos via ANN/vector search to serves results through a simple Streamlit UI. Definitely a great resource to catch up for any MLOps practitioner out there!

RL-Aligned Ranking in RecSys

RecSys ranking is shaping what billions of people watch, buy, and believe, so small improvements (or mistakes) can have a huge impact on user experience - this is a great resource that explores LLM RLHF style approaches in recommender systems: It is quite interesting to take this current angle, namely while modern recommender systems ranking models are typically trained to predict click/engagement/return and then combined with a hand-coded value function, they rarely optimize that value end-to-end, creating a gap compared to LLM pipelines pre-RLHF. There seems to be an opportunity to treat the ranking model as a policy over items and adding an off-policy, propensity-weighted policy-gradient-style loss that directly maximizes a scalar value/reward model (analogous to an LLM reward model) while using constraints (akin to KL regularization) to control drift. This basically means that recsys optimization could be extended to the end to end, such that ranking becomes a true reward optimization without changing inference latency. It is quite interesting to see that some RL approaches that have been revolutionising LLMs are now being brought into more traditional fields of ML, as it seems there's quite a lot of opportunity (and everyone loves a chance to play with RL).

The Waymo World Model

"What should a self driving car do if a huricane appears infront of it?" These are the corner cases that are hard or impossible to train models on, which is why it's exciting to see World Models in practice already at Waymo being used for synthetic-data-like generation. Basically, Waymo’s World Model is a generative simulation system adapted from Google DeepMind’s Genie 3 (exciting to see applications already!) that creates hyper-realistic, interactive 3D driving environments and produces multi-sensor outputs including camera and lidar, letting Waymo run billions of virtual miles to validate safety beyond what fleet data alone can capture. This is pretty awesome; it basically can synthesize rare long-tail scenarios (e.g. extreme weather, unusual objects, safety-critical events) without the need for this data to exist. Apparently it is also designed to be highly controllable via driving-action, scene-layout, and language conditioning for counterfactual what-if testing. This is exactly the type of interesting applications that will become exciting, this is the type of thinking that should go with these models, not just "it will replace videogames", as if anything it is augmenting various fields already.

Metaflow + Kubeflow Announcement

Workflow orchestration is the backbone of production ML, so it was quite interesting to see the recent integration between Kubeflow (yes still alive!) and Metaflow: This seems like primarily an ability to write native Metaflow workflows and execute them with a backend in Kubeflow (ie in k8s) as Kubeflow Pipelines alongside current KFP workloads - which to my memory means they basically run as Argo Workflows / Tecton pipelines. Great to see some of the OGs of the MLOps space are still driving quality-of-life integrations to continue to evolve and improve the ecosystem. I believe Vertex AI still uses Kubeflow under-the-hood so this sounds like it would bring some robust benefits that metaflow brings (+ convenience).

The Institute for Ethical AI & Machine Learning is a European research centre that carries out world-class research into responsible machine learning.

✉️ Email, 🐦 Twitter, 💼 Linkedin