diff --git a/core/src/main/java/tc/oc/pgm/command/ModeCommand.java b/core/src/main/java/tc/oc/pgm/command/ModeCommand.java
index 15e42c01c5..0315ad0e5e 100644
--- a/core/src/main/java/tc/oc/pgm/command/ModeCommand.java
+++ b/core/src/main/java/tc/oc/pgm/command/ModeCommand.java
@@ -17,9 +17,11 @@
 import net.kyori.adventure.text.TextComponent;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.apache.commons.lang.WordUtils;
+import org.jetbrains.annotations.NotNull;
 import tc.oc.pgm.api.Permissions;
 import tc.oc.pgm.api.match.Match;
 import tc.oc.pgm.countdowns.CountdownContext;
+import tc.oc.pgm.modes.Mode;
 import tc.oc.pgm.modes.ModeChangeCountdown;
 import tc.oc.pgm.modes.ModesPaginatedResult;
 import tc.oc.pgm.modes.ObjectiveModesMatchModule;
@@ -34,43 +36,35 @@ public final class ModeCommand {
   public void next(Audience audience, Match match) {
     ObjectiveModesMatchModule modes = getModes(match);
 
-    if (modes == null) {
-      throwNoResults();
+    List<ModeChangeCountdown> countdowns = modes.getActiveCountdowns();
+
+    if (countdowns.isEmpty()) throwNoResults();
+
+    TextComponent.Builder builder =
+        text().append(translatable("command.nextMode", NamedTextColor.DARK_PURPLE).append(space()));
+
+    ModeChangeCountdown next = countdowns.get(0);
+    Duration timeLeft = modes.getCountdown().getTimeLeft(next);
+
+    if (timeLeft == null) {
+      builder.append(text(next.getMode().getPreformattedMaterialName(), NamedTextColor.GOLD));
+    } else if (timeLeft.getSeconds() >= 0) {
+      builder.append(
+          text(
+                  WordUtils.capitalize(next.getMode().getPreformattedMaterialName()),
+                  NamedTextColor.GOLD)
+              .append(space())
+              .append(text("(", NamedTextColor.AQUA))
+              .append(
+                  new ModesPaginatedResult(modes)
+                      .formatSingleCountdown(next)
+                      .color(NamedTextColor.AQUA))
+              .append(text(")", NamedTextColor.AQUA)));
     } else {
-      List<ModeChangeCountdown> countdowns = modes.getActiveCountdowns();
-
-      if (countdowns.isEmpty()) {
-        throwNoResults();
-      } else {
-        TextComponent.Builder builder =
-            text()
-                .append(
-                    translatable("command.nextMode", NamedTextColor.DARK_PURPLE).append(space()));
-
-        ModeChangeCountdown next = countdowns.get(0);
-        Duration timeLeft = modes.getCountdown().getTimeLeft(next);
-
-        if (timeLeft == null) {
-          builder.append(text(next.getMode().getPreformattedMaterialName(), NamedTextColor.GOLD));
-        } else if (timeLeft.getSeconds() >= 0) {
-          builder.append(
-              text(
-                      WordUtils.capitalize(next.getMode().getPreformattedMaterialName()),
-                      NamedTextColor.GOLD)
-                  .append(space())
-                  .append(text("(", NamedTextColor.AQUA))
-                  .append(
-                      new ModesPaginatedResult(modes)
-                          .formatSingleCountdown(next)
-                          .color(NamedTextColor.AQUA))
-                  .append(text(")", NamedTextColor.AQUA)));
-        } else {
-          throwNoResults();
-        }
-
-        audience.sendMessage(builder.build());
-      }
+      throwNoResults();
     }
+
+    audience.sendMessage(builder.build());
   }
 
   @CommandMethod("list|page [page]")
@@ -79,7 +73,20 @@ public void list(
       Audience audience,
       Match match,
       @Argument(value = "page", defaultValue = "1") @Range(min = "1") int page) {
-    showList(page, audience, getModes(match));
+    ObjectiveModesMatchModule modes = getModes(match);
+    List<ModeChangeCountdown> modeList = modes.getSortedCountdowns(true);
+    int resultsPerPage = 8;
+    int pages = (modeList.size() + resultsPerPage - 1) / resultsPerPage;
+    Component header =
+        TextFormatter.paginate(
+            translatable("command.monumentModes"),
+            page,
+            pages,
+            NamedTextColor.DARK_AQUA,
+            NamedTextColor.AQUA,
+            true);
+
+    new ModesPaginatedResult(header, resultsPerPage, modes).display(audience, modeList, page);
   }
 
   @CommandMethod("push <time>")
@@ -88,13 +95,7 @@ public void list(
   public void push(Audience audience, Match match, @Argument("time") Duration duration) {
     ObjectiveModesMatchModule modes = getModes(match);
 
-    if (!match.isRunning()) {
-      throwMatchNotStarted();
-    }
-
-    if (modes == null) {
-      throwNoResults();
-    }
+    if (!match.isRunning()) throwMatchNotStarted();
 
     CountdownContext countdowns = modes.getCountdown();
     List<ModeChangeCountdown> sortedCountdowns = modes.getSortedCountdowns(false);
@@ -125,72 +126,39 @@ public void push(Audience audience, Match match, @Argument("time") Duration dura
     audience.sendMessage(builder);
   }
 
-  @CommandMethod("start")
+  @CommandMethod("start <mode> [time]")
   @CommandDescription("Starts an objective mode")
   @CommandPermission(Permissions.GAMEPLAY)
-  public void start(Audience audience, Match match, int modeNumber, Duration duration) {
-    ObjectiveModesMatchModule modes = getModes(match);
+  public void start(
+      Audience audience,
+      Match match,
+      @Argument("mode") Mode mode,
+      @Argument(value = "time", defaultValue = "0s") Duration time) {
+    if (!match.isRunning()) throwMatchNotStarted();
 
-    if (!match.isRunning()) {
-      throwMatchNotStarted();
-    }
-    if (modes == null) {
-      throwNoResults();
-    }
-    modeNumber--;
-    CountdownContext countdowns = modes.getCountdown();
-    List<ModeChangeCountdown> sortedCountdowns = modes.getSortedCountdowns(true);
-    ModeChangeCountdown selectedMode;
+    ObjectiveModesMatchModule modes = getModes(match);
+    if (time.isNegative()) throwInvalidNumber(time.toString());
 
-    if (sortedCountdowns.toArray().length < modeNumber) {
-      throwInvalidNumber(Integer.toString(modeNumber));
-    }
-    if (duration.isNegative()) {
-      throwInvalidNumber(duration.toString());
-    }
-    selectedMode = sortedCountdowns.get(modeNumber);
-    countdowns.cancel(selectedMode);
-    countdowns.start(selectedMode, duration);
+    CountdownContext context = modes.getCountdown();
+    ModeChangeCountdown countdown = modes.getCountdown(mode);
 
-    String modeName;
-    if (selectedMode.getMode().getName() != null) {
-      modeName = selectedMode.getMode().getName();
-    } else {
-      modeName = selectedMode.getMode().getPreformattedMaterialName();
-    }
+    context.cancel(countdown);
+    context.start(countdown, time);
 
     TextComponent.Builder builder =
         text()
             .append(
-                translatable("command.selectedModePushed", text(modeName))
+                translatable("command.selectedModePushed", mode.getComponentName())
                     .color(NamedTextColor.GOLD)
                     .append(space()));
-    builder.append(clock(Math.abs(duration.getSeconds())).color(NamedTextColor.AQUA));
+    builder.append(clock(Math.abs(time.getSeconds())).color(NamedTextColor.AQUA));
     audience.sendMessage(builder);
   }
 
-  private static void showList(int page, Audience audience, ObjectiveModesMatchModule modes) {
-    if (modes == null) {
-      throwNoResults();
-    } else {
-      List<ModeChangeCountdown> modeList = modes.getSortedCountdowns(true);
-      int resultsPerPage = 8;
-      int pages = (modeList.size() + resultsPerPage - 1) / resultsPerPage;
-      Component header =
-          TextFormatter.paginate(
-              translatable("command.monumentModes"),
-              page,
-              pages,
-              NamedTextColor.DARK_AQUA,
-              NamedTextColor.AQUA,
-              true);
-
-      new ModesPaginatedResult(header, resultsPerPage, modes).display(audience, modeList, page);
-    }
-  }
-
-  private static ObjectiveModesMatchModule getModes(Match match) {
-    return match.getModule(ObjectiveModesMatchModule.class);
+  private static @NotNull ObjectiveModesMatchModule getModes(Match match) {
+    return match
+        .moduleOptional(ObjectiveModesMatchModule.class)
+        .orElseThrow(() -> exception("command.moduleNotFound", text("modes")));
   }
 
   private static void throwNoResults() {
diff --git a/core/src/main/java/tc/oc/pgm/command/parsers/MatchObjectParser.java b/core/src/main/java/tc/oc/pgm/command/parsers/MatchObjectParser.java
new file mode 100644
index 0000000000..1cad30f0d3
--- /dev/null
+++ b/core/src/main/java/tc/oc/pgm/command/parsers/MatchObjectParser.java
@@ -0,0 +1,94 @@
+package tc.oc.pgm.command.parsers;
+
+import static cloud.commandframework.arguments.parser.ArgumentParseResult.failure;
+import static net.kyori.adventure.text.Component.text;
+import static tc.oc.pgm.util.text.TextException.exception;
+import static tc.oc.pgm.util.text.TextException.invalidFormat;
+import static tc.oc.pgm.util.text.TextException.playerOnly;
+
+import cloud.commandframework.arguments.parser.ArgumentParseResult;
+import cloud.commandframework.arguments.parser.ParserParameters;
+import cloud.commandframework.context.CommandContext;
+import cloud.commandframework.paper.PaperCommandManager;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.bukkit.command.CommandSender;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.NotNull;
+import tc.oc.pgm.api.PGM;
+import tc.oc.pgm.api.match.Match;
+import tc.oc.pgm.api.match.MatchModule;
+import tc.oc.pgm.command.util.CommandKeys;
+import tc.oc.pgm.util.LiquidMetal;
+import tc.oc.pgm.util.StringUtils;
+import tc.oc.pgm.util.text.TextException;
+
+/**
+ * Generic parser for match-time objects, eg: teams, classes, modes, etc. Automatically handles
+ * getting the module, and failing if module isn't enabled.
+ *
+ * @param <T> The object-type to parse
+ * @param <M> The match module that provides it
+ */
+public abstract class MatchObjectParser<T, M extends MatchModule>
+    extends StringLikeParser<CommandSender, T> {
+
+  private final Class<T> objType;
+  private final Class<M> moduleType;
+  private final String moduleName;
+
+  public MatchObjectParser(
+      PaperCommandManager<CommandSender> manager,
+      ParserParameters options,
+      Class<T> objType,
+      Class<M> moduleType,
+      String moduleName) {
+    super(manager, options);
+    this.objType = objType;
+    this.moduleType = moduleType;
+    this.moduleName = moduleName;
+  }
+
+  @Override
+  public ArgumentParseResult<T> parse(
+      @NotNull CommandContext<CommandSender> context, @NotNull String text) {
+    Match match = PGM.get().getMatchManager().getMatch(context.getSender());
+    if (match == null) return failure(playerOnly());
+
+    M module = match.getModule(moduleType);
+    if (module == null) return failure(moduleNotFound());
+
+    T obj = StringUtils.bestFuzzyMatch(text, objects(module), this::getName);
+    if (obj == null) return failure(invalidFormat(text, objType));
+
+    return ArgumentParseResult.success(obj);
+  }
+
+  @Override
+  public @NonNull List<@NonNull String> suggestions(
+      @NonNull CommandContext<CommandSender> context, @NonNull String input) {
+    Match match = PGM.get().getMatchManager().getMatch(context.getSender());
+    if (match == null) return Collections.emptyList();
+
+    List<String> inputQueue = context.get(CommandKeys.INPUT_QUEUE);
+    String text = StringUtils.getText(inputQueue);
+    String mustKeep = StringUtils.getMustKeepText(inputQueue);
+
+    return match.moduleOptional(moduleType).map(this::objects).orElse(Collections.emptySet())
+        .stream()
+        .map(this::getName)
+        .filter(name -> LiquidMetal.match(name, text))
+        .map(name -> StringUtils.getSuggestion(name, mustKeep))
+        .collect(Collectors.toList());
+  }
+
+  protected abstract Collection<T> objects(M module);
+
+  protected abstract String getName(T obj);
+
+  protected TextException moduleNotFound() {
+    return exception("command.moduleNotFound", text(moduleName));
+  }
+}
diff --git a/core/src/main/java/tc/oc/pgm/command/parsers/ModeParser.java b/core/src/main/java/tc/oc/pgm/command/parsers/ModeParser.java
new file mode 100644
index 0000000000..e53e1b3805
--- /dev/null
+++ b/core/src/main/java/tc/oc/pgm/command/parsers/ModeParser.java
@@ -0,0 +1,25 @@
+package tc.oc.pgm.command.parsers;
+
+import cloud.commandframework.arguments.parser.ParserParameters;
+import cloud.commandframework.paper.PaperCommandManager;
+import java.util.Collection;
+import org.bukkit.command.CommandSender;
+import tc.oc.pgm.modes.Mode;
+import tc.oc.pgm.modes.ObjectiveModesMatchModule;
+
+public class ModeParser extends MatchObjectParser<Mode, ObjectiveModesMatchModule> {
+
+  public ModeParser(PaperCommandManager<CommandSender> manager, ParserParameters options) {
+    super(manager, options, Mode.class, ObjectiveModesMatchModule.class, "modes");
+  }
+
+  @Override
+  protected Collection<Mode> objects(ObjectiveModesMatchModule module) {
+    return module.getModes();
+  }
+
+  @Override
+  protected String getName(Mode mode) {
+    return mode.getId();
+  }
+}
diff --git a/core/src/main/java/tc/oc/pgm/command/parsers/PartyParser.java b/core/src/main/java/tc/oc/pgm/command/parsers/PartyParser.java
index e1f6dd9b2a..5b5f610379 100644
--- a/core/src/main/java/tc/oc/pgm/command/parsers/PartyParser.java
+++ b/core/src/main/java/tc/oc/pgm/command/parsers/PartyParser.java
@@ -9,8 +9,6 @@
 import cloud.commandframework.context.CommandContext;
 import cloud.commandframework.paper.PaperCommandManager;
 import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 import org.bukkit.command.CommandSender;
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.jetbrains.annotations.NotNull;
@@ -19,10 +17,14 @@
 import tc.oc.pgm.api.party.Party;
 import tc.oc.pgm.util.LiquidMetal;
 
+/** Parses parties, ie: teams, plus the obs keyword for the observer party */
 public final class PartyParser extends StringLikeParser<CommandSender, Party> {
 
+  private final TeamParser teamParser;
+
   public PartyParser(PaperCommandManager<CommandSender> manager, ParserParameters options) {
     super(manager, options);
+    this.teamParser = new TeamParser(manager, options);
   }
 
   @Override
@@ -33,14 +35,14 @@ public ArgumentParseResult<Party> parse(
 
     if (text.equalsIgnoreCase("obs")) return success(match.getDefaultParty());
 
-    return TeamParser.getTeam(match, text).mapParsedValue(team -> team);
+    return teamParser.parse(context, text).mapParsedValue(team -> team);
   }
 
   @Override
   public @NonNull List<@NonNull String> suggestions(
       @NonNull CommandContext<CommandSender> context, @NonNull String input) {
-    return Stream.concat(Stream.of("obs"), TeamParser.getTeams(context.getSender()))
-        .filter(str -> LiquidMetal.match(str, input))
-        .collect(Collectors.toList());
+    List<String> teams = teamParser.suggestions(context, input);
+    if (LiquidMetal.match("obs", input)) teams.add("obs");
+    return teams;
   }
 }
diff --git a/core/src/main/java/tc/oc/pgm/command/parsers/PlayerClassParser.java b/core/src/main/java/tc/oc/pgm/command/parsers/PlayerClassParser.java
index 0e9a169601..6755ad74c2 100644
--- a/core/src/main/java/tc/oc/pgm/command/parsers/PlayerClassParser.java
+++ b/core/src/main/java/tc/oc/pgm/command/parsers/PlayerClassParser.java
@@ -1,63 +1,33 @@
 package tc.oc.pgm.command.parsers;
 
-import static cloud.commandframework.arguments.parser.ArgumentParseResult.failure;
 import static tc.oc.pgm.util.text.TextException.exception;
-import static tc.oc.pgm.util.text.TextException.playerOnly;
 
-import cloud.commandframework.arguments.parser.ArgumentParseResult;
 import cloud.commandframework.arguments.parser.ParserParameters;
-import cloud.commandframework.context.CommandContext;
 import cloud.commandframework.paper.PaperCommandManager;
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
+import java.util.Collection;
 import org.bukkit.command.CommandSender;
-import org.checkerframework.checker.nullness.qual.NonNull;
-import org.jetbrains.annotations.NotNull;
-import tc.oc.pgm.api.PGM;
-import tc.oc.pgm.api.match.Match;
 import tc.oc.pgm.classes.ClassMatchModule;
 import tc.oc.pgm.classes.PlayerClass;
-import tc.oc.pgm.command.util.CommandKeys;
-import tc.oc.pgm.util.LiquidMetal;
-import tc.oc.pgm.util.StringUtils;
+import tc.oc.pgm.util.text.TextException;
 
-public final class PlayerClassParser extends StringLikeParser<CommandSender, PlayerClass> {
+public final class PlayerClassParser extends MatchObjectParser<PlayerClass, ClassMatchModule> {
 
   public PlayerClassParser(PaperCommandManager<CommandSender> manager, ParserParameters options) {
-    super(manager, options);
+    super(manager, options, PlayerClass.class, ClassMatchModule.class, "classes");
   }
 
   @Override
-  public ArgumentParseResult<PlayerClass> parse(
-      @NotNull CommandContext<CommandSender> context, @NotNull String text) {
-    Match match = PGM.get().getMatchManager().getMatch(context.getSender());
-    if (match == null) return failure(playerOnly());
-
-    ClassMatchModule classes = match.getModule(ClassMatchModule.class);
-    if (classes == null) return failure(exception("match.class.notEnabled"));
-
-    PlayerClass playerClass = StringUtils.bestFuzzyMatch(text, classes.getClasses());
-    if (playerClass == null) return failure(exception("match.class.notFound"));
-
-    return ArgumentParseResult.success(playerClass);
+  protected Collection<PlayerClass> objects(ClassMatchModule module) {
+    return module.getClasses();
   }
 
   @Override
-  public @NonNull List<@NonNull String> suggestions(
-      @NonNull CommandContext<CommandSender> context, @NonNull String input) {
-    Match match = PGM.get().getMatchManager().getMatch(context.getSender());
-    if (match == null) return Collections.emptyList();
-
-    List<String> inputQueue = context.get(CommandKeys.INPUT_QUEUE);
-    String text = StringUtils.getText(inputQueue);
-    String mustKeep = StringUtils.getMustKeepText(inputQueue);
+  protected String getName(PlayerClass obj) {
+    return obj.getName();
+  }
 
-    return match.moduleOptional(ClassMatchModule.class).map(ClassMatchModule::getClasses)
-        .orElse(Collections.emptySet()).stream()
-        .map(PlayerClass::getName)
-        .filter(name -> LiquidMetal.match(name, text))
-        .map(name -> StringUtils.getSuggestion(name, mustKeep))
-        .collect(Collectors.toList());
+  @Override
+  protected TextException moduleNotFound() {
+    return exception("match.class.notEnabled");
   }
 }
diff --git a/core/src/main/java/tc/oc/pgm/command/parsers/TeamParser.java b/core/src/main/java/tc/oc/pgm/command/parsers/TeamParser.java
index bb866ad58c..6d3f264d41 100644
--- a/core/src/main/java/tc/oc/pgm/command/parsers/TeamParser.java
+++ b/core/src/main/java/tc/oc/pgm/command/parsers/TeamParser.java
@@ -1,69 +1,33 @@
 package tc.oc.pgm.command.parsers;
 
-import static cloud.commandframework.arguments.parser.ArgumentParseResult.failure;
-import static cloud.commandframework.arguments.parser.ArgumentParseResult.success;
 import static tc.oc.pgm.util.text.TextException.exception;
-import static tc.oc.pgm.util.text.TextException.invalidFormat;
-import static tc.oc.pgm.util.text.TextException.playerOnly;
 
-import cloud.commandframework.arguments.parser.ArgumentParseResult;
 import cloud.commandframework.arguments.parser.ParserParameters;
-import cloud.commandframework.context.CommandContext;
 import cloud.commandframework.paper.PaperCommandManager;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
+import java.util.Collection;
 import org.bukkit.command.CommandSender;
-import org.checkerframework.checker.nullness.qual.NonNull;
-import org.jetbrains.annotations.NotNull;
-import tc.oc.pgm.api.PGM;
-import tc.oc.pgm.api.match.Match;
 import tc.oc.pgm.teams.Team;
 import tc.oc.pgm.teams.TeamMatchModule;
-import tc.oc.pgm.util.LiquidMetal;
+import tc.oc.pgm.util.text.TextException;
 
-public final class TeamParser extends StringLikeParser<CommandSender, Team> {
+public final class TeamParser extends MatchObjectParser<Team, TeamMatchModule> {
 
   public TeamParser(PaperCommandManager<CommandSender> manager, ParserParameters options) {
-    super(manager, options);
+    super(manager, options, Team.class, TeamMatchModule.class, "teams");
   }
 
   @Override
-  public ArgumentParseResult<Team> parse(
-      @NotNull CommandContext<CommandSender> context, @NotNull String text) {
-    final Match match = PGM.get().getMatchManager().getMatch(context.getSender());
-    if (match == null) return failure(playerOnly());
-
-    return getTeam(match, text);
+  protected Collection<Team> objects(TeamMatchModule module) {
+    return module.getParticipatingTeams();
   }
 
   @Override
-  public @NonNull List<@NonNull String> suggestions(
-      @NonNull CommandContext<CommandSender> context, @NonNull String input) {
-    return getTeams(context.getSender())
-        .filter(str -> LiquidMetal.match(str, input))
-        .collect(Collectors.toList());
-  }
-
-  public static ArgumentParseResult<Team> getTeam(Match match, String text) {
-    final TeamMatchModule teams = match.getModule(TeamMatchModule.class);
-    if (teams == null) return failure(exception("command.noTeams"));
-
-    final Team team = teams.bestFuzzyMatch(text);
-    if (team == null) return failure(invalidFormat(text, Team.class, null));
-
-    return success(team);
+  protected String getName(Team obj) {
+    return obj.getNameLegacy().replace(" ", "");
   }
 
-  public static Stream<String> getTeams(CommandSender sender) {
-    final Match match = PGM.get().getMatchManager().getMatch(sender);
-    if (match == null) return Stream.empty();
-
-    TeamMatchModule tmm = match.getModule(TeamMatchModule.class);
-    if (tmm == null) return Stream.empty();
-
-    return tmm.getParticipatingTeams().stream()
-        .map(Team::getNameLegacy)
-        .map(name -> name.replace(" ", ""));
+  @Override
+  protected TextException moduleNotFound() {
+    return exception("command.noTeams");
   }
 }
diff --git a/core/src/main/java/tc/oc/pgm/command/parsers/TeamsParser.java b/core/src/main/java/tc/oc/pgm/command/parsers/TeamsParser.java
index 90d452646b..8bad5185c3 100644
--- a/core/src/main/java/tc/oc/pgm/command/parsers/TeamsParser.java
+++ b/core/src/main/java/tc/oc/pgm/command/parsers/TeamsParser.java
@@ -12,8 +12,6 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 import org.bukkit.command.CommandSender;
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.jetbrains.annotations.NotNull;
@@ -21,12 +19,15 @@
 import tc.oc.pgm.api.match.Match;
 import tc.oc.pgm.teams.Team;
 import tc.oc.pgm.teams.TeamMatchModule;
-import tc.oc.pgm.util.LiquidMetal;
 
+/** Parses teams, supporting * for all teams */
 public final class TeamsParser extends StringLikeParser<CommandSender, Collection<Team>> {
 
+  private final TeamParser teamParser;
+
   public TeamsParser(PaperCommandManager<CommandSender> manager, ParserParameters options) {
     super(manager, options);
+    this.teamParser = new TeamParser(manager, options);
   }
 
   @Override
@@ -41,14 +42,14 @@ public ArgumentParseResult<Collection<Team>> parse(
       return success(teams.getTeams());
     }
 
-    return TeamParser.getTeam(match, text).mapParsedValue(Collections::singleton);
+    return teamParser.parse(context, text).mapParsedValue(Collections::singleton);
   }
 
   @Override
   public @NonNull List<@NonNull String> suggestions(
       @NonNull CommandContext<CommandSender> context, @NonNull String input) {
-    return Stream.concat(Stream.of("*"), TeamParser.getTeams(context.getSender()))
-        .filter(str -> LiquidMetal.match(str, input))
-        .collect(Collectors.toList());
+    List<String> teams = teamParser.suggestions(context, input);
+    if ("*".startsWith(input)) teams.add("*");
+    return teams;
   }
 }
diff --git a/core/src/main/java/tc/oc/pgm/command/util/CommandGraph.java b/core/src/main/java/tc/oc/pgm/command/util/CommandGraph.java
index baba360a90..d4bc5234cb 100644
--- a/core/src/main/java/tc/oc/pgm/command/util/CommandGraph.java
+++ b/core/src/main/java/tc/oc/pgm/command/util/CommandGraph.java
@@ -86,6 +86,7 @@
 import tc.oc.pgm.command.parsers.MapInfoParser;
 import tc.oc.pgm.command.parsers.MapPoolParser;
 import tc.oc.pgm.command.parsers.MatchPlayerParser;
+import tc.oc.pgm.command.parsers.ModeParser;
 import tc.oc.pgm.command.parsers.PartyParser;
 import tc.oc.pgm.command.parsers.PlayerClassParser;
 import tc.oc.pgm.command.parsers.RotationParser;
@@ -96,6 +97,7 @@
 import tc.oc.pgm.community.command.ModerationCommand;
 import tc.oc.pgm.community.command.ReportCommand;
 import tc.oc.pgm.listeners.ChatDispatcher;
+import tc.oc.pgm.modes.Mode;
 import tc.oc.pgm.rotation.MapPoolManager;
 import tc.oc.pgm.rotation.pools.MapPool;
 import tc.oc.pgm.rotation.pools.MapPoolType;
@@ -277,6 +279,7 @@ private void setupParsers() {
     registerParser(Team.class, TeamParser::new);
     registerParser(TypeFactory.parameterizedClass(Collection.class, Team.class), TeamsParser::new);
     registerParser(PlayerClass.class, PlayerClassParser::new);
+    registerParser(Mode.class, ModeParser::new);
     registerParser(
         TypeFactory.parameterizedClass(Optional.class, VictoryCondition.class),
         new VictoryConditionParser());
diff --git a/core/src/main/java/tc/oc/pgm/features/SelfIdentifyingFeatureDefinition.java b/core/src/main/java/tc/oc/pgm/features/SelfIdentifyingFeatureDefinition.java
index a9b16aa4a4..11bdfdca10 100644
--- a/core/src/main/java/tc/oc/pgm/features/SelfIdentifyingFeatureDefinition.java
+++ b/core/src/main/java/tc/oc/pgm/features/SelfIdentifyingFeatureDefinition.java
@@ -1,5 +1,8 @@
 package tc.oc.pgm.features;
 
+import java.text.Normalizer;
+import java.util.Locale;
+import org.bukkit.ChatColor;
 import org.jetbrains.annotations.Nullable;
 import tc.oc.pgm.api.feature.FeatureDefinition;
 import tc.oc.pgm.api.feature.FeatureInfo;
@@ -39,6 +42,8 @@ public static String makeTypeName(Class<? extends FeatureDefinition> type) {
   }
 
   public static String makeId(String text) {
-    return text.toLowerCase().replaceAll("\\s+", "-");
+    return Normalizer.normalize(ChatColor.stripColor(text), Normalizer.Form.NFD)
+        .toLowerCase(Locale.ROOT)
+        .replaceAll("\\s+", "-");
   }
 }
diff --git a/core/src/main/java/tc/oc/pgm/modes/Mode.java b/core/src/main/java/tc/oc/pgm/modes/Mode.java
index 57a06729b5..1cbdc086df 100644
--- a/core/src/main/java/tc/oc/pgm/modes/Mode.java
+++ b/core/src/main/java/tc/oc/pgm/modes/Mode.java
@@ -3,13 +3,16 @@
 import static net.kyori.adventure.text.Component.text;
 
 import java.time.Duration;
+import java.util.concurrent.atomic.AtomicInteger;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.material.MaterialData;
 import org.jetbrains.annotations.Nullable;
+import tc.oc.pgm.api.feature.FeatureInfo;
 import tc.oc.pgm.api.filter.Filter;
 import tc.oc.pgm.features.SelfIdentifyingFeatureDefinition;
 
+@FeatureInfo(name = "mode")
 public class Mode extends SelfIdentifyingFeatureDefinition {
   private final MaterialData material;
   private final Duration after;
@@ -40,6 +43,11 @@ public Mode(
     this.showBefore = showBefore;
   }
 
+  @Override
+  protected String getDefaultId() {
+    return makeDefaultId() + "--" + makeId(legacyName);
+  }
+
   public MaterialData getMaterialData() {
     return this.material;
   }
@@ -71,4 +79,8 @@ public Duration getShowBefore() {
   public @Nullable String getName() {
     return this.name;
   }
+
+  public static String makeDefaultId(@Nullable String name, AtomicInteger serial) {
+    return "--" + makeTypeName(Mode.class) + "-" + makeId(name);
+  }
 }
diff --git a/core/src/main/java/tc/oc/pgm/modes/ObjectiveModesMatchModule.java b/core/src/main/java/tc/oc/pgm/modes/ObjectiveModesMatchModule.java
index 011dfb49f2..8d9df3b0c6 100644
--- a/core/src/main/java/tc/oc/pgm/modes/ObjectiveModesMatchModule.java
+++ b/core/src/main/java/tc/oc/pgm/modes/ObjectiveModesMatchModule.java
@@ -44,11 +44,11 @@ public class ObjectiveModesMatchModule implements MatchModule, Listener {
                   .thenComparing(Mode::getLegacyName));
 
   private final Match match;
-  private final List<Mode> modes;
+  private final ImmutableList<Mode> modes;
   private final List<ModeChangeCountdown> countdowns;
   private final CountdownContext countdownContext;
 
-  public ObjectiveModesMatchModule(Match match, List<Mode> modes) {
+  public ObjectiveModesMatchModule(Match match, ImmutableList<Mode> modes) {
     this.match = match;
     this.modes = modes;
     this.countdowns = new ArrayList<>(this.modes.size());
@@ -91,6 +91,10 @@ public void disable() {
     }
   }
 
+  public ImmutableList<Mode> getModes() {
+    return modes;
+  }
+
   public CountdownContext getCountdown() {
     return this.countdownContext;
   }
@@ -115,6 +119,10 @@ public List<ModeChangeCountdown> getActiveCountdowns() {
         .collect(Collectors.toList());
   }
 
+  public ModeChangeCountdown getCountdown(Mode mode) {
+    return this.countdowns.stream().filter(mcc -> mcc.getMode() == mode).findFirst().orElse(null);
+  }
+
   @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
   public void onObjectiveModeChange(ObjectiveModeChangeEvent event) {
     if (event.isVisible()) {
diff --git a/core/src/main/java/tc/oc/pgm/modes/ObjectiveModesModule.java b/core/src/main/java/tc/oc/pgm/modes/ObjectiveModesModule.java
index cd449f30ee..277bc0d1b7 100644
--- a/core/src/main/java/tc/oc/pgm/modes/ObjectiveModesModule.java
+++ b/core/src/main/java/tc/oc/pgm/modes/ObjectiveModesModule.java
@@ -4,9 +4,7 @@
 
 import com.google.common.collect.ImmutableList;
 import java.time.Duration;
-import java.util.ArrayList;
 import java.util.Collection;
-import java.util.List;
 import java.util.logging.Logger;
 import org.bukkit.ChatColor;
 import org.bukkit.material.MaterialData;
@@ -19,6 +17,7 @@
 import tc.oc.pgm.api.map.factory.MapModuleFactory;
 import tc.oc.pgm.api.match.Match;
 import tc.oc.pgm.api.match.MatchModule;
+import tc.oc.pgm.features.FeatureDefinitionContext;
 import tc.oc.pgm.filters.FilterMatchModule;
 import tc.oc.pgm.filters.parse.DynamicFilterValidation;
 import tc.oc.pgm.goals.GoalMatchModule;
@@ -29,10 +28,10 @@
 
 public class ObjectiveModesModule implements MapModule {
 
-  private List<Mode> modes;
+  private final ImmutableList<Mode> modes;
   public static final Duration DEFAULT_SHOW_BEFORE = Duration.ofSeconds(60L);
 
-  private ObjectiveModesModule(List<Mode> modes) {
+  private ObjectiveModesModule(ImmutableList<Mode> modes) {
     this.modes = modes;
   }
 
@@ -60,7 +59,7 @@ public ObjectiveModesModule parse(MapFactory factory, Logger logger, Document do
         return null;
       }
 
-      List<Mode> parsedModes = new ArrayList<>();
+      ImmutableList.Builder<Mode> parsedModes = ImmutableList.builder();
 
       if (doc.getRootElement().getChild("modes") == null) {
         return null;
@@ -88,15 +87,30 @@ public ObjectiveModesModule parse(MapFactory factory, Logger logger, Document do
 
         // Legacy
         boolean legacyShowBossBar = XMLUtils.parseBoolean(modeEl.getAttribute("boss-bar"), true);
-        if (!legacyShowBossBar) {
-          showBefore = Duration.ZERO;
+        if (!legacyShowBossBar) showBefore = Duration.ZERO;
+
+        // Autogenerate a unique id, required for /mode start
+        if (id == null) {
+          String legacyName = name != null ? name : ModeUtils.formatMaterial(material);
+          id = makeUniqueId(legacyName, factory.getFeatures());
         }
+
         Mode mode = new Mode(id, material, after, filter, name, showBefore);
         parsedModes.add(mode);
         factory.getFeatures().addFeature(modeEl, mode);
       }
 
-      return new ObjectiveModesModule(parsedModes);
+      return new ObjectiveModesModule(parsedModes.build());
+    }
+
+    private String makeUniqueId(String name, FeatureDefinitionContext features) {
+      String baseId = "mode-" + Mode.makeId(name);
+      if (!features.contains(baseId)) return baseId;
+
+      for (int i = 2; ; i++) {
+        String newId = baseId + "-" + i;
+        if (!features.contains(newId)) return newId;
+      }
     }
   }
 }
diff --git a/util/src/main/i18n/templates/misc.properties b/util/src/main/i18n/templates/misc.properties
index 7a99ffc4ed..e1d07f83b1 100644
--- a/util/src/main/i18n/templates/misc.properties
+++ b/util/src/main/i18n/templates/misc.properties
@@ -260,6 +260,10 @@ type.uri = url
 
 type.team = team
 
+type.playerclass = class
+
+type.mode = mode
+
 type.settingkey = setting
 
 type.uuid = uuid
diff --git a/util/src/main/java/tc/oc/pgm/util/StringUtils.java b/util/src/main/java/tc/oc/pgm/util/StringUtils.java
index e64823ec4b..0ca7ba9e26 100644
--- a/util/src/main/java/tc/oc/pgm/util/StringUtils.java
+++ b/util/src/main/java/tc/oc/pgm/util/StringUtils.java
@@ -87,15 +87,22 @@ public static <T> T bestMultiFuzzyMatch(
     return bestScore < 0.75 ? null : bestObj;
   }
 
-  public static String getSuggestion(String suggestion, String input) {
+  public static String getSuggestion(String suggestion, String mustKeep) {
     // At least one of the two has no spaces, algorithm isn't needed.
-    if (input.length() > 1 && suggestion.contains(SPACE)) {
-      int matchIdx = LiquidMetal.getIndexOf(suggestion, input);
-
-      // Should never happen!
-      if (matchIdx == -1)
-        throw new IllegalStateException(
-            "Suggestion is not matched by input! '" + suggestion + "', '" + input + "'");
+    if (mustKeep.length() > 1 && suggestion.contains(SPACE)) {
+      int matchIdx = LiquidMetal.getIndexOf(suggestion, mustKeep);
+
+      // Bad case, this can happen when input was normalized before search
+      if (matchIdx == -1) {
+        int normalizedMatch = LiquidMetal.getIndexOf(suggestion, StringUtils.normalize(mustKeep));
+
+        // We found something, keep up until the end of the word, to compensate for removed chars in normalization.
+        // This is FAR from ideal, but it's the edge-case of an edge-case.
+        if (normalizedMatch != -1) {
+          int nextWordEnd = suggestion.indexOf(" ", normalizedMatch + 1);
+          matchIdx = nextWordEnd != -1 ? nextWordEnd : normalizedMatch;
+        }
+      }
 
       suggestion = suggestion.substring(matchIdx + 1);
     }
diff --git a/util/src/main/java/tc/oc/pgm/util/text/TextException.java b/util/src/main/java/tc/oc/pgm/util/text/TextException.java
index 6f34313e99..19c71b3385 100644
--- a/util/src/main/java/tc/oc/pgm/util/text/TextException.java
+++ b/util/src/main/java/tc/oc/pgm/util/text/TextException.java
@@ -98,6 +98,6 @@ private static Component format(Range<?> range) {
   }
 
   private static Component format(Class<?> type) {
-    return translatable("type." + type.getSimpleName().toLowerCase());
+    return translatable("type." + type.getSimpleName().toLowerCase(Locale.ROOT));
   }
 }