Index: source/simulation2/components/CCmpAIManager.cpp
===================================================================
--- source/simulation2/components/CCmpAIManager.cpp
+++ source/simulation2/components/CCmpAIManager.cpp
@@ -147,8 +147,11 @@
 			m_ScriptInterface->Eval(L"({})", &settings);
 			m_ScriptInterface->SetProperty(settings, "player", m_Player, false);
 			m_ScriptInterface->SetProperty(settings, "difficulty", m_Difficulty, false);
-			ENSURE(m_Worker.m_HasLoadedEntityTemplates);
-			m_ScriptInterface->SetProperty(settings, "templates", m_Worker.m_EntityTemplates, false);
+			if (!m_UseSharedComponent)
+			{
+				ENSURE(m_Worker.m_HasLoadedEntityTemplates);
+				m_ScriptInterface->SetProperty(settings, "templates", m_Worker.m_EntityTemplates, false);
+			}
 
 			JS::AutoValueVector argv(cx);
 			argv.append(settings.get());
@@ -239,6 +242,8 @@
 		JS_RemoveExtraGCRootsTracer(m_ScriptInterface->GetJSRuntime(), Trace, this);
 	}
 
+	bool HasLoadedEntityTemplates() const { return m_HasLoadedEntityTemplates; }
+
 	bool LoadScripts(const std::wstring& moduleName)
 	{
 		// Ignore modules that are already loaded
@@ -950,9 +955,8 @@
 class CCmpAIManager : public ICmpAIManager
 {
 public:
-	static void ClassInit(CComponentManager& componentManager)
+	static void ClassInit(CComponentManager& UNUSED(componentManager))
 	{
-		componentManager.SubscribeToMessageType(MT_ProgressiveLoad);
 	}
 
 	DEFAULT_COMPONENT_ALLOCATOR(AIManager)
@@ -967,8 +971,6 @@
 		m_TerritoriesDirtyID = 0;
 		m_TerritoriesDirtyBlinkingID = 0;
 		m_JustDeserialized = false;
-
-		StartLoadEntityTemplates();
 	}
 
 	virtual void Deinit()
@@ -994,38 +996,17 @@
 		u32 numAis;
 		deserialize.NumberU32_Unbounded("num ais", numAis);
 		if (numAis > 0)
-			ForceLoadEntityTemplates();
+			LoadUsedEntityTemplates();
 
 		m_Worker.Deserialize(deserialize.GetStream(), numAis);
 
 		m_JustDeserialized = true;
 	}
 
-	virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
-	{
-		switch (msg.GetType())
-		{
-		case MT_ProgressiveLoad:
-		{
-			const CMessageProgressiveLoad& msgData = static_cast<const CMessageProgressiveLoad&> (msg);
-
-			*msgData.total += (int)m_TemplateNames.size();
-
-			if (*msgData.progressed)
-				break;
-
-			if (ContinueLoadEntityTemplates())
-				*msgData.progressed = true;
-
-			*msgData.progress += (int)m_TemplateLoadedIdx;
-
-			break;
-		}
-		}
-	}
-
 	virtual void AddPlayer(const std::wstring& id, player_id_t player, u8 difficulty)
 	{
+		LoadUsedEntityTemplates();
+
 		m_Worker.AddPlayer(id, player, difficulty);
 
 		// AI players can cheat and see through FoW/SoD, since that greatly simplifies
@@ -1051,11 +1032,10 @@
 		CmpPtr<ICmpDataTemplateManager> cmpDataTemplateManager(GetSystemEntity());
 		ENSURE(cmpDataTemplateManager);
 
-		// Get the game state from AIInterface
 		JS::RootedValue techTemplates(cx);
 		cmpDataTemplateManager->GetAllTechs(&techTemplates);
-
 		m_Worker.RegisterTechTemplates(scriptInterface.WriteStructuredClone(techTemplates));
+
 		m_Worker.TryLoadSharedComponent(true);
 	}
 
@@ -1100,8 +1080,6 @@
 	{
 		PROFILE("AI setup");
 
-		ForceLoadEntityTemplates();
-
 		ScriptInterface& scriptInterface = GetSimContext().GetScriptInterface();
 		JSContext* cx = scriptInterface.GetContext();
 		JSAutoRequest rq(cx);
@@ -1183,51 +1161,34 @@
 	}
 
 private:
