Adam Ladhari Français

Applied AI Engineer · Paris, France

Hi, I'm Adam

I build AI systems for interactive 3D and games.

I'm an applied AI engineer at Arcade AI, where AI agents turn a conversation into a multiplayer game. I work on those agents and on the engine they drive: visual effects, shaders, networking, vehicles and the gameplay core. Before that, I built a text-to-3D tool for a game studio, an adaptive learning platform, and games and tools for freelance clients.

See my work Get in touch

A small game world, generated in your browser. Drag to turn it

About me

I'm a software engineer specialised in applied AI. I graduated in software engineering from INSAT in Tunis in 2026, after internships and freelance work in games, 3D and AI, and I now work in Paris at Arcade AI.

What I enjoy most is owning a subject from start to finish: understanding the problem, building the solution, and checking with real tests and measurements that it works before it ships.

Games are where it started. I won one game jam and placed third in another, and I still build small games and AI experiments to understand how things work.

Based in
Paris, France
Currently
Applied AI Engineer, Arcade AI
Education
Software engineering degree, INSAT Tunis, 2026
Focus
AI agents, game engines, online multiplayer, generated effects and 3D

Experience

  1. Feb 2026 – presentParis

    Applied AI Engineer

    Arcade AI · AI-native game engine

    • Agent harness: core engineer on the agent system that turns a prompt into a playable 3D game, with specialist sub-agents for the world, logic, effects, interface and audio, made reliable by typed contracts, validation gates, cost ceilings and failure breakers.
    • Text-to-VFX: built the system that compiles a written description into a visual effect, renders it, has an AI critique it and revises it until it reads right. It is backed by a preset library, an authoring workshop and a runtime API used by every game.
    • Multiplayer: server-authoritative netcode with client prediction and lag compensation up to 250 ms, solo and online kept identical by tests, deployed on Kubernetes (GKE).
    • Core engine: extended the engine with generic primitives (gravity fields, portals, voxel worlds, hit regions, abilities) that make new kinds of games possible. 100 complete games shipped to production on it.
    • Shaders and materials: shaders generated from a prompt, validated offscreen and tuned live, in one material model the agents can use.
    • Vehicles: designed and built the physics-driven vehicle system, playable solo and online against AI opponents, and used across circuit racing, kart battles and portal races.
  2. Jul – Aug 2025Tunis

    AI Programmer Intern

    Lanterns Studio · Game studio

    • Built a text-to-3D pipeline: from a sentence to a 3D model with realistic materials, in a file a game can load.
    • Added automatic clean-up in Blender and quality checks, and deployed the tool online on Hugging Face Spaces.
  3. Jan – Jun 2025Tunis

    Full-stack Developer, part-time

    AXIO · AI learning platform

    • Built an adaptive learning platform: it tracks each learner's progress, curates their lesson path, detects frustration from time on task and brings in an LLM agent that answers from the course documentation (RAG).
    • Modular architecture with fine-grained access control; automated unit and end-to-end tests (CI/CD) cut release time by 35%.
  4. Jun 2023 – May 2025Remote

    Software Engineer

    Freelance · Upwork and direct clients

    • Emotion-driven gameplay: a Unity plugin that reads the player's facial emotion in real time and adapts the gameplay, with a dashboard analysing players' emotional feedback.
    • A hyper-casual mobile game, designed and shipped in Unity.
    • Automated Gerber image processing in Python, cutting pre-production cycles by 75%.
    • Automated trading tools (MQL4/5) for adaptive risk management, with 70% lower CPU load through multithreading and caching.
  5. 2021 – 2026Tunis

    National Engineering Degree in Software Engineering

    INSAT · Engineering school, Tunis

Selected work

Nine things I built, explained in plain words. Each one comes with an interactive 3D demo you can open.

Arcade AI · Agent harness

An agent system that builds a whole game from one prompt

I'm a core engineer on the agent system that turns a written prompt into a playable 3D game, made reliable by its structure rather than by its prompt.

