Filippo Lollato

Artificial Intelligence Developer

SeniorFrontend Developer

7/10State Management & Data Flow

2years in tech

5repositories checked by code analysis

Overview

C++ and Rust systems engineer (senior-level) focused on type-safe numeric systems and gameplay/robotics simulation with a strong emphasis on compile-time invariants. The strongest proven skill is metaprogramming for tensor shape and dtype invariants as implemented in include/incin/tensor.hpp together with the compile-fail tests and CMake packaging that validate the installed package. There is little to no public evidence of custom rendering shaders, networked multiplayer/netcode, or profiler-driven performance tuning in these human-authored files.

Timeline

Teaching Assistant / Academic Tutor · Middle

University of Trento · Full-Time

Trento In office

Serves as a tutor for undergraduate students, focusing on Rust and advanced programming topics including compilers and related subjects. Supports learning through guidance on coursework and assignment work. Has been tutoring since the 2024/25 academic year.

Rust

Projects

evolcpp

In progress, porting core abstractions from the incin framework to C++20. Implementing compile-time tensor shape checking using C++ templates to bring similar structural safety ideas into the C++ type system. Aims to extend the same invariants-oriented approach beyond Rust.

NLU

Developed a natural language understanding model for joint intent classification and slot filling on the ATIS dataset. Implemented the training pipeline and evaluation workflow to assess model quality on the benchmark. Achieved a reported intent classification accuracy of 0.9765.

ASA Autobots

Co-led a team project creating a multi-agent delivery system that combines BDI agents, an LLM coordinator, and symbolic planning via PDDL. Worked on system architecture and the integration of agent components and service interfaces. Focused on coordinating delivery workflows using both language and symbolic reasoning.

incin

Built a Rust machine-learning framework focused on compile-time safety checks for tensor shapes and invariants. Designed the code so model structure can be validated earlier, improving correctness and maintainability. The longer-term goal is to help research agents generate valid ML code with compiler feedback.

MOT Benchmark

Developed an academic multi-object tracking benchmark to compare tracking-by-detection approaches using reinforcement-learning-based tracking. Implemented a shared evaluation pipeline to run and compare multiple trackers across common MOT datasets. Analyzed outcomes with standard metrics and investigated evaluation/data issues to improve reproducibility.

Technical skills

Languages

C++

Rust

Lua

JavaScript

Node JS

Python

C++

STL

OpenGL

PyTorch C++

CMake

Frontend

Tailwind CSS

Astro

Three.JS

AI/ML

LLM

PyTorch

AWQ

ONNX Runtime

CUDA

Hugging Face

Ollama

vLLM

NLTK

Other

Axum

Tokio

GitHub

Docker

Git

Linux

Rest API

AI Agents

GGUF

ONNX

Machine Learning

CI/CD

RAG

WebSockets

Function Calling

Multi-Agent Systems

Quantization

Reinforcement Learning

Computer Vision

NLP

PPO

Senior Frontend Developer Confidence: High App Engineer

Senior-level frontend and application engineer focusing on interactive visualizations and complex client-side application logic. The single strongest proven skill is architecting complex state machines and asynchronous agent workflows, demonstrated by the generator-based BDI IntentionEngine and its preemption/resume model in ale-bena/asa-autobots/src/agent/Intentions.js. Public code does not show evidence of large-scale backend or cloud infrastructure ownership, formal a11y CI, or server-side rendering architectures.

UI Component Architecture

6/10

How interface parts are built

Component composition and slots used sensibly; bespoke tokens and CSS variables instead of an off-the-shelf design system, showing deliberate component design for a portfolio UI.

Evidence

xupremix/portfolio/src/components/ProjectCard.astro: slot usage, Props interface and composition with Badge.astro xupremix/portfolio/src/layouts/Layout.astro: layout wrapper, Nav/Footer composition and language setter xupremix/portfolio/src/components/ProjectCard.astro: scoped CSS variables and visual token uses (project-accent)

Responsive & Cross-browser

6/10

Works on all screens and browsers

Responsive behaviors and graceful degradation are present (ResizeObserver, prefers-reduced-motion, fluid canvas sizing); explicit handling of different breakpoints and devicePixelRatio.

Evidence

xupremix/portfolio/src/components/ProjectCard.astro: ResizeObserver usage and responsive lg:grid layout xupremix/portfolio/src/components/ProjectCard.astro: @media (prefers-reduced-motion: reduce) and CSS variable-driven styling xupremix/portfolio/src/scripts/signal-demo.ts: canvas sizing and coordinate math to adapt to container size