-	std::vector<std::string> m_TemplateNames;
-	size_t m_TemplateLoadedIdx;
-	std::vector<std::pair<std::string, const CParamNode*> > m_Templates;
 	size_t m_TerritoriesDirtyID;
 	size_t m_TerritoriesDirtyBlinkingID;
 
 	bool m_JustDeserialized;
 
-	void StartLoadEntityTemplates()
-	{
-		CmpPtr<ICmpTemplateManager> cmpTemplateManager(GetSystemEntity());
-		ENSURE(cmpTemplateManager);
-
-		m_TemplateNames = cmpTemplateManager->FindAllTemplates(false);
-		m_TemplateLoadedIdx = 0;
-		m_Templates.reserve(m_TemplateNames.size());
-	}
-
-	// Tries to load the next entity template. Returns true if we did some work.
-	bool ContinueLoadEntityTemplates()
+	/**
+	 * Load the templates of all entities on the map (called when adding a new AI player for a new game
+	 * or when deserializing)
+	 */
+	void LoadUsedEntityTemplates()
 	{
-		if (m_TemplateLoadedIdx >= m_TemplateNames.size())
-			return false;
+		if (m_Worker.HasLoadedEntityTemplates())
+			return;
 
 		CmpPtr<ICmpTemplateManager> cmpTemplateManager(GetSystemEntity());
 		ENSURE(cmpTemplateManager);
 
-		const CParamNode* node = cmpTemplateManager->GetTemplateWithoutValidation(m_TemplateNames[m_TemplateLoadedIdx]);
-		if (node)
-			m_Templates.emplace_back(m_TemplateNames[m_TemplateLoadedIdx], node);
-
-		m_TemplateLoadedIdx++;
-
-		// If this was the last template, send the data to the worker
-		if (m_TemplateLoadedIdx == m_TemplateNames.size())
-			m_Worker.LoadEntityTemplates(m_Templates);
-
-		return true;
-	}
-
-	void ForceLoadEntityTemplates()
-	{
-		while (ContinueLoadEntityTemplates())
-		{
+		std::unordered_set<std::string> templateNames = cmpTemplateManager->FindUsedTemplates();
+		std::vector<std::pair<std::string, const CParamNode*> > usedTemplates;
+		usedTemplates.reserve(templateNames.size());
+		for (const std::string name : templateNames)
+		{
+			const CParamNode* node = cmpTemplateManager->GetTemplateWithoutValidation(name);
+			if (node)
+				usedTemplates.emplace_back(name, node);
 		}
+		// Send the data to the worker
+		m_Worker.LoadEntityTemplates(usedTemplates);
 	}
 
 	void LoadPathfinderClasses(JS::HandleValue state)
Index: source/simulation2/components/CCmpTemplateManager.cpp
===================================================================
--- source/simulation2/components/CCmpTemplateManager.cpp
+++ source/simulation2/components/CCmpTemplateManager.cpp
@@ -114,6 +114,8 @@
 
 	virtual std::vector<std::string> FindAllTemplates(bool includeActors) const;
 
+	virtual std::unordered_set<std::string> FindUsedTemplates() const;
+
 	virtual std::vector<entity_id_t> GetEntitiesUsingTemplate(const std::string& templateName) const;
 
 private:
@@ -214,6 +216,14 @@
 	return m_templateLoader.FindTemplates("", true, templatesType);
 }
 
+std::unordered_set<std::string> CCmpTemplateManager::FindUsedTemplates() const
+{
+	std::unordered_set<std::string> usedTemplates;
+	for (const std::pair<entity_id_t, std::string>& p : m_LatestTemplates)
+	       	usedTemplates.insert(p.second);
+	return usedTemplates;
+}
+
 /**
  * Get the list of entities using the specified template
  */
Index: source/simulation2/components/ICmpTemplateManager.h
===================================================================
--- source/simulation2/components/ICmpTemplateManager.h
+++ source/simulation2/components/ICmpTemplateManager.h
@@ -20,6 +20,7 @@
 
 #include "simulation2/system/Interface.h"
 
+#include <unordered_set>
 #include <vector>
 
 /**
@@ -104,6 +105,12 @@
 	virtual std::vector<std::string> FindAllTemplates(bool includeActors) const = 0;
 
 	/**
+	 * Returns a list of strings that could be validly passed as @c templateName to LoadTemplate.
+	 * Intended for use by the AI manager.
+	 */
+	virtual std::unordered_set<std::string> FindUsedTemplates() const = 0;
+
+	/**
 	 * Permanently disable XML validation (intended solely for test cases).
 	 */
 	virtual void DisableValidation() = 0;