5 specialist sub-agents: world, logic, VFX, UI, audio

Read the details

The problem

A game is too big for one AI answer. It has a world, rules, effects, an interface and sound, and one mistake in any of them can break it. Asking the model to be careful does not make it reliable, and a run that goes wrong can keep spending without getting anywhere.

What I built

A harness, the structure the agents work inside: one tool-use loop (the model chooses a tool, uses it and reads the result), skills loaded only when they are needed, specialist sub-agents for the world, the game logic, the visual effects, the interface and the audio, and a memory kept for each level.

How I checked it

The checks are part of the system. Every output follows a typed contract, a strict format the code can verify. Validation gates reject an output that breaks its contract before it reaches the game. Cost ceilings cap what a run can spend, and failure breakers stop a run that keeps failing.

The result

Reliability that comes from the system, not from the prompt: a prompt goes in, and a playable 3D game comes out.

specialist sub-agents: world, logic, VFX, UI, audio
5
typed contracts, validation gates, cost ceilings, failure breakers
4 safeguards

Arcade AI · Text to VFX

Visual effects generated from a description

I built the system that turns a written description of an effect into a real-time visual effect, checked by an AI that looks at the result and asks for changes.

every game uses the effects runtime API

Read the details

The problem

Games need effects: fire, sparks, smoke, magic. When the request is free text, asking an AI to place particles directly gives effects that look wrong, and nothing tells the system that they do.

What I built

A compiler from the description to a bounded phenomenon specification. It describes what is being simulated (a flame, a shockwave, a swirl of dust), not which particles to spawn, and stays within limits the engine can run. The engine then renders that specification as an effect.

How I checked it

The effect is rendered, and a multimodal model, an AI that can read images, critiques the picture. The specification is revised and rendered again, in a loop, until the effect reads right.

The result

The text-to-VFX system, backed by a preset library, an authoring workshop to build and adjust effects, and a runtime API that every game uses.

uses the effects runtime API
every game
render, critique, revise until the effect reads right
critique loop

Arcade AI · Online multiplayer

Making an online game feel instant and fair

I built the networking that keeps online games responsive and fair on slow connections, and the infrastructure that runs every game server.

250 ms of delay covered by lag compensation

Read the details

The problem

Online, every message takes time to travel, so each player sees a slightly old version of the game. Without care, your character reacts late and shots that looked on target miss. And only the server should decide what really happened.

What I built

A server-authoritative simulation built with Node.js, Colyseus and Rapier: the server has the final say, and only what changed is sent over the network (delta replication). The player's device shows the result of an action at once and corrects itself if the server disagrees (client prediction and reconciliation). For shots, the server looks back in time to where the target was when the player fired (lag compensation). It runs on Kubernetes (GKE): one addressable pod per game server, autoscaling, matchmaking and CI/CD.

How I checked it

Tests enforce that a game behaves the same solo and online, through the same API, so a game built for one works in the other.

The result

Online games that stay fair with up to 250 ms of network delay, on servers that scale with the number of games being played.

of delay covered by lag compensation
250 ms
same API, enforced by tests
solo = online
per game server, autoscaled on GKE
1 pod

Arcade AI · Core engine

Engine primitives that make new kinds of games possible

I extended the engine core so that new kinds of games become possible, solving each need with a generic building block. 100 complete games have shipped to production on it.

100 complete games shipped to production

Read the details

The problem

Every new kind of game asks something new of the engine: walking around a small planet, stepping through a portal, building with blocks. Writing special code for each game does not scale, least of all when AI agents are the ones assembling the games.

What I built

Each need solved as a generic primitive rather than game-specific code: gravity fields, portals, voxel worlds, hit regions and abilities. Any game, and any agent, can combine them.

How I checked it

Proven by shipping: complete games built on these primitives and released to production.

The result

100 complete games shipped to production on the engine.

complete games shipped to production
100

