diff --git a/src/agent/agent.js b/src/agent/agent.js
index 87a0d2f..7935894 100644
--- a/src/agent/agent.js
+++ b/src/agent/agent.js
@@ -14,83 +14,142 @@ import settings from '../../settings.js';
 
 export class Agent {
     async start(profile_fp, load_mem=false, init_message=null, count_id=0) {
-        this.actions = new ActionManager(this);
-        this.prompter = new Prompter(this, profile_fp);
-        this.name = this.prompter.getName();
-        this.history = new History(this);
-        this.coder = new Coder(this);
-        this.npc = new NPCContoller(this);
-        this.memory_bank = new MemoryBank();
-        this.self_prompter = new SelfPrompter(this);
+        try {
+            // Initialize components with error handling
+            this.actions = new ActionManager(this);
+            this.prompter = new Prompter(this, profile_fp);
+            this.name = this.prompter.getName();
+            this.history = new History(this);
+            this.coder = new Coder(this);
+            this.npc = new NPCContoller(this);
+            this.memory_bank = new MemoryBank();
+            this.self_prompter = new SelfPrompter(this);
 
-        await this.prompter.initExamples();
+            try {
+                await this.prompter.initExamples();
+            } catch (error) {
+                console.error('Failed to initialize examples:', error);
+                throw error;
+            }
 
-        console.log('Logging into minecraft...');
-        this.bot = initBot(this.name);
+            console.log('Logging into minecraft...');
+            try {
+                this.bot = initBot(this.name);
+            } catch (error) {
+                console.error('Failed to initialize Minecraft bot:', error);
+                throw error;
+            }
 
-        initModes(this);
+            initModes(this);
 
-        let save_data = null;
-        if (load_mem) {
-            save_data = this.history.load();
+            let save_data = null;
+            if (load_mem) {
+                try {
+                    save_data = this.history.load();
+                } catch (error) {
+                    console.error('Failed to load history:', error);
+                    // Don't throw here, continue without history
+                }
+            }
+
+            // Return a promise that resolves when spawn is complete
+            return new Promise((resolve, reject) => {
+                // Add timeout to prevent hanging
+                const spawnTimeout = setTimeout(() => {
+                    reject(new Error('Bot spawn timed out after 30 seconds'));
+                }, 30000);
+
+                this.bot.once('error', (error) => {
+                    clearTimeout(timeout);
+                    console.error('Bot encountered error:', error);
+                    reject(error);
+                });
+
+                this.bot.on('login', () => {
+                    console.log('Logged in!');
+                });
+
+                this.bot.once('spawn', async () => {
+                    try {
+                        clearTimeout(spawnTimeout);
+                        addViewer(this.bot, count_id);
+
+                        // wait for a bit so stats are not undefined
+                        await new Promise((resolve) => setTimeout(resolve, 1000));
+
+                        console.log(`${this.name} spawned.`);
+                        this.clearBotLogs();
+                        
+                        this._setupEventHandlers(save_data, init_message);
+                        this.startEvents();
+                        resolve();
+                    } catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        } catch (error) {
+            console.error('Failed to start agent:', error);
+            throw error; // Re-throw to be caught by init-agent.js
         }
+    }
 
-        this.bot.on('login', () => {
-            console.log('Logged in!');
-        });
-
-        this.bot.once('spawn', async () => {
-            addViewer(this.bot, count_id);
-
-            // wait for a bit so stats are not undefined
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-
-            console.log(`${this.name} spawned.`);
-            this.clearBotLogs();
-            
-            const ignore_messages = [
-                "Set own game mode to",
-                "Set the time to",
-                "Set the difficulty to",
-                "Teleported ",
-                "Set the weather to",
-                "Gamerule "
-            ];
-            const eventname = settings.profiles.length > 1 ? 'whisper' : 'chat';
-            this.bot.on(eventname, async (username, message) => {
+    // Split out event handler setup for clarity
+    _setupEventHandlers(save_data, init_message) {
+        const ignore_messages = [
+            "Set own game mode to",
+            "Set the time to",
+            "Set the difficulty to",
+            "Teleported ",
+            "Set the weather to",
+            "Gamerule "
+        ];
+        
+        const eventname = settings.profiles.length > 1 ? 'whisper' : 'chat';
+        this.bot.on(eventname, async (username, message) => {
+            try {
                 if (username === this.name) return;
                 
                 if (ignore_messages.some((m) => message.startsWith(m))) return;
 
                 this.shut_up = false;
-    
-                this.handleMessage(username, message);
-            });
+                await this.handleMessage(username, message);
+            } catch (error) {
+                console.error('Error handling message:', error);
+            }
+        });
 
-            // set the bot to automatically eat food when hungry
-            this.bot.autoEat.options = {
-                priority: 'foodPoints',
-                startAt: 14,
-                bannedFood: ["rotten_flesh", "spider_eye", "poisonous_potato", "pufferfish", "chicken"]
-            };
+        // Set up auto-eat
+        this.bot.autoEat.options = {
+            priority: 'foodPoints',
+            startAt: 14,
+            bannedFood: ["rotten_flesh", "spider_eye", "poisonous_potato", "pufferfish", "chicken"]
+        };
 
-            if (save_data && save_data.self_prompt) { // if we're loading memory and self-prompting was on, restart it, ignore init_message
+        // Handle startup conditions
+        this._handleStartupConditions(save_data, init_message);
+    }
+
+    async _handleStartupConditions(save_data, init_message) {
+        try {
+            if (save_data?.self_prompt) {
                 let prompt = save_data.self_prompt;
                 // add initial message to history
                 this.history.add('system', prompt);
-                this.self_prompter.start(prompt);
+                await this.self_prompter.start(prompt);
             }
             else if (init_message) {
-                this.handleMessage('system', init_message, 2);
+                await this.handleMessage('system', init_message, 2);
             }
             else {
                 const translation = await handleTranslation("Hello world! I am "+this.name);
                 this.bot.chat(translation);
                 this.bot.emit('finished_executing');
             }
-
-            this.startEvents();
-        });
+        } catch (error) {
+            console.error('Error handling startup conditions:', error);
+            throw error;
+        }
     }
 
     requestInterrupt() {
diff --git a/src/agent/history.js b/src/agent/history.js
index a24f421..bfba278 100644
--- a/src/agent/history.js
+++ b/src/agent/history.js
@@ -1,4 +1,4 @@
-import { writeFileSync, readFileSync, mkdirSync } from 'fs';
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from 'fs';
 import { NPCData } from './npc/data.js';
 import settings from '../../settings.js';
 
@@ -78,50 +78,36 @@ export class History {
         }
     }
 
-    save() {
-        // save history object to json file
-        let data = {
-            'name': this.name,
-            'memory': this.memory,
-            'turns': this.turns
-        };
-        if (this.agent.npc.data !== null)
-            data.npc = this.agent.npc.data.toObject();
-        const modes = this.agent.bot.modes.getJson();
-        if (modes !== null)
-            data.modes = modes;
-        const memory_bank = this.agent.memory_bank.getJson();
-        if (memory_bank !== null)
-            data.memory_bank = memory_bank;
-        if (this.agent.self_prompter.on) {
-            data.self_prompt = this.agent.self_prompter.prompt;
+    async save() {
+        try {
+            const data = {
+                memory: this.memory,
+                turns: this.turns,
+                self_prompt: this.agent.self_prompter.on ? this.agent.self_prompter.prompt : null
+            };
+            writeFileSync(this.memory_fp, JSON.stringify(data, null, 2));
+            console.log('Saved memory to:', this.memory_fp);
+        } catch (error) {
+            console.error('Failed to save history:', error);
+            throw error;
         }
-        const json_data = JSON.stringify(data, null, 4);
-        writeFileSync(this.memory_fp, json_data, (err) => {
-            if (err) {
-                throw err;
-            }
-            console.log("JSON data is saved.");
-        });
     }
 
     load() {
         try {
-            // load history object from json file
-            const data = readFileSync(this.memory_fp, 'utf8');
-            const obj = JSON.parse(data);
-            this.memory = obj.memory;
-            this.agent.npc.data = NPCData.fromObject(obj.npc);
-            if (obj.modes)
-                this.agent.bot.modes.loadJson(obj.modes);
-            if (obj.memory_bank)
-                this.agent.memory_bank.loadJson(obj.memory_bank);
-            this.turns = obj.turns;
-            return obj;
-        } catch (err) {
-            console.error(`Error reading ${this.name}'s memory file: ${err.message}`);
+            if (!existsSync(this.memory_fp)) {
+                console.log('No memory file found.');
+                return null;
+            }
+            const data = JSON.parse(readFileSync(this.memory_fp, 'utf8'));
+            this.memory = data.memory || '';
+            this.turns = data.turns || [];
+            console.log('Loaded memory:', this.memory);
+            return data;
+        } catch (error) {
+            console.error('Failed to load history:', error);
+            throw error;
         }
-        return null;
     }
 
     clear() {
diff --git a/src/agent/prompter.js b/src/agent/prompter.js
index 03fd6a1..68af6d3 100644
--- a/src/agent/prompter.js
+++ b/src/agent/prompter.js
@@ -102,7 +102,7 @@ export class Prompter {
         mkdirSync(`./bots/${name}`, { recursive: true });
         writeFileSync(`./bots/${name}/last_profile.json`, JSON.stringify(this.profile, null, 4), (err) => {
             if (err) {
-                throw err;
+                throw new Error('Failed to save profile:', err);
             }
             console.log("Copy profile saved.");
         });
@@ -117,15 +117,28 @@ export class Prompter {
     }
 
     async initExamples() {
-        // Using Promise.all to implement concurrent processing
-        // Create Examples instances
-        this.convo_examples = new Examples(this.embedding_model);
-        this.coding_examples = new Examples(this.embedding_model);
-        // Use Promise.all to load examples concurrently
-        await Promise.all([
-            this.convo_examples.load(this.profile.conversation_examples),
-            this.coding_examples.load(this.profile.coding_examples),
-        ]);
+        try {
+            this.convo_examples = new Examples(this.embedding_model);
+            this.coding_examples = new Examples(this.embedding_model);
+            
+            const [convoResult, codingResult] = await Promise.allSettled([
+                this.convo_examples.load(this.profile.conversation_examples),
+                this.coding_examples.load(this.profile.coding_examples)
+            ]);
+
+            // Handle potential failures
+            if (convoResult.status === 'rejected') {
+                console.error('Failed to load conversation examples:', convoResult.reason);
+                throw convoResult.reason;
+            }
+            if (codingResult.status === 'rejected') {
+                console.error('Failed to load coding examples:', codingResult.reason);
+                throw codingResult.reason;
+            }
+        } catch (error) {
+            console.error('Failed to initialize examples:', error);
+            throw error;
+        }
     }
 
     async replaceStrings(prompt, messages, examples=null, to_summarize=[], last_goals=null) {
diff --git a/src/process/init-agent.js b/src/process/init-agent.js
index 81c3ce1..5a08185 100644
--- a/src/process/init-agent.js
+++ b/src/process/init-agent.js
@@ -1,6 +1,13 @@
 import { Agent } from '../agent/agent.js';
 import yargs from 'yargs';
 
+// Add global unhandled rejection handler
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise);
+    console.error('Reason:', reason);
+    process.exit(1);
+});
+
 const args = process.argv.slice(2);
 if (args.length < 1) {
     console.log('Usage: node init_agent.js <agent_name> [profile] [load_memory] [init_message]');
@@ -28,6 +35,15 @@ const argv = yargs(args)
         type: 'number',
         default: 0,
         description: 'identifying count for multi-agent scenarios',
-    }).argv
+    }).argv;
 
-new Agent().start(argv.profile, argv.load_memory, argv.init_message, argv.count_id);
+// Wrap agent start in async IIFE with proper error handling
+(async () => {
+    try {
+        const agent = new Agent();
+        await agent.start(argv.profile, argv.load_memory, argv.init_message, argv.count_id);
+    } catch (error) {
+        console.error('Failed to start agent:', error);
+        process.exit(1);
+    }
+})();