diff --git a/core/src/main/java/fr/traqueur/commands/api/CommandManager.java b/core/src/main/java/fr/traqueur/commands/api/CommandManager.java
index 7e7d041..acc91df 100644
--- a/core/src/main/java/fr/traqueur/commands/api/CommandManager.java
+++ b/core/src/main/java/fr/traqueur/commands/api/CommandManager.java
@@ -5,6 +5,7 @@
 import fr.traqueur.commands.api.arguments.Arguments;
 import fr.traqueur.commands.api.arguments.TabCompleter;
 import fr.traqueur.commands.api.exceptions.ArgumentIncorrectException;
+import fr.traqueur.commands.api.exceptions.CommandRegistrationException;
 import fr.traqueur.commands.api.exceptions.TypeArgumentNotExistException;
 import fr.traqueur.commands.api.logging.Logger;
 import fr.traqueur.commands.api.logging.MessageHandler;
@@ -150,7 +151,7 @@ public void registerCommand(Command<T,S> command) {
                 this.registerSubCommands(alias, command.getSubcommands());
             }
         } catch(TypeArgumentNotExistException e) {
-            throw new RuntimeException(e);
+            throw new CommandRegistrationException("Failed to register command: " + command.getClass().getSimpleName(), e);
         }
     }
 
@@ -299,8 +300,8 @@ private void registerSubCommands(String parentLabel, List<Command<T,S>> subcomma
             return;
         }
         for (Command<T,S> subcommand : subcommands) {
+            // getAliases() already returns [name, ...aliases], so no need to add the name again
             List<String> aliasesSub = new ArrayList<>(subcommand.getAliases());
-            aliasesSub.add(subcommand.getName());
             for (String aliasSub : aliasesSub) {
                 this.addCommand(subcommand, parentLabel + "." + aliasSub);
                 this.registerSubCommands(parentLabel + "." + aliasSub, subcommand.getSubcommands());
@@ -318,8 +319,8 @@ private void unregisterSubCommands(String parentLabel, List<Command<T,S>> subcom
             return;
         }
         for (Command<T,S> subcommand : subcommandsList) {
+            // getAliases() already returns [name, ...aliases], so no need to add the name again
             List<String> aliasesSub = new ArrayList<>(subcommand.getAliases());
-            aliasesSub.add(subcommand.getName());
             for (String aliasSub : aliasesSub) {
                 this.removeCommand(parentLabel + "." + aliasSub, true);
                 this.unregisterSubCommands(parentLabel + "." + aliasSub, subcommand.getSubcommands());
diff --git a/core/src/main/java/fr/traqueur/commands/api/arguments/Arguments.java b/core/src/main/java/fr/traqueur/commands/api/arguments/Arguments.java
index 6a34bdf..07f98d0 100644
--- a/core/src/main/java/fr/traqueur/commands/api/arguments/Arguments.java
+++ b/core/src/main/java/fr/traqueur/commands/api/arguments/Arguments.java
@@ -16,12 +16,12 @@ public class Arguments {
     /**
      * The map of the arguments.
      */
-    private final Map<String, ArgumentValue> arguments;
+    protected final Map<String, ArgumentValue> arguments;
 
     /**
      * The logger of the class.
      */
-    private final Logger logger;
+    protected final Logger logger;
 
     /**
      * Constructor of the class.
@@ -374,4 +374,23 @@ public void add(String key, Class<?> type, Object object) {
         ArgumentValue argumentValue = new ArgumentValue(type, object);
         this.arguments.put(key, argumentValue);
     }
+
+    /**
+     * Check if an argument exists in the map.
+     *
+     * @param key The key of the argument.
+     * @return true if the argument exists, false otherwise.
+     */
+    public boolean has(String key) {
+        return this.arguments.containsKey(key);
+    }
+
+    /**
+     * Get the logger of the class.
+     *
+     * @return The logger of the class.
+     */
+    protected Logger getLogger() {
+        return this.logger;
+    }
 }
diff --git a/core/src/main/java/fr/traqueur/commands/api/exceptions/CommandRegistrationException.java b/core/src/main/java/fr/traqueur/commands/api/exceptions/CommandRegistrationException.java
new file mode 100644
index 0000000..d0ad43b
--- /dev/null
+++ b/core/src/main/java/fr/traqueur/commands/api/exceptions/CommandRegistrationException.java
@@ -0,0 +1,36 @@
+package fr.traqueur.commands.api.exceptions;
+
+/**
+ * Exception thrown when a command registration fails.
+ * This is a runtime exception as registration failures are typically unrecoverable.
+ */
+public class CommandRegistrationException extends RuntimeException {
+
+    /**
+     * Constructs a new exception with the specified detail message.
+     *
+     * @param message the detail message
+     */
+    public CommandRegistrationException(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message and cause.
+     *
+     * @param message the detail message
+     * @param cause the cause of the exception
+     */
+    public CommandRegistrationException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new exception with the specified cause.
+     *
+     * @param cause the cause of the exception
+     */
+    public CommandRegistrationException(Throwable cause) {
+        super(cause);
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/java/fr/traqueur/commands/api/exceptions/UpdaterInitializationException.java b/core/src/main/java/fr/traqueur/commands/api/exceptions/UpdaterInitializationException.java
new file mode 100644
index 0000000..6fc453a
--- /dev/null
+++ b/core/src/main/java/fr/traqueur/commands/api/exceptions/UpdaterInitializationException.java
@@ -0,0 +1,36 @@
+package fr.traqueur.commands.api.exceptions;
+
+/**
+ * Exception thrown when the updater fails to initialize.
+ * This is a runtime exception as initialization failures are typically unrecoverable.
+ */
+public class UpdaterInitializationException extends RuntimeException {
+
+    /**
+     * Constructs a new exception with the specified detail message.
+     *
+     * @param message the detail message
+     */
+    public UpdaterInitializationException(String message) {
+        super(message);
+    }
+
+    /**
+     * Constructs a new exception with the specified detail message and cause.
+     *
+     * @param message the detail message
+     * @param cause the cause of the exception
+     */
+    public UpdaterInitializationException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs a new exception with the specified cause.
+     *
+     * @param cause the cause of the exception
+     */
+    public UpdaterInitializationException(Throwable cause) {
+        super(cause);
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/java/fr/traqueur/commands/api/models/CommandInvoker.java b/core/src/main/java/fr/traqueur/commands/api/models/CommandInvoker.java
index e4c0a43..1aa3440 100644
--- a/core/src/main/java/fr/traqueur/commands/api/models/CommandInvoker.java
+++ b/core/src/main/java/fr/traqueur/commands/api/models/CommandInvoker.java
@@ -41,63 +41,209 @@ public CommandInvoker(CommandManager<T, S> manager) {
      * @return true if a command handler was executed or a message sent; false if command not found
      */
     public boolean invoke(S source, String base, String[] rawArgs) {
-        // find matching node
+        Optional<CommandContext<T, S>> contextOpt = findCommandContext(base, rawArgs);
+        if (!contextOpt.isPresent()) {
+            return false;
+        }
+
+        CommandContext<T, S> context = contextOpt.get();
+
+        if (!validateCommandExecution(source, context)) {
+            return true;
+        }
+
+        return executeCommand(source, context);
+    }
+
+    /**
+     * Find and prepare command context.
+     * @param base the base command label
+     * @param rawArgs the raw arguments
+     * @return the command context if found
+     */
+    private Optional<CommandContext<T, S>> findCommandContext(String base, String[] rawArgs) {
         Optional<MatchResult<T, S>> found = manager.getCommands().findNode(base, rawArgs);
-        if (!found.isPresent()) return false;
+        if (!found.isPresent()) {
+            return Optional.empty();
+        }
+
         MatchResult<T, S> result = found.get();
         CommandTree.CommandNode<T, S> node = result.node;
         Optional<Command<T, S>> cmdOpt = node.getCommand();
-        if (!cmdOpt.isPresent()) return false;
+
+        if (!cmdOpt.isPresent()) {
+            return Optional.empty();
+        }
+
         Command<T, S> command = cmdOpt.get();
         String label = node.getFullLabel() != null ? node.getFullLabel() : base;
         String[] args = result.args;
 
-        // in-game check
+        return Optional.of(new CommandContext<>(command, label, args));
+    }
+
+    /**
+     * Validate command execution conditions (in-game, permissions, requirements, usage).
+     * @param source the command sender
+     * @param context the command context
+     * @return true if all validations passed, false otherwise (message already sent to user)
+     */
+    private boolean validateCommandExecution(S source, CommandContext<T, S> context) {
+        return checkInGameOnly(source, context.command)
+                && checkPermission(source, context.command)
+                && checkRequirements(source, context.command)
+                && checkUsage(source, context);
+    }
+
+    /**
+     * Check if command requires in-game execution.
+     * @param source the command sender
+     * @param command the command to check
+     * @return true if check passed or not applicable
+     */
+    private boolean checkInGameOnly(S source, Command<T, S> command) {
         if (command.inGameOnly() && !manager.getPlatform().isPlayer(source)) {
             manager.getPlatform().sendMessage(source, manager.getMessageHandler().getOnlyInGameMessage());
-            return true;
+            return false;
         }
-        // permission check
+        return true;
+    }
+
+    /**
+     * Check if sender has required permission.
+     * @param source the command sender
+     * @param command the command to check
+     * @return true if check passed or no permission required
+     */
+    private boolean checkPermission(S source, Command<T, S> command) {
         String perm = command.getPermission();
         if (!perm.isEmpty() && !manager.getPlatform().hasPermission(source, perm)) {
             manager.getPlatform().sendMessage(source, manager.getMessageHandler().getNoPermissionMessage());
-            return true;
+            return false;
         }
-        // requirements
+        return true;
+    }
+
+    /**
+     * Check if all requirements are satisfied.
+     * @param source the command sender
+     * @param command the command to check
+     * @return true if all requirements passed
+     */
+    private boolean checkRequirements(S source, Command<T, S> command) {
         for (Requirement<S> req : command.getRequirements()) {
             if (!req.check(source)) {
-                String msg = req.errorMessage().isEmpty()
-                        ? manager.getMessageHandler().getRequirementMessage().replace("%requirement%", req.getClass().getSimpleName())
-                        : req.errorMessage();
+                String msg = buildRequirementMessage(req);
                 manager.getPlatform().sendMessage(source, msg);
-                return true;
+                return false;
             }
         }
-        // usage check
+        return true;
+    }
+
+    /**
+     * Build error message for failed requirement.
+     * @param req the failed requirement
+     * @return the error message
+     */
+    private String buildRequirementMessage(Requirement<S> req) {
+        return req.errorMessage().isEmpty()
+                ? manager.getMessageHandler().getRequirementMessage()
+                .replace("%requirement%", req.getClass().getSimpleName())
+                : req.errorMessage();
+    }
+
+    /**
+     * Check if argument count is valid.
+     * @param source the command sender
+     * @param context the command context
+     * @return true if usage is correct
+     */
+    private boolean checkUsage(S source, CommandContext<T, S> context) {
+        Command<T, S> command = context.command;
+        String[] args = context.args;
+
         int min = command.getArgs().size();
         int max = command.isInfiniteArgs() ? Integer.MAX_VALUE : min + command.getOptinalArgs().size();
+
         if (args.length < min || args.length > max) {
-            String usage = command.getUsage().isEmpty()
-                    ? command.generateDefaultUsage(manager.getPlatform(), source, label)
-                    : command.getUsage();
+            String usage = buildUsageMessage(source, context);
             manager.getPlatform().sendMessage(source, usage);
-            return true;
+            return false;
         }
-        // parse and execute
+        return true;
+    }
+
+    /**
+     * Build usage message for command.
+     * @param source the command sender
+     * @param context the command context
+     * @return the usage message
+     */
+    private String buildUsageMessage(S source, CommandContext<T, S> context) {
+        Command<T, S> command = context.command;
+        String label = context.label;
+
+        return command.getUsage().isEmpty()
+                ? command.generateDefaultUsage(manager.getPlatform(), source, label)
+                : command.getUsage();
+    }
+
+    /**
+     * Execute the command with error handling.
+     * @param source the command sender
+     * @param context the command context
+     * @return true if execution succeeded or error was handled, false for internal errors
+     */
+    private boolean executeCommand(S source, CommandContext<T, S> context) {
         try {
-            Arguments parsed = manager.parse(command, args);
-            command.execute(source, parsed);
+            Arguments parsed = manager.parse(context.command, context.args);
+            context.command.execute(source, parsed);
+            return true;
         } catch (TypeArgumentNotExistException e) {
-            manager.getPlatform().sendMessage(source, "&cInternal error: invalid argument type");
-            return false;
+            return handleTypeArgumentError(source);
         } catch (ArgumentIncorrectException e) {
-            String msg = manager.getMessageHandler().getArgNotRecognized().replace("%arg%", e.getInput());
-            manager.getPlatform().sendMessage(source, msg);
-            return true;
+            return handleArgumentIncorrectError(source, e);
         }
+    }
+
+    /**
+     * Handle type argument not exist error.
+     * @param source the command sender
+     * @return false to indicate internal error
+     */
+    private boolean handleTypeArgumentError(S source) {
+        manager.getPlatform().sendMessage(source, "&cInternal error: invalid argument type");
+        return false;
+    }
+
+    /**
+     * Handle incorrect argument error.
+     * @param source the command sender
+     * @param e the exception
+     * @return true to indicate error was handled
+     */
+    private boolean handleArgumentIncorrectError(S source, ArgumentIncorrectException e) {
+        String msg = manager.getMessageHandler().getArgNotRecognized().replace("%arg%", e.getInput());
+        manager.getPlatform().sendMessage(source, msg);
         return true;
     }
 
+    /**
+     * Internal context class to hold command execution data.
+     */
+    private static class CommandContext<T, S> {
+        final Command<T, S> command;
+        final String label;
+        final String[] args;
+
+        CommandContext(Command<T, S> command, String label, String[] args) {
+            this.command = command;
+            this.label = label;
+            this.args = args;
+        }
+    }
+
     /**
      * Suggests command completions based on the provided source, base label, and arguments.
      * This method checks for available tab completers and filters suggestions based on the current input.
diff --git a/core/src/main/java/fr/traqueur/commands/api/updater/Updater.java b/core/src/main/java/fr/traqueur/commands/api/updater/Updater.java
index 93c11e5..8da7a73 100644
--- a/core/src/main/java/fr/traqueur/commands/api/updater/Updater.java
+++ b/core/src/main/java/fr/traqueur/commands/api/updater/Updater.java
@@ -1,5 +1,7 @@
 package fr.traqueur.commands.api.updater;
 
+import fr.traqueur.commands.api.exceptions.UpdaterInitializationException;
+
 import java.io.IOException;
 import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
@@ -22,7 +24,7 @@ public class Updater {
         try {
             URL_LATEST_RELEASE = URI.create("https://api.github.com/repos/Traqueur-dev/CommandsAPI/releases/latest").toURL();
         } catch (MalformedURLException e) {
-            throw new RuntimeException(e);
+            throw new UpdaterInitializationException("Failed to initialize updater URL", e);
         }
     }
 
diff --git a/gradle.properties b/gradle.properties
index 859570d..50d9458 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=4.2.3
\ No newline at end of file
+version=4.3.0
\ No newline at end of file
diff --git a/jda-test-bot/build.gradle b/jda-test-bot/build.gradle
new file mode 100644
index 0000000..5e62de5
--- /dev/null
+++ b/jda-test-bot/build.gradle
@@ -0,0 +1,30 @@
+plugins {
+    id 'application'
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation project(":jda")
+    implementation("net.dv8tion:JDA:5.2.1") {
+        exclude module: 'opus-java'
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+}
+
+application {
+    mainClass = 'fr.traqueur.commands.test.TestBot'
+}
+
+tasks.register('runBot', JavaExec) {
+    group = 'application'
+    description = 'Run the test Discord bot'
+    classpath = sourceSets.main.runtimeClasspath
+    mainClass = 'fr.traqueur.commands.test.TestBot'
+}
\ No newline at end of file
diff --git a/jda-test-bot/src/main/java/fr/traqueur/commands/test/TestBot.java b/jda-test-bot/src/main/java/fr/traqueur/commands/test/TestBot.java
new file mode 100644
index 0000000..71fc4cc
--- /dev/null
+++ b/jda-test-bot/src/main/java/fr/traqueur/commands/test/TestBot.java
@@ -0,0 +1,74 @@
+package fr.traqueur.commands.test;
+
+import fr.traqueur.commands.jda.CommandManager;
+import fr.traqueur.commands.test.commands.*;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.JDABuilder;
+import net.dv8tion.jda.api.requests.GatewayIntent;
+
+import java.util.logging.Logger;
+
+/**
+ * Test bot to demonstrate the JDA CommandsAPI.
+ *
+ * To run this bot:
+ * 1. Set the DISCORD_BOT_TOKEN environment variable
+ * 2. Set the DISCORD_GUILD_ID environment variable (optional, for testing)
+ * 3. Run with: ./gradlew :jda-test-bot:runBot
+ */
+public class TestBot {
+
+    private static final Logger LOGGER = Logger.getLogger(TestBot.class.getName());
+
+    public static void main(String[] args) {
+        String token = System.getenv("DISCORD_BOT_TOKEN");
+        if (token == null || token.isEmpty()) {
+            LOGGER.severe("DISCORD_BOT_TOKEN environment variable not set!");
+            LOGGER.info("Please set your Discord bot token with: export DISCORD_BOT_TOKEN=your_token_here");
+            return;
+        }
+
+        try {
+            new TestBot(token);
+        } catch (Exception e) {
+            LOGGER.severe("Failed to start bot: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    public TestBot(String token) throws InterruptedException {
+        LOGGER.info("Starting Discord bot...");
+
+        // Build JDA instance
+        JDA jda = JDABuilder.createDefault(token)
+                .enableIntents(GatewayIntent.GUILD_MEMBERS, GatewayIntent.MESSAGE_CONTENT)
+                .build()
+                .awaitReady();
+
+        LOGGER.info("Bot is ready! Logged in as: " + jda.getSelfUser().getAsTag());
+
+        // Create command manager
+        CommandManager<TestBot> commandManager = new CommandManager<>(this, jda, LOGGER);
+        commandManager.setDebug(true);
+
+        // Register commands
+        LOGGER.info("Registering commands...");
+        commandManager.registerCommand(new PingCommand(this));
+        commandManager.registerCommand(new UserInfoCommand(this));
+        commandManager.registerCommand(new MathCommand(this));
+        commandManager.registerCommand(new GreetCommand(this));
+        commandManager.registerCommand(new AdminCommand(this));
+
+        // Sync commands
+        String guildId = System.getenv("DISCORD_GUILD_ID");
+        if (guildId != null && !guildId.isEmpty()) {
+            LOGGER.info("Syncing commands to guild " + guildId + " (instant update)...");
+            commandManager.syncCommandsToGuild(guildId);
+        } else {
+            LOGGER.info("Syncing commands globally (may take up to 1 hour)...");
+            commandManager.syncCommands();
+        }
+
+        LOGGER.info("Bot is fully operational!");
+    }
+}
\ No newline at end of file
diff --git a/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/AdminCommand.java b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/AdminCommand.java
new file mode 100644
index 0000000..f892eba
--- /dev/null
+++ b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/AdminCommand.java
@@ -0,0 +1,181 @@
+package fr.traqueur.commands.test.commands;
+
+import fr.traqueur.commands.api.arguments.Arguments;
+import fr.traqueur.commands.jda.Command;
+import fr.traqueur.commands.jda.JDAArguments;
+import fr.traqueur.commands.test.TestBot;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+/**
+ * Admin command with subcommand groups to test JDAPlatform.addCommand() with parts.length >= 3
+ * Structure:
+ * - /admin users kick <user> <reason>
+ * - /admin users ban <user> <reason>
+ * - /admin server info
+ * - /admin server settings <option> <value>
+ */
+public class AdminCommand extends Command<TestBot> {
+
+    public AdminCommand(TestBot bot) {
+        super(bot, "admin");
+        this.setDescription("Administration commands");
+        this.setGameOnly(true);
+
+        // Users group
+        Command<TestBot> usersGroup = new UsersGroupCommand(bot);
+        usersGroup.addSubCommand(new KickCommand(bot));
+        usersGroup.addSubCommand(new BanCommand(bot));
+
+        // Server group
+        Command<TestBot> serverGroup = new ServerGroupCommand(bot);
+        serverGroup.addSubCommand(new ServerInfoCommand(bot));
+        serverGroup.addSubCommand(new ServerSettingsCommand(bot));
+
+        this.addSubCommand(usersGroup);
+        this.addSubCommand(serverGroup);
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+        // This won't be called since we have subcommands
+    }
+
+    /**
+     * Users group: /admin users
+     */
+    private static class UsersGroupCommand extends Command<TestBot> {
+        public UsersGroupCommand(TestBot bot) {
+            super(bot, "users");
+            this.setDescription("User management commands");
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            // This won't be called since we have subcommands
+        }
+    }
+
+    /**
+     * Kick subcommand: /admin users kick <user> <reason>
+     */
+    private static class KickCommand extends Command<TestBot> {
+        public KickCommand(TestBot bot) {
+            super(bot, "kick");
+            this.setDescription("Kick a user from the server");
+            this.addArgs("user", User.class);
+            this.addOptionalArgs("reason", String.class);
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            JDAArguments jdaArgs = jda(arguments);
+            User user = jdaArgs.getUser("user").orElse(null);
+            String reason = jdaArgs.getAsString("reason").orElse("No reason provided");
+
+            if (user == null) {
+                jdaArgs.replyEphemeral("User not found!");
+                return;
+            }
+
+            jdaArgs.reply(String.format("Would kick user %s for reason: %s",
+                user.getAsMention(), reason));
+        }
+    }
+
+    /**
+     * Ban subcommand: /admin users ban <user> <reason>
+     */
+    private static class BanCommand extends Command<TestBot> {
+        public BanCommand(TestBot bot) {
+            super(bot, "ban");
+            this.setDescription("Ban a user from the server");
+            this.addArgs("user", User.class);
+            this.addOptionalArgs("reason", String.class);
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            User user = arguments.getUser("user").orElse(null);
+            String reason = arguments.getAsString("reason").orElse("No reason provided");
+
+            if (user == null) {
+                arguments.replyEphemeral("User not found!");
+                return;
+            }
+
+            arguments.reply(String.format("Would ban user %s for reason: %s",
+                user.getAsMention(), reason));
+        }
+    }
+
+    /**
+     * Server group: /admin server
+     */
+    private static class ServerGroupCommand extends Command<TestBot> {
+        public ServerGroupCommand(TestBot bot) {
+            super(bot, "server");
+            this.setDescription("Server management commands");
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            // This won't be called since we have subcommands
+        }
+    }
+
+    /**
+     * Server info subcommand: /admin server info
+     */
+    private static class ServerInfoCommand extends Command<TestBot> {
+        public ServerInfoCommand(TestBot bot) {
+            super(bot, "info");
+            this.setDescription("Display server information");
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            JDAArguments jdaArgs = jda(arguments);
+
+            if (event.getGuild() == null) {
+                jdaArgs.replyEphemeral("This command can only be used in a server!");
+                return;
+            }
+
+            String info = String.format(
+                    """
+                            **Server Info**
+                            Name: %s
+                            ID: %s
+                            Members: %d
+                            Owner: %s""",
+                event.getGuild().getName(),
+                event.getGuild().getId(),
+                event.getGuild().getMemberCount(),
+                event.getGuild().getOwner() != null ? event.getGuild().getOwner().getAsMention() : "Unknown"
+            );
+
+            jdaArgs.reply(info);
+        }
+    }
+
+    /**
+     * Server settings subcommand: /admin server settings <option> <value>
+     */
+    private static class ServerSettingsCommand extends Command<TestBot> {
+        public ServerSettingsCommand(TestBot bot) {
+            super(bot, "settings");
+            this.setDescription("Modify server settings");
+            this.addArgs("option", String.class, "value", String.class);
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            JDAArguments jdaArgs = jda(arguments);
+            String option = jdaArgs.getAsString("option").orElse("unknown");
+            String value = jdaArgs.getAsString("value").orElse("unknown");
+
+            jdaArgs.reply(String.format("Would set setting '%s' to '%s'", option, value));
+        }
+    }
+}
\ No newline at end of file
diff --git a/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/GreetCommand.java b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/GreetCommand.java
new file mode 100644
index 0000000..84dc086
--- /dev/null
+++ b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/GreetCommand.java
@@ -0,0 +1,40 @@
+package fr.traqueur.commands.test.commands;
+
+import fr.traqueur.commands.api.arguments.Arguments;
+import fr.traqueur.commands.jda.Command;
+import fr.traqueur.commands.jda.JDAArguments;
+import fr.traqueur.commands.test.TestBot;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+/**
+ * Greet command that greets a user with an optional custom message.
+ * Usage: /greet <user> [message]
+ */
+public class GreetCommand extends Command<TestBot> {
+
+    public GreetCommand(TestBot bot) {
+        super(bot, "greet");
+        this.setDescription("Greet a user with a custom message");
+        this.addArgs("user", User.class);
+        this.addOptionalArgs("message:infinite");
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+        User target = arguments.getUser("user").orElse(null);
+        if (target == null) {
+            arguments.replyEphemeral("User not found!");
+            return;
+        }
+
+        String customMessage = arguments.getAsString("message", "Hello there!");
+
+        String greeting = String.format("%s says to %s: %s",
+                event.getUser().getAsMention(),
+                target.getAsMention(),
+                customMessage);
+
+        arguments.reply(greeting);
+    }
+}
\ No newline at end of file
diff --git a/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/MathCommand.java b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/MathCommand.java
new file mode 100644
index 0000000..19c8275
--- /dev/null
+++ b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/MathCommand.java
@@ -0,0 +1,120 @@
+package fr.traqueur.commands.test.commands;
+
+import fr.traqueur.commands.api.arguments.Arguments;
+import fr.traqueur.commands.jda.Command;
+import fr.traqueur.commands.jda.JDAArguments;
+import fr.traqueur.commands.test.TestBot;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+/**
+ * Math command with subcommands demonstrating the command tree structure.
+ * Commands:
+ * - /math add <a> <b>
+ * - /math subtract <a> <b>
+ * - /math multiply <a> <b>
+ * - /math divide <a> <b>
+ */
+public class MathCommand extends Command<TestBot> {
+
+    public MathCommand(TestBot bot) {
+        super(bot, "math");
+        this.setDescription("Perform mathematical operations");
+
+        // Add subcommand
+        this.addSubCommand(new AddCommand(bot));
+        this.addSubCommand(new SubtractCommand(bot));
+        this.addSubCommand(new MultiplyCommand(bot));
+        this.addSubCommand(new DivideCommand(bot));
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+        // This won't be called since we have subcommands
+    }
+
+    /**
+     * Add subcommand: /math add <a> <b>
+     */
+    private static class AddCommand extends Command<TestBot> {
+        public AddCommand(TestBot bot) {
+            super(bot, "add");
+            this.setDescription("Add two numbers");
+            this.addArgs("a", Double.class, "b", Double.class);
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            double a = arguments.getAsDouble("a").orElse(0.0);
+            double b = arguments.getAsDouble("b").orElse(0.0);
+            double result = a + b;
+
+            jda(arguments).reply(String.format("%.2f + %.2f = %.2f", a, b, result));
+        }
+    }
+
+    /**
+     * Subtract subcommand: /math subtract <a> <b>
+     */
+    private static class SubtractCommand extends Command<TestBot> {
+        public SubtractCommand(TestBot bot) {
+            super(bot, "subtract");
+            this.setDescription("Subtract two numbers");
+            this.addArgs("a", Double.class, "b", Double.class);
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            double a = arguments.getAsDouble("a").orElse(0.0);
+            double b = arguments.getAsDouble("b").orElse(0.0);
+            double result = a - b;
+
+            jda(arguments).reply(String.format("%.2f - %.2f = %.2f", a, b, result));
+        }
+    }
+
+    /**
+     * Multiply subcommand: /math multiply <a> <b>
+     */
+    private static class MultiplyCommand extends Command<TestBot> {
+        public MultiplyCommand(TestBot bot) {
+            super(bot, "multiply");
+            this.setDescription("Multiply two numbers");
+            this.addArgs("a", Double.class, "b", Double.class);
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            double a = arguments.getAsDouble("a").orElse(0.0);
+            double b = arguments.getAsDouble("b").orElse(0.0);
+            double result = a * b;
+
+            jda(arguments).reply(String.format("%.2f × %.2f = %.2f", a, b, result));
+        }
+    }
+
+    /**
+     * Divide subcommand: /math divide <a> <b>
+     */
+    private static class DivideCommand extends Command<TestBot> {
+        public DivideCommand(TestBot bot) {
+            super(bot, "divide");
+            this.setDescription("Divide two numbers");
+            this.addArgs("a", Double.class, "b", Double.class);
+        }
+
+        @Override
+        public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+            double a = arguments.getAsDouble("a").orElse(0.0);
+            double b = arguments.getAsDouble("b").orElse(0.0);
+
+            if (b == 0) {
+                jda(arguments).replyEphemeral("Cannot divide by zero!");
+                return;
+            }
+
+            double result = a / b;
+            jda(arguments).reply(String.format("%.2f ÷ %.2f = %.2f", a, b, result));
+        }
+    }
+}
\ No newline at end of file
diff --git a/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/PingCommand.java b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/PingCommand.java
new file mode 100644
index 0000000..f6f1367
--- /dev/null
+++ b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/PingCommand.java
@@ -0,0 +1,31 @@
+package fr.traqueur.commands.test.commands;
+
+import fr.traqueur.commands.api.arguments.Arguments;
+import fr.traqueur.commands.jda.Command;
+import fr.traqueur.commands.jda.JDAArguments;
+import fr.traqueur.commands.test.TestBot;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+/**
+ * Simple ping command that responds with "Pong!" and the bot's latency.
+ */
+public class PingCommand extends Command<TestBot> {
+
+    public PingCommand(TestBot bot) {
+        super(bot, "ping");
+        this.setDescription("Check the bot's latency");
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+        long gatewayPing = event.getJDA().getGatewayPing();
+
+        event.reply("Pong! Gateway ping: " + gatewayPing + "ms").queue(response -> {
+            response.retrieveOriginal().queue(message -> {
+                long restPing = message.getTimeCreated().toInstant().toEpochMilli() -
+                               event.getTimeCreated().toInstant().toEpochMilli();
+                response.editOriginal("Pong! Gateway ping: " + gatewayPing + "ms | REST ping: " + restPing + "ms").queue();
+            });
+        });
+    }
+}
\ No newline at end of file
diff --git a/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/UserInfoCommand.java b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/UserInfoCommand.java
new file mode 100644
index 0000000..548d490
--- /dev/null
+++ b/jda-test-bot/src/main/java/fr/traqueur/commands/test/commands/UserInfoCommand.java
@@ -0,0 +1,58 @@
+package fr.traqueur.commands.test.commands;
+
+import fr.traqueur.commands.api.arguments.Arguments;
+import fr.traqueur.commands.jda.Command;
+import fr.traqueur.commands.jda.JDAArguments;
+import fr.traqueur.commands.test.TestBot;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.IMentionable;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import java.awt.*;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * Command that displays information about a user.
+ */
+public class UserInfoCommand extends Command<TestBot> {
+
+    public UserInfoCommand(TestBot bot) {
+        super(bot, "userinfo");
+        this.setDescription("Get information about a user");
+        this.setGameOnly(true); // Guild-only command
+        this.addOptionalArgs("user", User.class);
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event, JDAArguments arguments) {
+        JDAArguments jdaArgs = jda(arguments);
+
+        // Get the target user (defaults to the command executor)
+        User user = jdaArgs.getUser("user").orElse(event.getUser());
+        Member member = event.getGuild().getMember(user);
+
+        if (member == null) {
+            jdaArgs.reply("User not found in this server!");
+            return;
+        }
+
+        // Build embed
+        EmbedBuilder embed = new EmbedBuilder()
+                .setTitle("User Information")
+                .setThumbnail(user.getEffectiveAvatarUrl())
+                .setColor(member.getColor() != null ? member.getColor() : Color.BLUE)
+                .addField("Username", user.getName(), true)
+                .addField("Display Name", member.getEffectiveName(), true)
+                .addField("ID", user.getId(), true)
+                .addField("Account Created", user.getTimeCreated().format(DateTimeFormatter.RFC_1123_DATE_TIME), false)
+                .addField("Joined Server", member.getTimeJoined().format(DateTimeFormatter.RFC_1123_DATE_TIME), false)
+                .addField("Roles", member.getRoles().isEmpty() ? "None" :
+                        member.getRoles().stream().map(IMentionable::getAsMention).limit(10)
+                                .reduce((a, b) -> a + ", " + b).orElse("None"), false)
+                .setFooter("Requested by " + event.getUser().getName(), event.getUser().getEffectiveAvatarUrl());
+
+        event.replyEmbeds(embed.build()).queue();
+    }
+}
\ No newline at end of file
diff --git a/jda/build.gradle b/jda/build.gradle
new file mode 100644
index 0000000..c4ea8bb
--- /dev/null
+++ b/jda/build.gradle
@@ -0,0 +1,35 @@
+plugins {
+    id 'maven-publish'
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    api project(":core")
+    compileOnly("net.dv8tion:JDA:5.2.1") {
+        exclude module: 'opus-java'
+    }
+    testImplementation("net.dv8tion:JDA:5.2.1") {
+        exclude module: 'opus-java'
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+    withSourcesJar()
+    withJavadocJar()
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            from components.java
+            groupId = project.group
+            artifactId = 'platform-jda'
+            version = project.version
+        }
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/Command.java b/jda/src/main/java/fr/traqueur/commands/jda/Command.java
new file mode 100644
index 0000000..b5c58ee
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/Command.java
@@ -0,0 +1,91 @@
+package fr.traqueur.commands.jda;
+
+import fr.traqueur.commands.api.arguments.Arguments;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+/**
+ * Abstract base class for JDA slash commands.
+ * This class extends the base Command class and provides JDA-specific functionality.
+ *
+ * @param <T> The type of the bot instance.
+ */
+public abstract class Command<T> extends fr.traqueur.commands.api.models.Command<T, SlashCommandInteractionEvent> {
+
+    /**
+     * Constructor for a JDA command.
+     *
+     * @param bot  The bot instance.
+     * @param name The name of the command.
+     */
+    public Command(T bot, String name) {
+        super(bot, name);
+    }
+
+    /**
+     * Abstract method to execute the command.
+     * Must be implemented by subclasses to define command behavior.
+     *
+     * @param event     The slash command interaction event.
+     * @param arguments The JDA-specific arguments for the command.
+     */
+    public abstract void execute(SlashCommandInteractionEvent event, JDAArguments arguments);
+
+    public void execute(SlashCommandInteractionEvent event, Arguments arguments) {
+        this.execute(event, jda(arguments));
+    }
+
+    /**
+     * Helper method to cast Arguments to JDAArguments.
+     * This provides easy access to JDA-specific argument methods.
+     *
+     * @param arguments The arguments to cast.
+     * @return The arguments as JDAArguments.
+     */
+    protected JDAArguments jda(Arguments arguments) {
+        return (JDAArguments) arguments;
+    }
+
+    /**
+     * Helper method to get the event's user.
+     *
+     * @param event The slash command event.
+     * @return The user who triggered the command.
+     */
+    protected User getUser(SlashCommandInteractionEvent event) {
+        return event.getUser();
+    }
+
+    /**
+     * Helper method to get the event's member (null if not in a guild).
+     *
+     * @param event The slash command event.
+     * @return The member who triggered the command, or null if not in a guild.
+     */
+    protected Member getMember(SlashCommandInteractionEvent event) {
+        return event.getMember();
+    }
+
+    /**
+     * Helper method to get the event's guild (null if not in a guild).
+     *
+     * @param event The slash command event.
+     * @return The guild where the command was triggered, or null if not in a guild.
+     */
+    protected Guild getGuild(SlashCommandInteractionEvent event) {
+        return event.getGuild();
+    }
+
+    /**
+     * Helper method to get the event's channel.
+     *
+     * @param event The slash command event.
+     * @return The channel where the command was triggered.
+     */
+    protected MessageChannelUnion getChannel(SlashCommandInteractionEvent event) {
+        return event.getChannel();
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/CommandManager.java b/jda/src/main/java/fr/traqueur/commands/jda/CommandManager.java
new file mode 100644
index 0000000..c1c7660
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/CommandManager.java
@@ -0,0 +1,100 @@
+package fr.traqueur.commands.jda;
+
+import fr.traqueur.commands.jda.arguments.*;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.entities.channel.unions.GuildChannelUnion;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import java.util.logging.Logger;
+
+/**
+ * JDA-specific CommandManager that manages slash commands for Discord bots.
+ * This class extends the base CommandManager and provides Discord-specific functionality.
+ *
+ * @param <T> The type of the bot instance.
+ */
+public class CommandManager<T> extends fr.traqueur.commands.api.CommandManager<T, SlashCommandInteractionEvent> {
+
+    /**
+     * The JDA platform instance.
+     */
+    private final JDAPlatform<T> jdaPlatform;
+
+    /**
+     * Constructor for the JDA CommandManager.
+     *
+     * @param bot    The bot instance.
+     * @param jda    The JDA instance.
+     * @param logger The logger instance.
+     */
+    public CommandManager(T bot, JDA jda, Logger logger) {
+        super(new JDAPlatform<>(bot, jda, logger));
+        this.jdaPlatform = (JDAPlatform<T>) getPlatform();
+
+        // Register JDA-specific argument converters with JDA context
+        this.registerJDAConverters(jda);
+    }
+
+    /**
+     * Register JDA-specific argument converters.
+     * This method is called automatically in the constructor.
+     *
+     * @param jda The JDA instance to inject into converters.
+     */
+    private void registerJDAConverters(JDA jda) {
+        registerConverter(User.class, new UserArgument(jda));
+        registerConverter(Member.class, new MemberArgument(jda));
+        registerConverter(Role.class, new RoleArgument(jda));
+        registerConverter(GuildChannelUnion.class, new ChannelArgument(jda));
+        registerConverter(Message.Attachment.class, new AttachmentArgument(jda));
+    }
+
+    /**
+     * Synchronize all registered commands with Discord globally.
+     * Note: Global commands may take up to 1 hour to update.
+     */
+    public void syncCommands() {
+        jdaPlatform.syncCommands();
+    }
+
+    /**
+     * Synchronize all registered commands with a specific guild.
+     * This updates instantly and is useful for testing.
+     *
+     * @param guildId The guild ID.
+     */
+    public void syncCommandsToGuild(long guildId) {
+        jdaPlatform.syncCommandsToGuild(guildId);
+    }
+
+    /**
+     * Synchronize all registered commands with a specific guild.
+     *
+     * @param guildId The guild ID as a string.
+     */
+    public void syncCommandsToGuild(String guildId) {
+        jdaPlatform.syncCommandsToGuild(guildId);
+    }
+
+    /**
+     * Get the JDA instance.
+     *
+     * @return The JDA instance.
+     */
+    public JDA getJDA() {
+        return jdaPlatform.getJDA();
+    }
+
+    /**
+     * Get the JDA platform.
+     *
+     * @return The JDA platform.
+     */
+    public JDAPlatform<T> getJDAPlatform() {
+        return jdaPlatform;
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/JDAArguments.java b/jda/src/main/java/fr/traqueur/commands/jda/JDAArguments.java
new file mode 100644
index 0000000..2ea09eb
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/JDAArguments.java
@@ -0,0 +1,267 @@
+package fr.traqueur.commands.jda;
+
+import fr.traqueur.commands.api.arguments.Arguments;
+import fr.traqueur.commands.api.logging.Logger;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.entities.channel.unions.GuildChannelUnion;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.commands.OptionMapping;
+
+import java.util.Optional;
+
+/**
+ * JDA-specific implementation of Arguments that provides direct access to Discord entities.
+ * This class extends the base Arguments class and adds methods to retrieve JDA-specific types
+ * like User, Member, Role, and Channel directly from slash command options.
+ */
+public class JDAArguments extends Arguments {
+
+    /**
+     * The slash command interaction event that triggered this command.
+     */
+    private final SlashCommandInteractionEvent event;
+
+    /**
+     * Constructor for JDAArguments.
+     *
+     * @param logger The logger instance.
+     * @param event  The slash command interaction event.
+     */
+    public JDAArguments(Logger logger, SlashCommandInteractionEvent event) {
+        super(logger);
+        this.event = event;
+    }
+
+    /**
+     * Get the slash command interaction event.
+     *
+     * @return The slash command interaction event.
+     */
+    public SlashCommandInteractionEvent getEvent() {
+        return event;
+    }
+
+    /**
+     * Get a User from the command options.
+     *
+     * @param name The name of the option.
+     * @return An Optional containing the User if present.
+     */
+    public Optional<User> getUser(String name) {
+        OptionMapping option = event.getOption(name);
+        if (option != null) {
+            return Optional.of(option.getAsUser());
+        }
+        // Fallback to arguments map
+        return this.getAs(name, User.class);
+    }
+
+    /**
+     * Get a User from the command options with a default value.
+     *
+     * @param name         The name of the option.
+     * @param defaultValue The default value if not present.
+     * @return The User or the default value.
+     */
+    public User getUser(String name, User defaultValue) {
+        return getUser(name).orElse(defaultValue);
+    }
+
+    /**
+     * Get a Member from the command options.
+     *
+     * @param name The name of the option.
+     * @return An Optional containing the Member if present.
+     */
+    public Optional<Member> getMember(String name) {
+        OptionMapping option = event.getOption(name);
+        if (option != null) {
+            return Optional.ofNullable(option.getAsMember());
+        }
+        // Fallback to arguments map
+        return this.getAs(name, Member.class);
+    }
+
+    /**
+     * Get a Member from the command options with a default value.
+     *
+     * @param name         The name of the option.
+     * @param defaultValue The default value if not present.
+     * @return The Member or the default value.
+     */
+    public Member getMember(String name, Member defaultValue) {
+        return getMember(name).orElse(defaultValue);
+    }
+
+    /**
+     * Get a Role from the command options.
+     *
+     * @param name The name of the option.
+     * @return An Optional containing the Role if present.
+     */
+    public Optional<Role> getRole(String name) {
+        OptionMapping option = event.getOption(name);
+        if (option != null) {
+            return Optional.of(option.getAsRole());
+        }
+        // Fallback to arguments map
+        return this.getAs(name, Role.class);
+    }
+
+    /**
+     * Get a Role from the command options with a default value.
+     *
+     * @param name         The name of the option.
+     * @param defaultValue The default value if not present.
+     * @return The Role or the default value.
+     */
+    public Role getRole(String name, Role defaultValue) {
+        return getRole(name).orElse(defaultValue);
+    }
+
+    /**
+     * Get a GuildChannel from the command options.
+     *
+     * @param name The name of the option.
+     * @return An Optional containing the GuildChannel if present.
+     */
+    public Optional<GuildChannelUnion> getChannel(String name) {
+        OptionMapping option = event.getOption(name);
+        if (option != null) {
+            return Optional.of(option.getAsChannel());
+        }
+        // Fallback to arguments map
+        return this.getAs(name, GuildChannelUnion.class);
+    }
+
+    /**
+     * Get a GuildChannel from the command options with a default value.
+     *
+     * @param name         The name of the option.
+     * @param defaultValue The default value if not present.
+     * @return The GuildChannel or the default value.
+     */
+    public GuildChannelUnion getChannel(String name, GuildChannelUnion defaultValue) {
+        return getChannel(name).orElse(defaultValue);
+    }
+
+    /**
+     * Override getAsString to first check JDA options.
+     *
+     * @param argument The key of the argument.
+     * @return The string or empty if not present.
+     */
+    @Override
+    public Optional<String> getAsString(String argument) {
+        OptionMapping option = event.getOption(argument);
+        if (option != null) {
+            return Optional.of(option.getAsString());
+        }
+        return super.getAsString(argument);
+    }
+
+    /**
+     * Override getAsInt to first check JDA options.
+     *
+     * @param argument The key of the argument.
+     * @return The integer or empty if not present.
+     */
+    @Override
+    public Optional<Integer> getAsInt(String argument) {
+        OptionMapping option = event.getOption(argument);
+        if (option != null) {
+            return Optional.of((int) option.getAsLong());
+        }
+        return super.getAsInt(argument);
+    }
+
+    /**
+     * Override getAsLong to first check JDA options.
+     *
+     * @param argument The key of the argument.
+     * @return The long or empty if not present.
+     */
+    @Override
+    public Optional<Long> getAsLong(String argument) {
+        OptionMapping option = event.getOption(argument);
+        if (option != null) {
+            return Optional.of(option.getAsLong());
+        }
+        return super.getAsLong(argument);
+    }
+
+    /**
+     * Override getAsDouble to first check JDA options.
+     *
+     * @param argument The key of the argument.
+     * @return The double or empty if not present.
+     */
+    @Override
+    public Optional<Double> getAsDouble(String argument) {
+        OptionMapping option = event.getOption(argument);
+        if (option != null) {
+            return Optional.of(option.getAsDouble());
+        }
+        return super.getAsDouble(argument);
+    }
+
+    /**
+     * Override getAsBoolean to first check JDA options.
+     *
+     * @param argument The key of the argument.
+     * @return The boolean or empty if not present.
+     */
+    @Override
+    public Optional<Boolean> getAsBoolean(String argument) {
+        OptionMapping option = event.getOption(argument);
+        if (option != null) {
+            return Optional.of(option.getAsBoolean());
+        }
+        return super.getAsBoolean(argument);
+    }
+
+    /**
+     * Reply to the interaction.
+     *
+     * @param message The message to send.
+     */
+    public void reply(String message) {
+        if (!event.isAcknowledged()) {
+            event.reply(message).queue();
+        } else {
+            event.getHook().sendMessage(message).queue();
+        }
+    }
+
+    /**
+     * Reply to the interaction ephemerally (only visible to the user).
+     *
+     * @param message The message to send.
+     */
+    public void replyEphemeral(String message) {
+        if (!event.isAcknowledged()) {
+            event.reply(message).setEphemeral(true).queue();
+        } else {
+            event.getHook().sendMessage(message).setEphemeral(true).queue();
+        }
+    }
+
+    /**
+     * Defer the reply to the interaction.
+     * This is useful for long-running commands.
+     */
+    public void deferReply() {
+        if (!event.isAcknowledged()) {
+            event.deferReply().queue();
+        }
+    }
+
+    /**
+     * Defer the reply to the interaction ephemerally.
+     */
+    public void deferReplyEphemeral() {
+        if (!event.isAcknowledged()) {
+            event.deferReply(true).queue();
+        }
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/JDAExecutor.java b/jda/src/main/java/fr/traqueur/commands/jda/JDAExecutor.java
new file mode 100644
index 0000000..5ebf6d1
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/JDAExecutor.java
@@ -0,0 +1,296 @@
+package fr.traqueur.commands.jda;
+
+import fr.traqueur.commands.api.CommandManager;
+import fr.traqueur.commands.api.models.Command;
+import fr.traqueur.commands.api.models.collections.CommandTree;
+import fr.traqueur.commands.api.requirements.Requirement;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.entities.channel.unions.GuildChannelUnion;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+import net.dv8tion.jda.api.interactions.commands.OptionMapping;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * JDA executor that handles slash command events.
+ * This class listens for SlashCommandInteractionEvent and routes them to the appropriate command.
+ *
+ * @param <T> The type of the bot instance.
+ */
+public class JDAExecutor<T> extends ListenerAdapter {
+
+    /**
+     * The command manager.
+     */
+    private final CommandManager<T, SlashCommandInteractionEvent> commandManager;
+
+    /**
+     * Constructor for JDAExecutor.
+     *
+     * @param commandManager The command manager.
+     */
+    public JDAExecutor(CommandManager<T, SlashCommandInteractionEvent> commandManager) {
+        this.commandManager = commandManager;
+    }
+
+    @Override
+    public void onSlashCommandInteraction(@NotNull SlashCommandInteractionEvent event) {
+        String label = buildLabel(event);
+        logDebugIfEnabled(label);
+
+        Optional<Command<T, SlashCommandInteractionEvent>> commandOpt = findCommand(event, label);
+        if (commandOpt.isEmpty()) {
+            return;
+        }
+
+        Command<T, SlashCommandInteractionEvent> command = commandOpt.get();
+
+        if (!validateCommand(event, command)) {
+            return;
+        }
+
+        JDAArguments jdaArguments = createArguments(event);
+        executeCommand(event, command, jdaArguments, label);
+    }
+
+    /**
+     * Log debug message if debug mode is enabled.
+     *
+     * @param label The command label.
+     */
+    private void logDebugIfEnabled(String label) {
+        if (commandManager.isDebug()) {
+            commandManager.getLogger().info("Received slash command: " + label);
+        }
+    }
+
+    /**
+     * Find the command in the tree.
+     *
+     * @param event The slash command event.
+     * @param label The command label.
+     * @return The command if found, empty otherwise.
+     */
+    private Optional<Command<T, SlashCommandInteractionEvent>> findCommand(
+            SlashCommandInteractionEvent event, String label) {
+        String[] labelParts = label.split("\\.");
+        Optional<CommandTree.MatchResult<T, SlashCommandInteractionEvent>> found =
+                commandManager.getCommands().findNode(labelParts);
+
+        if (found.isEmpty()) {
+            event.reply("Command not found!").setEphemeral(true).queue();
+            return Optional.empty();
+        }
+
+        CommandTree.MatchResult<T, SlashCommandInteractionEvent> result = found.get();
+        CommandTree.CommandNode<T, SlashCommandInteractionEvent> node = result.node;
+        Optional<Command<T, SlashCommandInteractionEvent>> cmdOpt = node.getCommand();
+
+        if (cmdOpt.isEmpty()) {
+            event.reply("Command implementation not found!").setEphemeral(true).queue();
+            return Optional.empty();
+        }
+
+        return cmdOpt;
+    }
+
+    /**
+     * Validate command execution conditions (game-only, permissions, requirements).
+     *
+     * @param event   The slash command event.
+     * @param command The command to validate.
+     * @return true if validation passed, false otherwise.
+     */
+    private boolean validateCommand(SlashCommandInteractionEvent event,
+                                     Command<T, SlashCommandInteractionEvent> command) {
+        if (!checkGameOnly(event, command)) {
+            return false;
+        }
+
+        if (!checkPermissions(event, command)) {
+            return false;
+        }
+
+        return checkRequirements(event, command);
+    }
+
+    /**
+     * Check if command is game-only (guild-only in Discord context).
+     *
+     * @param event   The slash command event.
+     * @param command The command to check.
+     * @return true if check passed, false otherwise.
+     */
+    private boolean checkGameOnly(SlashCommandInteractionEvent event,
+                                   Command<T, SlashCommandInteractionEvent> command) {
+        if (command.inGameOnly() && !event.isFromGuild()) {
+            event.reply(commandManager.getMessageHandler().getOnlyInGameMessage())
+                    .setEphemeral(true).queue();
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Check command permissions.
+     *
+     * @param event   The slash command event.
+     * @param command The command to check.
+     * @return true if check passed, false otherwise.
+     */
+    private boolean checkPermissions(SlashCommandInteractionEvent event,
+                                      Command<T, SlashCommandInteractionEvent> command) {
+        String perm = command.getPermission();
+        if (!perm.isEmpty() && !commandManager.getPlatform().hasPermission(event, perm)) {
+            event.reply(commandManager.getMessageHandler().getNoPermissionMessage())
+                    .setEphemeral(true).queue();
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Check command requirements.
+     *
+     * @param event   The slash command event.
+     * @param command The command to check.
+     * @return true if all requirements passed, false otherwise.
+     */
+    private boolean checkRequirements(SlashCommandInteractionEvent event,
+                                       Command<T, SlashCommandInteractionEvent> command) {
+        for (Requirement<SlashCommandInteractionEvent> req : command.getRequirements()) {
+            if (!req.check(event)) {
+                String msg = req.errorMessage().isEmpty()
+                        ? commandManager.getMessageHandler().getRequirementMessage()
+                        .replace("%requirement%", req.getClass().getSimpleName())
+                        : req.errorMessage();
+                event.reply(msg).setEphemeral(true).queue();
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Create JDAArguments from event options.
+     *
+     * @param event The slash command event.
+     * @return The populated JDAArguments.
+     */
+    private JDAArguments createArguments(SlashCommandInteractionEvent event) {
+        JDAArguments jdaArguments = new JDAArguments(commandManager.getLogger(), event);
+        List<OptionMapping> options = event.getOptions();
+
+        for (OptionMapping option : options) {
+            populateArgument(jdaArguments, option);
+        }
+
+        return jdaArguments;
+    }
+
+    /**
+     * Populate a single argument based on option type.
+     *
+     * @param arguments The arguments container.
+     * @param option    The option to populate from.
+     */
+    private void populateArgument(JDAArguments arguments, OptionMapping option) {
+        String name = option.getName();
+
+        switch (option.getType()) {
+            case STRING:
+                arguments.add(name, String.class, option.getAsString());
+                break;
+            case INTEGER:
+                arguments.add(name, Long.class, option.getAsLong());
+                break;
+            case NUMBER:
+                arguments.add(name, Double.class, option.getAsDouble());
+                break;
+            case BOOLEAN:
+                arguments.add(name, Boolean.class, option.getAsBoolean());
+                break;
+            case USER:
+                arguments.add(name, User.class, option.getAsUser());
+                if (option.getAsMember() != null) {
+                    arguments.add(name, Member.class, option.getAsMember());
+                }
+                break;
+            case ROLE:
+                arguments.add(name, Role.class, option.getAsRole());
+                break;
+            case CHANNEL:
+                arguments.add(name, GuildChannelUnion.class, option.getAsChannel());
+                break;
+            case MENTIONABLE:
+                arguments.add(name, IMentionable.class, option.getAsMentionable());
+                break;
+            case ATTACHMENT:
+                arguments.add(name, Message.Attachment.class, option.getAsAttachment());
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Execute the command with error handling.
+     *
+     * @param event     The slash command event.
+     * @param command   The command to execute.
+     * @param arguments The command arguments.
+     * @param label     The command label for logging.
+     */
+    private void executeCommand(SlashCommandInteractionEvent event,
+                                 Command<T, SlashCommandInteractionEvent> command,
+                                 JDAArguments arguments, String label) {
+        try {
+            command.execute(event, arguments);
+        } catch (Exception e) {
+            handleCommandError(event, label, e);
+        }
+    }
+
+    /**
+     * Handle command execution errors.
+     *
+     * @param event The slash command event.
+     * @param label The command label.
+     * @param e     The exception that occurred.
+     */
+    private void handleCommandError(SlashCommandInteractionEvent event, String label, Exception e) {
+        commandManager.getLogger().error("Error executing command " + label + ": " + e.getMessage());
+        e.printStackTrace();
+        if (!event.isAcknowledged()) {
+            event.reply("An error occurred while executing this command!")
+                    .setEphemeral(true).queue();
+        }
+    }
+
+    /**
+     * Build a label from a slash command event.
+     * Examples:
+     * - /ping -> "ping"
+     * - /math add -> "math.add"
+     * - /admin users kick -> "admin.users.kick"
+     *
+     * @param event The slash command event.
+     * @return The constructed label.
+     */
+    private String buildLabel(SlashCommandInteractionEvent event) {
+        StringBuilder label = new StringBuilder(event.getName());
+
+        if (event.getSubcommandGroup() != null) {
+            label.append(".").append(event.getSubcommandGroup());
+        }
+
+        if (event.getSubcommandName() != null) {
+            label.append(".").append(event.getSubcommandName());
+        }
+
+        return label.toString().toLowerCase();
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/JDAPlatform.java b/jda/src/main/java/fr/traqueur/commands/jda/JDAPlatform.java
new file mode 100644
index 0000000..dec2123
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/JDAPlatform.java
@@ -0,0 +1,336 @@
+package fr.traqueur.commands.jda;
+
+import fr.traqueur.commands.api.CommandManager;
+import fr.traqueur.commands.api.arguments.Argument;
+import fr.traqueur.commands.api.models.Command;
+import fr.traqueur.commands.api.models.CommandPlatform;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.Permission;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.commands.OptionType;
+import net.dv8tion.jda.api.interactions.commands.build.Commands;
+import net.dv8tion.jda.api.interactions.commands.build.OptionData;
+import net.dv8tion.jda.api.interactions.commands.build.SlashCommandData;
+import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
+import net.dv8tion.jda.api.interactions.commands.build.SubcommandGroupData;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+/**
+ * JDA implementation of the CommandPlatform interface.
+ * This class handles the registration and management of slash commands in Discord.
+ *
+ * @param <T> The type of the bot instance.
+ */
+public class JDAPlatform<T> implements CommandPlatform<T, SlashCommandInteractionEvent> {
+
+    /**
+     * The bot instance associated with this platform.
+     */
+    private final T bot;
+
+    /**
+     * The JDA instance.
+     */
+    private final JDA jda;
+
+    /**
+     * The logger for this platform.
+     */
+    private final Logger logger;
+
+    /**
+     * The command manager.
+     */
+    private CommandManager<T, SlashCommandInteractionEvent> commandManager;
+
+    /**
+     * Map of root command names to their SlashCommandData.
+     */
+    private final Map<String, SlashCommandData> slashCommands;
+
+    /**
+     * Constructor for JDAPlatform.
+     *
+     * @param bot    The bot instance.
+     * @param jda    The JDA instance.
+     * @param logger The logger instance.
+     */
+    public JDAPlatform(T bot, JDA jda, Logger logger) {
+        this.bot = bot;
+        this.jda = jda;
+        this.logger = logger;
+        this.slashCommands = new HashMap<>();
+    }
+
+    @Override
+    public T getPlugin() {
+        return bot;
+    }
+
+    @Override
+    public void injectManager(CommandManager<T, SlashCommandInteractionEvent> commandManager) {
+        this.commandManager = commandManager;
+        this.jda.addEventListener(new JDAExecutor<>(commandManager));
+    }
+
+    @Override
+    public Logger getLogger() {
+        return logger;
+    }
+
+    @Override
+    public boolean hasPermission(SlashCommandInteractionEvent sender, String permission) {
+        if (sender.getMember() == null) {
+            return false;
+        }
+        try {
+            Permission perm = Permission.valueOf(permission.toUpperCase());
+            return sender.getMember().hasPermission(perm);
+        } catch (IllegalArgumentException e) {
+            logger.warning("Invalid permission: " + permission);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean isPlayer(SlashCommandInteractionEvent sender) {
+        // In Discord context, we consider guild-only commands
+        return sender.isFromGuild();
+    }
+
+    @Override
+    public void sendMessage(SlashCommandInteractionEvent sender, String message) {
+        if (!sender.isAcknowledged()) {
+            sender.reply(message).queue();
+        } else {
+            sender.getHook().sendMessage(message).queue();
+        }
+    }
+
+    @Override
+    public void addCommand(Command<T, SlashCommandInteractionEvent> command, String label) {
+        String[] parts = label.split("\\.");
+        String rootName = parts[0].toLowerCase();
+
+        if (parts.length == 1) {
+            // Root command
+            SlashCommandData slashCommand = Commands.slash(rootName,
+                    command.getDescription().isEmpty() ? "No description" : command.getDescription());
+
+            // Add arguments if this is a leaf command
+            if (command.getSubcommands().isEmpty()) {
+                addArgumentsToCommand(slashCommand, command);
+            }
+
+            slashCommands.put(rootName, slashCommand);
+
+        } else if (parts.length == 2) {
+            // Subcommand: /command subcommand
+            // Skip if this command has subcommands (it will be treated as a group)
+            if (!command.getSubcommands().isEmpty()) {
+                // This is a group, not a leaf subcommand - skip it
+                // Its children will be registered as subcommand groups (parts.length >= 3)
+                logger.warning(String.format(
+                    "Command '%s' has subcommands and will be treated as a subcommand group. " +
+                    "Discord does not support executing intermediate groups. " +
+                    "If you want this group to be executable, create a dedicated subcommand (e.g., '%s.list' or '%s.info').",
+                    label, label, label
+                ));
+                return;
+            }
+
+            String subName = parts[1].toLowerCase();
+
+            SlashCommandData slashCommand = slashCommands.computeIfAbsent(rootName,
+                    k -> Commands.slash(rootName, "Command group"));
+
+            SubcommandData subcommand = new SubcommandData(subName,
+                    command.getDescription().isEmpty() ? "No description" : command.getDescription());
+
+            addArgumentsToSubcommand(subcommand, command);
+            slashCommand.addSubcommands(subcommand);
+
+        } else if (parts.length >= 3) {
+            // Subcommand group: /command group subcommand
+            String groupName = parts[1].toLowerCase();
+            String subName = parts[2].toLowerCase();
+
+            SlashCommandData slashCommand = slashCommands.computeIfAbsent(rootName,
+                    k -> Commands.slash(rootName, "Command group"));
+
+            // Find or create the subcommand group
+            SubcommandGroupData group = null;
+            for (var existingGroup : slashCommand.getSubcommandGroups()) {
+                if (existingGroup.getName().equals(groupName)) {
+                    group = existingGroup;
+                    break;
+                }
+            }
+
+            if (group == null) {
+                group = new SubcommandGroupData(groupName, "Subcommand group");
+                slashCommand.addSubcommandGroups(group);
+            }
+
+            SubcommandData subcommand = new SubcommandData(subName,
+                    command.getDescription().isEmpty() ? "No description" : command.getDescription());
+
+            addArgumentsToSubcommand(subcommand, command);
+            group.addSubcommands(subcommand);
+        }
+    }
+
+    @Override
+    public void removeCommand(String label, boolean subcommand) {
+        String[] parts = label.split("\\.");
+        String rootName = parts[0].toLowerCase();
+
+        if (!subcommand && parts.length == 1) {
+            slashCommands.remove(rootName);
+        }
+    }
+
+    /**
+     * Add arguments to a slash command.
+     *
+     * @param slashCommand The slash command data.
+     * @param command      The command instance.
+     */
+    private void addArgumentsToCommand(SlashCommandData slashCommand, Command<T, SlashCommandInteractionEvent> command) {
+        List<Argument<SlashCommandInteractionEvent>> args = command.getArgs();
+        List<Argument<SlashCommandInteractionEvent>> optionalArgs = command.getOptinalArgs();
+
+        for (Argument<SlashCommandInteractionEvent> arg : args) {
+            OptionData option = createOptionData(arg, true);
+            slashCommand.addOptions(option);
+        }
+
+        for (Argument<SlashCommandInteractionEvent> arg : optionalArgs) {
+            OptionData option = createOptionData(arg, false);
+            slashCommand.addOptions(option);
+        }
+    }
+
+    /**
+     * Add arguments to a subcommand.
+     *
+     * @param subcommand The subcommand data.
+     * @param command    The command instance.
+     */
+    private void addArgumentsToSubcommand(SubcommandData subcommand, Command<T, SlashCommandInteractionEvent> command) {
+        List<Argument<SlashCommandInteractionEvent>> args = command.getArgs();
+        List<Argument<SlashCommandInteractionEvent>> optionalArgs = command.getOptinalArgs();
+
+        for (Argument<SlashCommandInteractionEvent> arg : args) {
+            OptionData option = createOptionData(arg, true);
+            subcommand.addOptions(option);
+        }
+
+        for (Argument<SlashCommandInteractionEvent> arg : optionalArgs) {
+            OptionData option = createOptionData(arg, false);
+            subcommand.addOptions(option);
+        }
+    }
+
+    /**
+     * Create an OptionData from an Argument.
+     *
+     * @param arg      The argument.
+     * @param required Whether the argument is required.
+     * @return The OptionData.
+     */
+    private OptionData createOptionData(Argument<SlashCommandInteractionEvent> arg, boolean required) {
+        String[] parts = arg.arg().split(CommandManager.TYPE_PARSER);
+        String name = parts[0].trim().toLowerCase();
+        String type = parts.length > 1 ? parts[1].trim() : "string";
+
+        OptionType optionType = mapToOptionType(type);
+
+        return new OptionData(optionType, name, "Argument: " + name, required);
+    }
+
+    /**
+     * Map a type string to a JDA OptionType.
+     *
+     * @param type The type string.
+     * @return The corresponding OptionType.
+     */
+    private OptionType mapToOptionType(String type) {
+        return switch (type.toLowerCase()) {
+            case "integer", "int", "long" -> OptionType.INTEGER;
+            case "boolean" -> OptionType.BOOLEAN;
+            case "user", "member" -> OptionType.USER;
+            case "role" -> OptionType.ROLE;
+            case "channel", "guildchannelunion" -> OptionType.CHANNEL;
+            case "double", "float" -> OptionType.NUMBER;
+            case "attachment" -> OptionType.ATTACHMENT;
+            case "mentionable" -> OptionType.MENTIONABLE;
+            default -> OptionType.STRING;
+        };
+    }
+
+    /**
+     * Synchronize all registered commands with Discord globally.
+     * This may take up to 1 hour to update.
+     */
+    public void syncCommands() {
+        if (commandManager.isDebug()) {
+            logger.info("Syncing " + slashCommands.size() + " commands to Discord globally...");
+        }
+        jda.updateCommands()
+                .addCommands(slashCommands.values())
+                .queue(
+                        success -> logger.info("Successfully synced " + success.size() + " commands globally"),
+                        error -> logger.severe("Failed to sync commands: " + error.getMessage())
+                );
+    }
+
+    /**
+     * Synchronize all registered commands with a specific guild.
+     * This updates instantly and is useful for testing.
+     *
+     * @param guildId The guild ID.
+     */
+    public void syncCommandsToGuild(long guildId) {
+        if (commandManager.isDebug()) {
+            logger.info("Syncing " + slashCommands.size() + " commands to guild " + guildId + "...");
+        }
+        jda.getGuildById(guildId).updateCommands()
+                .addCommands(slashCommands.values())
+                .queue(
+                        success -> logger.info("Successfully synced " + success.size() + " commands to guild " + guildId),
+                        error -> logger.severe("Failed to sync commands to guild: " + error.getMessage())
+                );
+    }
+
+    /**
+     * Synchronize all registered commands with a specific guild.
+     *
+     * @param guildId The guild ID as a string.
+     */
+    public void syncCommandsToGuild(String guildId) {
+        syncCommandsToGuild(Long.parseLong(guildId));
+    }
+
+    /**
+     * Get the JDA instance.
+     *
+     * @return The JDA instance.
+     */
+    public JDA getJDA() {
+        return jda;
+    }
+
+    /**
+     * Get the command manager.
+     *
+     * @return The command manager.
+     */
+    public CommandManager<T, SlashCommandInteractionEvent> getCommandManager() {
+        return commandManager;
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/arguments/AttachmentArgument.java b/jda/src/main/java/fr/traqueur/commands/jda/arguments/AttachmentArgument.java
new file mode 100644
index 0000000..5e02cd0
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/arguments/AttachmentArgument.java
@@ -0,0 +1,50 @@
+package fr.traqueur.commands.jda.arguments;
+
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.entities.Message;
+
+/**
+ * Argument converter for JDA {@link Message.Attachment}.
+ * <p>
+ * This converter handles attachment input for Discord messages.
+ * </p>
+ * <p>
+ * Note: Attachments are only available in the context of slash commands or message events.
+ * For slash commands, Discord handles attachment input natively via the ATTACHMENT option type.
+ * </p>
+ * <p>
+ * <b>Important:</b> This converter cannot resolve attachments from a string input.
+ * It returns null when called. For slash commands, attachments are automatically provided
+ * by Discord through the event options (see JDAExecutor lines 136-138).
+ * </p>
+ */
+public class AttachmentArgument extends JDAArgumentConverter<Message.Attachment> {
+
+    /**
+     * Creates a new AttachmentArgument.
+     *
+     * @param jda The JDA instance.
+     */
+    public AttachmentArgument(JDA jda) {
+        super(jda);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * Note: This implementation cannot resolve attachments from string input.
+     * For slash commands, attachments are automatically provided by Discord
+     * through the event options.
+     * </p>
+     *
+     * @param input The input string (unused for attachments)
+     * @return Always returns null as attachments cannot be resolved from strings
+     */
+    @Override
+    public Message.Attachment apply(String input) {
+        // Attachments cannot be resolved from string input
+        // They are automatically provided by Discord in slash commands
+        // through the event options (see JDAExecutor lines 136-138)
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/arguments/ChannelArgument.java b/jda/src/main/java/fr/traqueur/commands/jda/arguments/ChannelArgument.java
new file mode 100644
index 0000000..9f19d2b
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/arguments/ChannelArgument.java
@@ -0,0 +1,56 @@
+package fr.traqueur.commands.jda.arguments;
+
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.entities.channel.unions.GuildChannelUnion;
+
+/**
+ * Argument converter for JDA {@link GuildChannelUnion}.
+ * <p>
+ * This converter handles channel input in various formats:
+ * </p>
+ * <ul>
+ *     <li>Channel ID (e.g., "123456789")</li>
+ *     <li>Channel mention (e.g., "&lt;#123456789&gt;")</li>
+ * </ul>
+ * <p>
+ * Note: This converter requires a guild context to resolve channels.
+ * For slash commands, Discord handles channel input natively via the CHANNEL option type.
+ * The guild context is obtained from the command execution context.
+ * </p>
+ * <p>
+ * <b>Important:</b> This converter cannot resolve channels without a guild context.
+ * It returns null if called outside of a guild context. For slash commands,
+ * use {@link fr.traqueur.commands.jda.JDAArguments#getChannel(String)} instead,
+ * which properly handles the guild context from the event.
+ * </p>
+ */
+public class ChannelArgument extends JDAArgumentConverter<GuildChannelUnion> {
+
+    /**
+     * Creates a new ChannelArgument.
+     *
+     * @param jda The JDA instance.
+     */
+    public ChannelArgument(JDA jda) {
+        super(jda);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * Note: This implementation cannot resolve channels without a guild context.
+     * For slash commands, the channel is automatically resolved by Discord and
+     * available through {@link fr.traqueur.commands.jda.JDAArguments#getChannel(String)}.
+     * </p>
+     *
+     * @param input The channel ID or mention string
+     * @return Always returns null as guild context is required
+     */
+    @Override
+    public GuildChannelUnion apply(String input) {
+        // Channels require guild context which is not available in this converter
+        // For slash commands, channels are automatically provided by Discord
+        // through the event options (see JDAExecutor lines 129-131)
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/arguments/JDAArgumentConverter.java b/jda/src/main/java/fr/traqueur/commands/jda/arguments/JDAArgumentConverter.java
new file mode 100644
index 0000000..2961345
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/arguments/JDAArgumentConverter.java
@@ -0,0 +1,49 @@
+package fr.traqueur.commands.jda.arguments;
+
+import fr.traqueur.commands.api.arguments.ArgumentConverter;
+import fr.traqueur.commands.api.arguments.TabCompleter;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Abstract base class for JDA argument converters.
+ * <p>
+ * This class provides access to the JDA instance for converters that need it.
+ * All JDA-specific argument converters should extend this class.
+ * </p>
+ *
+ * @param <T> The type this converter produces.
+ */
+public abstract class JDAArgumentConverter<T> implements ArgumentConverter<T>, TabCompleter<SlashCommandInteractionEvent> {
+
+    /**
+     * The JDA instance used for resolving Discord entities.
+     */
+    protected final JDA jda;
+
+    /**
+     * Creates a new JDA argument converter.
+     *
+     * @param jda The JDA instance.
+     */
+    public JDAArgumentConverter(JDA jda) {
+        this.jda = jda;
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * For slash commands, autocomplete is handled by Discord natively.
+     * This method returns an empty list by default.
+     * Subclasses can override this if needed for non-slash command contexts.
+     * </p>
+     */
+    @Override
+    public List<String> onCompletion(SlashCommandInteractionEvent sender, List<String> args) {
+        // Slash commands handle autocomplete natively through Discord
+        return Collections.emptyList();
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/arguments/MemberArgument.java b/jda/src/main/java/fr/traqueur/commands/jda/arguments/MemberArgument.java
new file mode 100644
index 0000000..32a32d1
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/arguments/MemberArgument.java
@@ -0,0 +1,56 @@
+package fr.traqueur.commands.jda.arguments;
+
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.entities.Member;
+
+/**
+ * Argument converter for JDA {@link Member}.
+ * <p>
+ * This converter handles member input in various formats:
+ * </p>
+ * <ul>
+ *     <li>User ID (e.g., "123456789")</li>
+ *     <li>User mention (e.g., "&lt;@123456789&gt;" or "&lt;@!123456789&gt;")</li>
+ * </ul>
+ * <p>
+ * Note: This converter requires a guild context to resolve members.
+ * For slash commands, Discord handles member input natively via the USER option type.
+ * The guild context is obtained from the command execution context.
+ * </p>
+ * <p>
+ * <b>Important:</b> This converter cannot resolve members without a guild context.
+ * It returns null if called outside of a guild context. For slash commands,
+ * use {@link fr.traqueur.commands.jda.JDAArguments#getMember(String)} instead,
+ * which properly handles the guild context from the event.
+ * </p>
+ */
+public class MemberArgument extends JDAArgumentConverter<Member> {
+
+    /**
+     * Creates a new MemberArgument.
+     *
+     * @param jda The JDA instance.
+     */
+    public MemberArgument(JDA jda) {
+        super(jda);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * Note: This implementation cannot resolve members without a guild context.
+     * For slash commands, the member is automatically resolved by Discord and
+     * available through {@link fr.traqueur.commands.jda.JDAArguments#getMember(String)}.
+     * </p>
+     *
+     * @param input The user ID or mention string
+     * @return Always returns null as guild context is required
+     */
+    @Override
+    public Member apply(String input) {
+        // Members require guild context which is not available in this converter
+        // For slash commands, members are automatically provided by Discord
+        // through the event options (see JDAExecutor lines 122-124)
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/arguments/RoleArgument.java b/jda/src/main/java/fr/traqueur/commands/jda/arguments/RoleArgument.java
new file mode 100644
index 0000000..f7785d0
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/arguments/RoleArgument.java
@@ -0,0 +1,56 @@
+package fr.traqueur.commands.jda.arguments;
+
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.entities.Role;
+
+/**
+ * Argument converter for JDA {@link Role}.
+ * <p>
+ * This converter handles role input in various formats:
+ * </p>
+ * <ul>
+ *     <li>Role ID (e.g., "123456789")</li>
+ *     <li>Role mention (e.g., "&lt;@&amp;123456789&gt;")</li>
+ * </ul>
+ * <p>
+ * Note: This converter requires a guild context to resolve roles.
+ * For slash commands, Discord handles role input natively via the ROLE option type.
+ * The guild context is obtained from the command execution context.
+ * </p>
+ * <p>
+ * <b>Important:</b> This converter cannot resolve roles without a guild context.
+ * It returns null if called outside of a guild context. For slash commands,
+ * use {@link fr.traqueur.commands.jda.JDAArguments#getRole(String)} instead,
+ * which properly handles the guild context from the event.
+ * </p>
+ */
+public class RoleArgument extends JDAArgumentConverter<Role> {
+
+    /**
+     * Creates a new RoleArgument.
+     *
+     * @param jda The JDA instance.
+     */
+    public RoleArgument(JDA jda) {
+        super(jda);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * Note: This implementation cannot resolve roles without a guild context.
+     * For slash commands, the role is automatically resolved by Discord and
+     * available through {@link fr.traqueur.commands.jda.JDAArguments#getRole(String)}.
+     * </p>
+     *
+     * @param input The role ID or mention string
+     * @return Always returns null as guild context is required
+     */
+    @Override
+    public Role apply(String input) {
+        // Roles require guild context which is not available in this converter
+        // For slash commands, roles are automatically provided by Discord
+        // through the event options (see JDAExecutor line 127)
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/arguments/UserArgument.java b/jda/src/main/java/fr/traqueur/commands/jda/arguments/UserArgument.java
new file mode 100644
index 0000000..e129fbb
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/arguments/UserArgument.java
@@ -0,0 +1,60 @@
+package fr.traqueur.commands.jda.arguments;
+
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.entities.User;
+
+/**
+ * Argument converter for JDA {@link User}.
+ * <p>
+ * This converter handles user input in various formats:
+ * </p>
+ * <ul>
+ *     <li>User ID (e.g., "123456789")</li>
+ *     <li>User mention (e.g., "&lt;@123456789&gt;" or "&lt;@!123456789&gt;")</li>
+ * </ul>
+ * <p>
+ * For slash commands, Discord handles user input natively via the USER option type.
+ * This converter is primarily useful for text-based command contexts.
+ * </p>
+ */
+public class UserArgument extends JDAArgumentConverter<User> {
+
+    /**
+     * Creates a new UserArgument.
+     *
+     * @param jda The JDA instance.
+     */
+    public UserArgument(JDA jda) {
+        super(jda);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * Converts a user ID or mention to a User object.
+     * Accepts both raw IDs (e.g., "123456789") and mentions (e.g., "&lt;@123456789&gt;").
+     * </p>
+     *
+     * @param input The user ID or mention string
+     * @return The User object, or null if not found or invalid
+     */
+    @Override
+    public User apply(String input) {
+        if (input == null || input.isEmpty()) {
+            return null;
+        }
+
+        // Remove mention formatting if present (<@123456789> or <@!123456789>)
+        String id = input.replaceAll("[<@!>]", "");
+
+        try {
+            long userId = Long.parseLong(id);
+            return jda.retrieveUserById(userId).complete();
+        } catch (NumberFormatException e) {
+            return null;
+        } catch (Exception e) {
+            // User not found or other JDA exception
+            return null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/requirements/GuildRequirement.java b/jda/src/main/java/fr/traqueur/commands/jda/requirements/GuildRequirement.java
new file mode 100644
index 0000000..b962f9f
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/requirements/GuildRequirement.java
@@ -0,0 +1,50 @@
+package fr.traqueur.commands.jda.requirements;
+
+import fr.traqueur.commands.api.requirements.Requirement;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Requirement that checks if the command is executed in a specific guild.
+ */
+public class GuildRequirement implements Requirement<SlashCommandInteractionEvent> {
+
+    private final Collection<Long> guildIds;
+    private final String errorMessage;
+
+    /**
+     * Constructor for GuildRequirement.
+     *
+     * @param guildIds The guild IDs where the command is allowed.
+     */
+    public GuildRequirement(Long... guildIds) {
+        this(null, guildIds);
+    }
+
+    /**
+     * Constructor for GuildRequirement with custom error message.
+     *
+     * @param errorMessage Custom error message.
+     * @param guildIds     The guild IDs where the command is allowed.
+     */
+    public GuildRequirement(String errorMessage, Long... guildIds) {
+        this.guildIds = Arrays.asList(guildIds);
+        this.errorMessage = errorMessage != null ? errorMessage :
+                "This command can only be used in specific servers.";
+    }
+
+    @Override
+    public boolean check(SlashCommandInteractionEvent event) {
+        if (event.getGuild() == null) {
+            return false;
+        }
+        return guildIds.contains(event.getGuild().getIdLong());
+    }
+
+    @Override
+    public String errorMessage() {
+        return errorMessage;
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/requirements/PermissionRequirement.java b/jda/src/main/java/fr/traqueur/commands/jda/requirements/PermissionRequirement.java
new file mode 100644
index 0000000..78a3eab
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/requirements/PermissionRequirement.java
@@ -0,0 +1,58 @@
+package fr.traqueur.commands.jda.requirements;
+
+import fr.traqueur.commands.api.requirements.Requirement;
+import net.dv8tion.jda.api.Permission;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Requirement that checks if the user has specific Discord permissions.
+ */
+public class PermissionRequirement implements Requirement<SlashCommandInteractionEvent> {
+
+    private final Collection<Permission> permissions;
+    private final String errorMessage;
+
+    /**
+     * Constructor for PermissionRequirement.
+     *
+     * @param permissions The permissions required.
+     */
+    public PermissionRequirement(Permission... permissions) {
+        this(null, permissions);
+    }
+
+    /**
+     * Constructor for PermissionRequirement with custom error message.
+     *
+     * @param errorMessage Custom error message.
+     * @param permissions  The permissions required.
+     */
+    public PermissionRequirement(String errorMessage, Permission... permissions) {
+        this.permissions = Arrays.asList(permissions);
+        this.errorMessage = errorMessage != null ? errorMessage :
+                "You need the following permissions: " + formatPermissions();
+    }
+
+    @Override
+    public boolean check(SlashCommandInteractionEvent event) {
+        if (event.getMember() == null) {
+            return false;
+        }
+        return event.getMember().hasPermission(permissions);
+    }
+
+    @Override
+    public String errorMessage() {
+        return errorMessage;
+    }
+
+    private String formatPermissions() {
+        return permissions.stream()
+                .map(Permission::getName)
+                .reduce((a, b) -> a + ", " + b)
+                .orElse("");
+    }
+}
\ No newline at end of file
diff --git a/jda/src/main/java/fr/traqueur/commands/jda/requirements/RoleRequirement.java b/jda/src/main/java/fr/traqueur/commands/jda/requirements/RoleRequirement.java
new file mode 100644
index 0000000..59f93a7
--- /dev/null
+++ b/jda/src/main/java/fr/traqueur/commands/jda/requirements/RoleRequirement.java
@@ -0,0 +1,67 @@
+package fr.traqueur.commands.jda.requirements;
+
+import fr.traqueur.commands.api.requirements.Requirement;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Requirement that checks if the user has specific Discord roles.
+ */
+public class RoleRequirement implements Requirement<SlashCommandInteractionEvent> {
+
+    private final Collection<Long> roleIds;
+    private final String errorMessage;
+    private final boolean requireAll;
+
+    /**
+     * Constructor for RoleRequirement.
+     * Requires at least one of the specified roles.
+     *
+     * @param roleIds The role IDs required.
+     */
+    public RoleRequirement(Long... roleIds) {
+        this(false, null, roleIds);
+    }
+
+    /**
+     * Constructor for RoleRequirement with custom error message.
+     *
+     * @param requireAll   Whether all roles are required (true) or just one (false).
+     * @param errorMessage Custom error message.
+     * @param roleIds      The role IDs required.
+     */
+    public RoleRequirement(boolean requireAll, String errorMessage, Long... roleIds) {
+        this.roleIds = Arrays.asList(roleIds);
+        this.requireAll = requireAll;
+        this.errorMessage = errorMessage != null ? errorMessage :
+                "You don't have the required role" + (requireAll ? "s" : "") + " to use this command.";
+    }
+
+    @Override
+    public boolean check(SlashCommandInteractionEvent event) {
+        Member member = event.getMember();
+        if (member == null) {
+            return false;
+        }
+
+        if (requireAll) {
+            // Must have all roles
+            return roleIds.stream()
+                    .allMatch(roleId -> member.getRoles().stream()
+                            .anyMatch(role -> role.getIdLong() == roleId));
+        } else {
+            // Must have at least one role
+            return member.getRoles().stream()
+                    .anyMatch(role -> roleIds.contains(role.getIdLong()));
+        }
+    }
+
+    @Override
+    public String errorMessage() {
+        return errorMessage;
+    }
+}
\ No newline at end of file
diff --git a/jitpack.yml b/jitpack.yml
index bf75550..097b769 100644
--- a/jitpack.yml
+++ b/jitpack.yml
@@ -3,4 +3,4 @@ jdk:
 
 build:
   commands:
-    - ./gradlew core:publishToMavenLocal spigot:publishToMavenLocal velocity:publishToMavenLocal
\ No newline at end of file
+    - ./gradlew core:publishToMavenLocal spigot:publishToMavenLocal velocity:publishToMavenLocal jda:publishToMavenLocal
\ No newline at end of file
diff --git a/settings.gradle b/settings.gradle
index 247152e..2d7fb13 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -4,4 +4,6 @@ include 'velocity-test-plugin'
 include 'spigot-test-plugin'
 include 'spigot'
 include 'core'
-include 'velocity'
\ No newline at end of file
+include 'velocity'
+include 'jda'
+include 'jda-test-bot'
\ No newline at end of file
diff --git a/spigot/src/main/java/fr/traqueur/commands/spigot/SpigotPlatform.java b/spigot/src/main/java/fr/traqueur/commands/spigot/SpigotPlatform.java
index 7aad6e0..bd0f6d8 100644
--- a/spigot/src/main/java/fr/traqueur/commands/spigot/SpigotPlatform.java
+++ b/spigot/src/main/java/fr/traqueur/commands/spigot/SpigotPlatform.java
@@ -1,7 +1,8 @@
 package fr.traqueur.commands.spigot;
 
-import fr.traqueur.commands.api.models.Command;
 import fr.traqueur.commands.api.CommandManager;
+import fr.traqueur.commands.api.exceptions.CommandRegistrationException;
+import fr.traqueur.commands.api.models.Command;
 import fr.traqueur.commands.api.models.CommandPlatform;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
@@ -154,7 +155,7 @@ public void addCommand(Command<T, CommandSender> command, String label) {
                     return;
                 }
             } catch (Exception e) {
-                throw new RuntimeException(e);
+                throw new CommandRegistrationException("Failed to register command '" + cmdLabel + "' in Spigot", e);
             }
         }