Arcade AI · Shaders and materials

Shaders an agent can write and anyone can tune

I made shaders a first-class asset that can be authored: generated from a prompt, validated before use, and tuned live without generating them again.

offscreen validation before a shader reaches a game

Read the details

The problem

A shader is a small program that runs on the graphics card and decides how a surface looks. Writing one by hand takes expertise, a generated one can fail to compile or render nothing, and changing its look usually means generating it again.

What I built

A path from a prompt to a procedural shader, with parameters exposed so they can be tuned live without regenerating. A single material model covers both standard physically based (PBR) materials and shaders, and tools expose it to the agents.

How I checked it

Every generated shader is validated offscreen, rendered out of view, before it is used in a game.

The result

Shaders as a first-class authorable asset: generated, validated, then tuned live by people or by agents.

validation before a shader reaches a game
offscreen
parameter tuning, with no regeneration
live
material model for PBR and shaders
1

Arcade AI · Vehicles

One vehicle system for every kind of vehicle game

I designed and built the engine's physics-driven vehicle system: generic, drivable solo or online against AI opponents, and proven across many vehicle games in production.

3 genres circuit racing, kart battles, portal races

Read the details

The problem

Circuit racing, kart battles and portal races all need vehicles that behave physically, that work online as well as solo, and opponents to play against. Building that again for every game would not scale.

What I built

A generic vehicle system driven by physics rather than scripted paths, so one vehicle can serve different games. It drives the same solo and online, and AI opponents drive it too.

How I checked it

Proven in production across a wide range of vehicle games: circuit racing, kart battles and portal races.

The result

One vehicle system behind many vehicle games, solo and online, with AI opponents.

circuit racing, kart battles, portal races
3 genres
with AI opponents
solo + online

Lanterns Studio · Text to 3D

A game-ready 3D object, generated from a sentence

I built a tool that turns a written description into a 3D object with its materials, in a file a game can load.

text → GLB mesh and realistic materials in one pipeline

Read the details

The problem

AI can produce a 3D shape from a sentence, but a raw shape is not yet a game asset. It needs materials, a reasonable number of triangles and a file format the engine can load, and the person using the tool needs some control over the result.

What I built

A generation pipeline based on EmbodiedGen, a text-to-3D generation system: from the text it produces a 3D mesh with realistic materials (PBR) and exports a GLB file, a standard 3D format. Around it, an app built with Gradio: automatic and manual modes, seeds to reproduce a result, background removal and ranking of the candidate images.

How I checked it

Quality checks built into every generation, then automatic clean-up in Blender running without a screen: rebuilding a cleaner mesh (retopology), reducing the triangle count (decimation) and exporting to OBJ or GLB.

The result

A working pipeline from a sentence to a GLB file, deployed online on Hugging Face Spaces with a Docker image that includes GPU support and Blender.

mesh and realistic materials in one pipeline
text → GLB
deployed online, Docker GPU + Blender image
Hugging Face Spaces

AXIO · Adaptive learning with an AI assistant

Noticing when a learner is stuck, and helping at that moment

I built a learning platform that adapts the course to each learner and brings in an AI assistant when it detects they are stuck.

−35% release time, thanks to automated tests and delivery

Read the details

The problem

Every learner moves at a different pace, and a learner who is stuck needs help at that moment, not at the end of the course.

What I built

An adaptive learning platform: it tracks each learner's progress and curates the path, choosing the next lessons to fit. It is built as independent modules, with fine-grained control over who can access what.

How I checked it

The platform detects frustration from how long a learner spends on a task. When it does, an AI agent steps in and answers from the course documentation itself, a technique called RAG (retrieval-augmented generation). Every release goes through automated unit and end-to-end tests (CI/CD).

The result

A platform that reacts to each learner, and a release time cut by 35%.

release time, thanks to automated tests and delivery
−35%
answers from the course documentation
AI agent + RAG

Freelance · Emotion-driven gameplay