Performance Optimization

6/10

Speed of the interface

Measured, pragmatic runtime optimizations and rAF discipline; throttling and dt capping in animations and engine ticks show performance awareness.

Evidence

xupremix/portfolio/src/components/ProjectCard.astro: three.js renderer.setPixelRatio(Math.min(...)), requestAnimationFrame render loop xupremix/portfolio/src/scripts/signal-demo.ts: one rAF loop, delta-time animation, capped dt and sample scheduling ale-bena/asa-autobots/src/agent/Intentions.js: tick throttling (GOAL_EVAL_INTERVAL) and periodic cleanup to avoid expensive work every tick

Accessibility & Semantics

4/10

Usable for everyone

Basic a11y and semantics present (aria-hidden, focus-visible styling, keyboard shortcuts) but no evidence of automated a11y CI or advanced ARIA on custom widgets.

Evidence

xupremix/portfolio/src/components/ProjectCard.astro: aria-hidden on decorative elements and focus-visible handling on links ale-bena/asa-autobots/tools/map_builder.html: keyboard shortcuts, focus considerations and form input guards

State Management & Data Flow

7/10

Managing data in the app

Strong state discipline and dataflow design: generator-based plan engine, preemption/suspension stack, undo/redo and two-way JSON syncing in the map builder, and typed optimizer flows demonstrate deliberate state architecture.

Evidence

ale-bena/asa-autobots/src/agent/Intentions.js: generator-based BDI loop, suspendedStack preemption model, engine state snapshot/_applyEngineState ale-bena/asa-autobots/tools/map_builder.html (script): undo/redo stacks, skipJsonOutputUpdate flag and robust JSON<->UI sync ale-bena/asa-autobots/test/policy_optimizer.test.js: extensive tests exercising policy/optimizer flows and state transitions

UX & Visual Polish

7/10

Look and feel quality

UX polish and perceived-performance care: interactive demos with live metrics, clear play/pause semantics, honesty notes and motion-safe fallbacks show product-minded UX work.

Evidence

xupremix/portfolio/src/scripts/signal-demo.ts: RMSE live metric, sparkline, play/pause and motionSafe gating xupremix/portfolio/src/scripts/asa-demo.ts: single rAF loop, clear pause/resume semantics and interactive tooling xupremix/portfolio/src/components/ProjectCard.astro: visual accents, hover states and prefer-reduced-motion handling

Expertise

Modern Web Frameworks· Middle

Frontend Architecture & Build Tools· Middle

Industries

Artificial Intelligence· Middle

Gaming· Middle

Robotics· Middle

Technologies

JavaScript· Senior

Node JS· Senior

Tailwind CSS

Three.JS

Astro

Recommendations

Build interactive product experiences and marketing pages that require performant canvas/three.js visuals and low-JS shipping (OG generation, image capture pipelines).
Lead frontend features that need non-trivial client-side state machines or real-time loops, such as simulations, editors, and UX-critical dashboards.
Design and implement single-page apps that require careful async discipline, cancellation/throttling, and predictable state transitions (maps, planners, or telemetry UIs).
Own feature work that bridges UX and algorithmic logic, e.g., multi-agent demos, visualizations of ML/robotics systems, and in-browser prototyping of system behaviors.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

portfolio asa-autobots

Senior Game Developer Confidence: High Gameplay Engineer

Gameplay Systems & Mechanics

3/10

How game logic works

Gameplay systems and agent logic present: a deterministic gym/robot loop, RL training loop and replay buffer, but the systems are single-repo, single-process and lack large-scale simulation determinism or advanced tooling.

Evidence

ai_robot/src/gym/robot.rs: GymRobot process_tick/step/manual_action/update_dir logic

ai_robot/src/robot/train.rs: train and train_while_discovering loops and episode management

ai_robot/src/model/agent.rs: Actor-Critic training steps and replay memory integration

Graphics & Rendering

Drawing game visuals

Not evidenced in public code

Physics & Math

3/10

Game physics and math

Strong compile-time numeric and shape reasoning in C++ templates and runtime numeric verification tests, but no custom physics integrators or deterministic simulation scaffolding.

Evidence

incin-cpp/include/incin/tensor.hpp: extensive template meta-programming for Shape, MatmulShape, reshape/transpose/slice semantics and static_asserts

incin-cpp/tests/tensor_test.cpp: numeric equivalence tests, CUDA roundtrip checks and shape assertions

Engine Proficiency

4/10

Skill with the game engine

Clear engine/tooling proficiency shown by CMake packaging, relocatable Find/Package usage and install/export targets plus compile-fail test harness integration.

