ReAgentLive

La sonde live, in-process, pour le reverse engineering de jeux piloté par IA.

Les outils statiques vous disent ce que fait le code. ReAgentLive vous dit ce qui est vrai dans le jeu en cours d'exécution, à l'instant présent, et vous permet de le tester sans rien casser.

Live. Il s'exécute à l'intérieur du jeu et répond depuis la mémoire live, sur le tick propre au jeu. Sûr. Des références qui savent quand un objet est mort, des écritures qui vérifient d'abord, des changements qui s'annulent d'eux-mêmes. Immédiat. Pas de base de données, pas des heures d'analyse : les questions sur le code reçoivent une réponse à partir des octets live en quelques millisecondes.

Prise en charge native d'Unreal Engine. Compilez le pack Unreal contre le SDK Dumper-7 généré pour votre jeu, et travaillez par nom : trouver des objets, lire et suivre les champs reflétés, appeler des fonctions, lister chaque instance d'une classe, le tout sur le thread du jeu. Tout le reste (mémoire, code, structures natives) fonctionne dans n'importe quel jeu.

---

Le problème

Pointez un agent IA vers un jeu en cours d'exécution avec les outils habituels et il se heurte aux mêmes murs :

• Les lectures depuis l'extérieur sont déchirées. Deux valeurs lues à un instant d'écart ne proviennent jamais de la même frame.
• Les pointeurs deviennent obsolètes. Un ennemi réapparaît et l'adresse d'hier est désormais la mémoire de quelqu'un d'autre.
• Les écritures brutes font planter les choses. Un octet de travers, aucun retour en arrière.
• L'analyse statique est lente. Des heures d'analyse de programme entier avant la première réponse, et de nouveau après chaque patch.
• Les surfaces d'outils gigantesques dévorent le contexte. Une centaine d'outils coûtent à un agent son budget avant même qu'il ne fasse quoi que ce soit.

ReAgentLive est construit autour de ces murs.

30 secondes de démonstration

Chargez une DLL dans n'importe quel processus x64, ici un interpréteur Python en cours d'exécution, et posez vos questions. Pas de jeu, pas de SDK, pas de base de données. Sortie condensée à partir du JSON que la console affiche :

> reagentlive -c "search text PYTHONPATH --module python313.dll --paged --timing"
  hits: python313.dll+0x2c1ca8                               4.9 ms

> reagentlive -c "xrefs python313.dll+0x2c1ca8 --timing"
  lea  python313.dll+0x12ff02  in function +0x12fd64..+0x1301ce
  scanned all of python313.dll                               29.6 ms

> reagentlive -c "disasm python313.dll+0x12ff02 3"
  +0x12ff02  lea rdx, [0x7FF827981CA8]   string: "PYTHONPATH"
  +0x12ff09  mov rcx, rbx
  +0x12ff0c  call python313.dll+0x1301d0

Une chaîne, chaque endroit où le code l'utilise, et le code autour : trois commandes, bien moins d'une seconde, directement depuis les octets que le processus exécute. Chaque adresse revient sous la forme module + rva, prête à être collée dans votre désassembleur.

Pourquoi c'est différent

Aucun de ces éléments n'est nouveau pris isolément. C'est la combinaison qui l'est.

ReAgentLive	La méthode habituelle
À l'intérieur du processus, sur un thread auquel l'hôte fait confiance. Aucun débogueur attaché, aucun hook propre	Un débogueur, un framework de hooking, ou une lecture depuis l'extérieur
Précis au tick : sur le thread du moteur, tout ce qui figure dans une même réponse provient du même instant	Lectures incohérentes depuis l'extérieur, ou interrogation périodique
Sûr par construction : des références qui refusent un objet remplacé, des écritures uniquement sur les octets attendus, des pins et des essais qui expirent d'eux-mêmes	Écritures brutes confiées à un agent
Conçu pour les coûts d'une IA : une seule console, peu de commandes qui chacune effectuent une recherche complète, une sortie filtrée, un état conservé entre les exécutions	De vastes surfaces d'outils qui remplissent d'abord le contexte
Immédiat : des questions de code sur une adresse à partir d'octets vivants, sans base de données	Des heures d'analyse avant la première réponse
Réflexion et mémoire brute dans un seul outil : objets Unreal et structures natives côte à côte	L'un ou l'autre

Empreinte réduite

ReAgentLive est discret. Il répond lorsqu'on l'interroge et, sinon, reste hors du chemin du jeu :

• Aucun hook propre. Le cœur ne patche jamais le code ni n'échange de pointeur ; l'origine du tick relève de l'hôte.
• Aucun thread propre. Il s'exécute sur un thread que l'hôte possède déjà. L'exemple own-thread en ajoute exactement un, son tick ; la recherche en arrière-plan n'ajoute un worker que lorsque l'hôte l'autorise.
• Aucun handle de processus. Le client n'ouvre jamais le processus du jeu : pas d'OpenProcess, pas de ReadProcessMemory, pas de débogueur. Les requêtes transitent par une seule section de mémoire partagée nommée.
• Quasiment rien au repos : un incrément atomique et une comparaison par tick. Des tampons fixes, aucune allocation au chargement.

Empreinte réduite signifie qu'il ne perturbe pas le jeu. Cela ne signifie pas qu'il est caché : voir ce qu'il n'est pas.

Ce que vous pouvez faire

Si vous voulez	ReAgentLive vous offre
Voir ce que fait le jeu à l'instant présent	trouver des objets, les dumper, suivre des chemins de champs, lire des conteneurs, échantillonner n'importe quelle valeur à chaque tick
Tester une idée sans recompiler	des écritures gardées, des pins qui maintiennent une valeur, des écritures d'essai qui se défont d'elles-mêmes, des appels au moteur
Comprendre le code sans attendre	la voie rapide : instructions, références, fonctions utilisant un offset, vérifications de signature
Nommer ce que vous avez trouvé	étiqueter une fois les membres non reflétés ; exporter les étiquettes vers votre outil statique
Laisser une IA faire tout ce qui précède	une seule console avec du JSON en entrée et en sortie, un client Python, et une compétence qui enseigne la méthode

Essayez en cinq minutes

L'exemple own-thread est une DLL qui fonctionne dans n'importe quel processus x64 : aucun mod, aucun SDK, aucune connaissance du jeu.

# From a Visual Studio x64 developer shell, in the ReAgentLive folder:
cmake -S examples/own_thread -B build/own-thread -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build/own-thread
# Load reagentlive-own-thread.dll into the target with any DLL loader, then:
reagentlive -c "status; modules"

Vous obtenez la mémoire, la voie rapide et les objets natifs (vtable, chaînes de pointeurs, region, chaînes de caractères). Sans pid, la console trouve le processus toute seule. Plus d'informations : exemple own-thread.

Au mieux sur le thread du jeu

La DLL own-thread est le moyen le plus rapide d'entrer. ReAgentLive est à son meilleur lorsque l'hôte le cadence sur le thread de jeu du moteur, depuis un mod ou un hook que vous possédez déjà :

L'hôte cadence sur	Vous obtenez
Le thread du jeu	tout : commandes d'objets et de champs, appels au moteur, et un tick qui est un instant du jeu (batch et get indiquent avec same_tick s'ils tiennent dans un seul)
Un autre thread (le sien, ou la présentation de frame)	la mémoire, la voie rapide et les objets natifs ; les commandes moteur sont refusées, et les lectures dans un même tick ne sont pas nécessairement cohérentes

status indique lequel vous avez (host_thread). Comment accéder au thread du jeu relève de l'hôte ; ce que chaque choix apporte est décrit dans hosting.

Aller plus loin