A game that reacts to how the player feels

For a freelance client, I built a Unity plugin that reads the player's facial emotion in real time and adapts the gameplay to it.

real time facial emotion recognition driving the gameplay

Read the details

The problem

Most games run the same way whatever the player feels. The client wanted gameplay that adapts to the player's emotional state while they play.

What I built

A plugin for the Unity game engine that recognises the player's facial emotion in real time with deep learning, and connects it to the game logic.

How I checked it

A dashboard that analyses players' emotional feedback, so the effect on players can be read instead of guessed.

The result

Gameplay that adapts to the player in real time, and a dashboard that shows how players felt.

facial emotion recognition driving the gameplay
real time

More projects

Personal, jam and university projects: where the taste for games, AI and tools comes from.

Games

Faysa

Game jam, 1st place

A time-travel puzzle game where you cooperate with past versions of yourself to solve platforming challenges.

Nos · DreamScape: The Lucid Mission

Game jam, 3rd place

A dream-based adventure: a lucid dreamer, guided by a genie, has to save the dream world. Each dream mission brings a new gameplay style.

EchoMIDI

A rhythm memory game in Unity URP with MIDI support: replay an ever-growing sequence of notes on a MIDI keyboard or a virtual piano. Guided mode, velocity sensitivity, dynamic difficulty.

Code · GitHub

Fruit Slicer VR

A VR fruit-slicing game in Unity with real-time physics and blade collision.

Code · GitHub

Pencil Sharpener

A hyper-casual game with one job: sharpen pencils fast. Built for quick mobile-style play.

The Boiz

A collaborative escape-room game made with and for friends.

AI

Parki

A smart parking system with licence plate recognition and mobile tracking. Python, Flutter, YOLO.

Code · GitHub

GameDB

A tool that scrapes Reddit and YouTube comments to analyse what players love or hate about a game. Python, BERT, web scraping.

Code · GitHub

Formation Recommender

A multi-label recommender that suggests up to three training programmes per user, with confidence thresholds and model calibration. Python, XGBoost, scikit-learn.

Code · GitHub

Tools

Img2Gerber

An automation pipeline that converts layered image designs (PNG/SVG) into production-ready KiCad Gerber files, in batch. Python, KiCad API, Inkscape CLI, OpenCV.

Gurobi Wrapper

A desktop tool to solve LP/ILP optimisation problems with Gurobi, with a GUI for inputs, outputs and settings.

Web

Elmarchi

An online marketplace built in Angular as a university group project.

Code · GitHub

Tuniscape

A travel agency website built with Symfony: booking modules, forms, server-side rendering.

Code · GitHub

InnovaBank

My first university web project: a simulated bank interface in plain HTML, CSS and JavaScript.

Skills

Agentic AI
Agent harness design, tool use, MCP, multi-agent orchestration, RAG, agent memory, context engineering, structured outputs, guardrails, benchmarking, evaluation and tracing
Generative AI
GPT, Gemini, Claude, multimodal critique loops, text/image-to-3D, generative audio and VFX, LLM customisation, TensorFlow, deep learning
Engines and 3D
PlayCanvas, WebGPU, Unity, Unreal Engine (Blueprints, C++), Three.js, OpenGL, HLSL, Blender
Networking and backend
Colyseus, Rapier, Node.js, NestJS, Socket.io, PostgreSQL, Prisma, Docker, Kubernetes (GKE), Cloud Run, CI/CD
Languages
TypeScript, JavaScript, Python, C#, C++, Java

Awards and certificates

NVIDIA
Efficient Large Language Model (LLM) Customization certificate (Oct 2024)
Game jams
Android Club Game Jam, 1st place; Playground Game Jam, 3rd place (2024)
CTF
SparkCTF, 1st place; Cybersphere CTF, 2nd place (2024)

Contact

Based in Paris. The fastest way to reach me is email.

adamldr3@gmail.com LinkedIn GitHub ArtStation YouTube