Evidence

incin-cpp/CMakeLists.txt: find_package(Torch REQUIRED), target_link_libraries with torch target, install/export and configure_package_config_file usage

incin-cpp/tests/consumer/CMakeLists.txt: consumer project to validate installed package relocatability and find_package(incin-cpp) behavior

Performance & Frame Budget

2/10

Keeping the game smooth

Some attention to low-level performance (zero-cost templates, reserve() in hot paths, CUDA-target checks) but no profiler numbers, documented frame-budget optimization or zero-alloc hot-path instrumentation.

Evidence

incin-cpp/include/incin/tensor.hpp: use of std::vector::reserve in stack/cat implementations and careful from_torch validation

incin-cpp/tests/tensor_test.cpp: CUDA availability checks and device roundtrip tests

Content Pipeline & Tooling

3/10

Tools for game content

Basic content and packaging pipeline is present: packaging, install targets and consumer verification plus test fixtures; higher-level CI and asset pipelines are outside the scored files.

Evidence

incin-cpp/CMakeLists.txt: install(DIRECTORY include/...), install(EXPORT ...), configure_package_config_file

incin-cpp/tests/consumer/CMakeLists.txt: consumer test project used by CI to validate package relocatability

Verified artifacts

ale-bena/asa-autobots· contrib

Expertise

Gameplay & Mechanics Development· Middle

Game AI & Pathfinding· Middle

Industries

Gaming· Middle

Technologies

Rust· since 2024 · Senior

Lua· since 2024 · Senior

OpenGL

Recommendations

Author low-level engine subsystems that require strong type guarantees and correctness proofs, such as mathematically-correct physics/math libraries or tensor-backed inference bindings in C++.
Develop gameplay AI systems and simulation loops that benefit from the existing Gym/Agent code; expand deterministic simulation, seed control and reproducible episode tooling.
Package and validate C++ libraries for downstream consumers, including relocatable CMake packages and compile-fail/installation test harnesses.
Extend performance work with profiler-driven optimizations and zero-alloc hot-path instrumentation around tensor conversions and device transfers.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

incin-cpp nvim ai_robot

Senior Embedded Engineer Confidence: High Generalist

C++ library engineer (Senior) focused on compile-time tensor invariants and host-side PyTorch integration. The strongest proven skill is advanced compile-time metaprogramming and type-level shape reasoning as implemented in include/incin/tensor.hpp together with compile-fail tests under tests/compile_fail. There is little to no evidence of embedded firmware, low-level hardware drivers, RTOS or power-management work in the public human-authored code.

Embedded & Firmware

Low-level device code

Not evidenced in public code

Hardware-Software Interface

Connecting code to hardware

Not evidenced in public code

Resource Constraints

Working with limited resources

Not evidenced in public code

Real-time & Timing

Precise timing control

Not evidenced in public code

HDL & Circuit Logic

Designing digital circuits

Not evidenced in public code

Reliability & On-device Testing

2/10

Testing on real hardware

Basic reliability and integration testing is present (unit-style runtime tests, compile-fail fixtures, and a relocatable-package consumer test) but there are no hardware-in-the-loop, on-device, power-loss or OTA/rollback strategies.

Evidence

xupremix/incin-cpp/tests/tensor_test.cpp: runtime numerical and shape tests exercising libtorch round-trips xupremix/incin-cpp/tests/compile_fail/matmul_inner_mismatch.cpp: compile-fail fixture exercising the static shape checks xupremix/incin-cpp/tests/consumer/CMakeLists.txt: consumer project verifying relocatable find_package and installed package behavior

Expertise

Low-level Development & Tooling· Senior

Industries

Artificial Intelligence· Middle

Technologies

C++· since 2024 · Senior

CMake

PyTorch C++

STL

Recommendations

Develop core C++ ML infrastructure and domain-specific compile-time DSLs (tensor invariants, safe bindings) using the existing include/incin/tensor.hpp as the foundation.
Own cross-language integration work that bridges libtorch/PyTorch C++ APIs with higher-level language bindings and packaging (CMake packaging and relocatable find_package consumer tests are present).
Design and maintain compile-time test suites and compile-fail fixtures for API evolution and semver guarantees.
Implement performance-sensitive kernel adapters or backend connectors (CUDA/XLA paths) where compile-time contracts map to optimized runtime kernels.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

incin-cpp

Job preferences

Work permits: Italy
Citizenship: Italy
Employment type: Full-Time

Open to AI agents: they read this profile and start a dialog through Alionalion.io/@filippo-lollato/mcp