diff --git a/moly-mofa/src/lib.rs b/moly-mofa/src/lib.rs
index aa87f0eb..2926cfd7 100644
--- a/moly-mofa/src/lib.rs
+++ b/moly-mofa/src/lib.rs
@@ -2,7 +2,7 @@ use moly_protocol::open_ai::{
     ChatResponseData, ChoiceData, MessageData, Role, StopReason, UsageData,
 };
 use serde::{Deserialize, Deserializer, Serialize};
-use std::sync::mpsc::{self, channel};
+use std::sync::mpsc::{self, channel, Sender};
 use tokio::task::JoinHandle;
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -50,121 +50,130 @@ pub struct MofaResponseSearchAssistant {
     pub result: MofaResponseSearchAssistantResult,
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
-pub enum MofaAgent {
-    Example,
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Hash, Eq)]
+pub struct AgentId(pub String);
+
+impl AgentId {
+    pub fn new(agent_name: &str, server_address: &str) -> Self {
+        AgentId(format!("{}-{}", agent_name, server_address))
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum AgentType {
     Reasoner,
     SearchAssistant,
     ResearchScholar,
+    MakepadExpert,
 }
 
-impl MofaAgent {
-    pub fn name(&self) -> &str {
-        match self {
-            MofaAgent::Example => "Example Agent",
-            MofaAgent::Reasoner => "Reasoner Agent",
-            MofaAgent::SearchAssistant => "Search Assistant",
-            MofaAgent::ResearchScholar => "Research Scholar",
-        }
-    }
+#[derive(Debug, Default, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
+pub struct MofaServerId(pub String);
 
-    pub fn short_description(&self) -> &str {
-        match self {
-            MofaAgent::Example => "This is an example agent implemented by MoFa",
-            MofaAgent::Reasoner => "Helps to find good questions about any topic",
-            MofaAgent::SearchAssistant => "Your assistant to find information on the web",
-            MofaAgent::ResearchScholar => "Expert in academic research",
-        }
-    }
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MofaAgent {
+    pub id: AgentId,
+    pub name: String,
+    pub description: String,
+    pub agent_type: AgentType,
+    pub server_id: MofaServerId,
 }
 
-#[derive(Default)]
-pub struct MofaOptions {
-    pub address: Option<String>,
+impl MofaAgent {
+    /// Returns a dummy agent whenever the corresponding Agent cannot be found
+    /// (due to the server not being available, the server no longer providing the agent, etc.).
+    pub fn unknown() -> Self {
+        MofaAgent {
+            id: AgentId("unknown".to_string()),
+            name: "Inaccesible Agent".to_string(),
+            description: "This agent is not currently reachable, its information is not available".to_string(),
+            agent_type: AgentType::Reasoner,
+            server_id: MofaServerId("Unknown".to_string()),
+        }
+    }
 }
 
-pub enum TestServerResponse {
-    Success(String),
-    Failure(String),
+pub enum MofaServerResponse {
+    Connected(String, Vec<MofaAgent>),
+    Unavailable(String),
 }
 
 pub enum MofaAgentCommand {
-    SendTask(String, MofaAgent, mpsc::Sender<ChatResponse>),
+    SendTask(String, MofaAgent, Sender<ChatResponse>),
     CancelTask,
-    UpdateServerAddress(String),
-    TestServer(mpsc::Sender<TestServerResponse>),
+    FetchAgentsFromServer(Sender<MofaServerResponse>),
 }
 
-pub struct MofaBackend {
-    pub command_sender: mpsc::Sender<MofaAgentCommand>,
+#[derive(Clone, Debug)]
+pub struct MofaClient {
+    command_sender: Sender<MofaAgentCommand>,
+    pub address: String,
 }
 
-impl Default for MofaBackend {
-    fn default() -> Self {
-        Self::new()
-    }
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
+pub enum BackendType {
+    Local,
+    Remote,
 }
 
-const DEFAULT_MOFA_ADDRESS: &str = "http://localhost:8000";
+impl MofaClient {
+    pub fn cancel_task(&self) {
+        self.command_sender.send(MofaAgentCommand::CancelTask).unwrap();
+    }
 
-impl MofaBackend {
-    pub fn available_agents() -> Vec<MofaAgent> {
-        vec![
-            MofaAgent::Example,
-            // Keeping only one agent for now. We will revisit this later when MoFa is more stable.
+    pub fn fetch_agents(&self, tx: Sender<MofaServerResponse>) {
+        self.command_sender.send(MofaAgentCommand::FetchAgentsFromServer(tx)).unwrap();
+    }
 
-            // MofaAgent::Reasoner,
-            // MofaAgent::SearchAssistant,
-            // MofaAgent::ResearchScholar,
-        ]
+    pub fn send_message_to_agent(&self, agent: &MofaAgent, prompt: &String, tx: Sender<ChatResponse>) {
+        self.command_sender.send(MofaAgentCommand::SendTask(prompt.clone(), agent.clone(), tx)).unwrap();
     }
 
-    pub fn new() -> Self {
+    pub fn new(address: String) -> Self {
         if should_be_real() {
             let (command_sender, command_receiver) = channel();
-            let backend = Self { command_sender };
-
+            let address_clone = address.clone();
             std::thread::spawn(move || {
-                Self::main_loop(command_receiver);
+                Self::process_agent_commands(command_receiver, address_clone);
             });
 
-            backend
+            Self { command_sender, address }
         } else {
             Self::new_fake()
         }
     }
 
-    pub fn main_loop(command_receiver: mpsc::Receiver<MofaAgentCommand>) {
-        println!("MoFa backend started");
+    /// Handles the communication between the MofaClient and the MoFa server.
+    /// 
+    /// This function runs in a separate thread and processes commands received through the command channel.
+    /// 
+    /// The loop continues until the command channel is closed or an unrecoverable error occurs.
+    fn process_agent_commands(command_receiver: mpsc::Receiver<MofaAgentCommand>, address: String) {
         let rt = tokio::runtime::Runtime::new().unwrap();
         let mut current_request: Option<JoinHandle<()>> = None;
-        let mut options = MofaOptions::default();
 
-        loop {
-            match command_receiver.recv().unwrap() {
-                MofaAgentCommand::SendTask(task, _agent, tx) => {
+        while let Ok(command) = command_receiver.recv() {
+            match command {
+                MofaAgentCommand::SendTask(task, agent, tx) => {
                     if let Some(handle) = current_request.take() {
                         handle.abort();
                     }
+
                     let data = ChatRequest {
-                        model: "example".to_string(),
+                        model: agent.name,
                         messages: vec![MessageData {
                             role: Role::User,
                             content: task,
                         }],
                     };
                     let client = reqwest::Client::new();
-                    let url = options
-                        .address
-                        .clone()
-                        .unwrap_or(DEFAULT_MOFA_ADDRESS.to_string());
+
+                    let req = client
+                        .post(format!("{}/v1/chat/completions", &address))
+                        .json(&data);
+
                     current_request = Some(rt.spawn(async move {
-                        let resp = client
-                            .post(format!("{}/v1/chat/completions", url))
-                            .json(&data)
-                            .send()
-                            .await
-                            .expect("Failed to send request");
+                        let resp = req.send().await.expect("Failed to send request");
 
                         let resp: Result<ChatResponseData, reqwest::Error> = resp.json().await;
                         match resp {
@@ -183,14 +192,8 @@ impl MofaBackend {
                     }
                     continue;
                 }
-                MofaAgentCommand::UpdateServerAddress(address) => {
-                    options.address = Some(address);
-                }
-                MofaAgentCommand::TestServer(tx) => {
-                    let url = options
-                        .address
-                        .clone()
-                        .unwrap_or(DEFAULT_MOFA_ADDRESS.to_string());
+                MofaAgentCommand::FetchAgentsFromServer(tx) => {
+                    let url = address.clone();
                     let resp = reqwest::blocking::ClientBuilder::new()
                         .timeout(std::time::Duration::from_secs(5))
                         .no_proxy()
@@ -200,31 +203,38 @@ impl MofaBackend {
                         .send();
 
                     match resp {
-                        Ok(r) => {
-                            if r.status().is_success() {
-                                tx.send(TestServerResponse::Success(url)).unwrap();
-                            } else {
-                                tx.send(TestServerResponse::Failure(url)).unwrap();
-                            }
+                        Ok(r) if r.status().is_success() => {
+                            let agents = vec![
+                                MofaAgent {
+                                    id: AgentId::new("Reasoner", &url),
+                                    name: "Reasoner".to_string(),
+                                    description: "An agent that will help you find good questions about any topic".to_string(),
+                                    agent_type: AgentType::Reasoner,
+                                    server_id: MofaServerId(url.clone()),
+                                },
+                            ];
+                            tx.send(MofaServerResponse::Connected(url, agents)).unwrap();
                         }
-                        Err(e) => {
-                            tx.send(TestServerResponse::Failure(url)).unwrap();
-                            eprintln!("{e}");
+                        _ => {
+                            tx.send(MofaServerResponse::Unavailable(url)).unwrap();
                         }
-                    };
+                    }
                 }
             }
         }
+
+        // Clean up any pending request when the channel is closed
+        if let Some(handle) = current_request {
+            handle.abort();
+        }
     }
 
     // For testing purposes
     pub fn new_fake() -> Self {
         let (command_sender, command_receiver) = channel();
-        let backend = Self { command_sender };
-
+        
         std::thread::spawn(move || {
             loop {
-                // Receive command from frontend
                 match command_receiver.recv().unwrap() {
                     MofaAgentCommand::SendTask(_task, _agent, tx) => {
                         let data = ChatResponseData {
@@ -255,7 +265,7 @@ impl MofaBackend {
             }
         });
 
-        backend
+        Self { command_sender, address: "localhost:8000".to_string() }
     }
 }
 
@@ -273,8 +283,6 @@ pub enum ChatResponse {
     ChatFinalResponseData(ChatResponseData),
 }
 
-// ====
-
 #[derive(Clone, Debug, Serialize, Deserialize)]
 struct ChatRequest {
     model: String,
diff --git a/resources/images/circle_check_icon.png b/resources/images/circle_check_icon.png
new file mode 100644
index 00000000..c749dfd3
Binary files /dev/null and b/resources/images/circle_check_icon.png differ
diff --git a/resources/images/globe_icon.png b/resources/images/globe_icon.png
new file mode 100644
index 00000000..7b43a1fd
Binary files /dev/null and b/resources/images/globe_icon.png differ
diff --git a/resources/images/laptop_icon.png b/resources/images/laptop_icon.png
new file mode 100644
index 00000000..66a47c2f
Binary files /dev/null and b/resources/images/laptop_icon.png differ
diff --git a/resources/images/loader_icon.png b/resources/images/loader_icon.png
new file mode 100644
index 00000000..642e2944
Binary files /dev/null and b/resources/images/loader_icon.png differ
diff --git a/resources/images/makepad_expert_agent_icon.png b/resources/images/makepad_expert_agent_icon.png
new file mode 100644
index 00000000..0d322275
Binary files /dev/null and b/resources/images/makepad_expert_agent_icon.png differ
diff --git a/resources/images/refresh_error_icon.png b/resources/images/refresh_error_icon.png
new file mode 100644
index 00000000..6e73f759
Binary files /dev/null and b/resources/images/refresh_error_icon.png differ
diff --git a/src/app.rs b/src/app.rs
index b976af4f..c7126900 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,5 +1,6 @@
 use crate::chat::chat_panel::ChatPanelAction;
 use crate::chat::model_selector_list::ModelSelectorListAction;
+use crate::data::chats::{MoFaTestServerAction, MofaServerConnectionStatus};
 use crate::data::downloads::download::DownloadFileAction;
 use crate::data::downloads::DownloadPendingNotification;
 use crate::data::store::*;
@@ -12,6 +13,7 @@ use crate::shared::download_notification_popup::{
 use crate::shared::popup_notification::PopupNotificationWidgetRefExt;
 use makepad_widgets::*;
 use markdown::MarkdownAction;
+use moly_mofa::MofaServerId;
 
 live_design! {
     use link::theme::*;
@@ -249,6 +251,10 @@ impl MatchEvent for App {
                 discover_radio_button.select(cx, &mut Scope::empty());
             }
 
+            self.store.handle_mofa_test_server_action(action.cast());
+            // redraw the UI to reflect the connection status
+            self.ui.redraw(cx);
+
             if matches!(
                 action.cast(),
                 DownloadNotificationPopupAction::ActionLinkClicked
diff --git a/src/chat/chat_history.rs b/src/chat/chat_history.rs
index c4ceb10c..393dea1a 100644
--- a/src/chat/chat_history.rs
+++ b/src/chat/chat_history.rs
@@ -1,10 +1,11 @@
 use super::chat_history_card::ChatHistoryCardWidgetRefExt;
 use crate::chat::entity_button::EntityButtonWidgetRefExt;
 use crate::data::chats::chat::ChatID;
+use crate::data::chats::AgentsAvailability;
 use crate::data::store::Store;
 use crate::shared::actions::ChatAction;
 use makepad_widgets::*;
-use moly_mofa::{MofaAgent, MofaBackend};
+use moly_mofa::MofaAgent;
 
 live_design! {
     use link::theme::*;
@@ -24,7 +25,16 @@ live_design! {
         margin: {left: 4, bottom: 4},
         draw_text:{
             text_style: <BOLD_FONT>{font_size: 10},
-            color: #667085
+            color: #3
+        }
+    }
+
+    NoAgentsWarning = <Label> {
+        margin: {left: 4, bottom: 4},
+        width: Fill
+        draw_text:{
+            text_style: {font_size: 8.5},
+            color: #3
         }
     }
 
@@ -48,7 +58,10 @@ live_design! {
                     list = <PortalList> {
                         drag_scrolling: false,
                         AgentHeading = <HeadingLabel> { text: "AGENTS" }
-                        Agent = <EntityButton> {}
+                        NoAgentsWarning = <NoAgentsWarning> {}
+                        Agent = <EntityButton> {
+                            server_url_visible: true,
+                        }
                         ChatsHeading = <HeadingLabel> { text: "CHATS", margin: {top: 10}, }
                         ChatHistoryCard = <ChatHistoryCard> {
                             padding: {top: 4}
@@ -94,12 +107,13 @@ impl Widget for ChatHistory {
     }
 
     fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
-        let store = scope.data.get::<Store>().unwrap();
-        let agents = MofaBackend::available_agents();
+        let store = scope.data.get_mut::<Store>().unwrap();
+        let agents = store.chats.get_agents_list();
 
         enum Item<'a> {
             ChatsHeader,
             AgentsHeader,
+            NoAgentsWarning(&'a str),
             AgentButton(&'a MofaAgent),
             ChatButton(&'a ChatID),
         }
@@ -108,9 +122,16 @@ impl Widget for ChatHistory {
 
         if moly_mofa::should_be_visible() {
             items.push(Item::AgentsHeader);
-
-            for agent in &agents {
-                items.push(Item::AgentButton(agent));
+            let agents_availability = store.chats.agents_availability();
+            match agents_availability {
+                AgentsAvailability::NoServers => items.push(Item::NoAgentsWarning(agents_availability.to_human_readable())),
+                AgentsAvailability::ServersNotConnected => items.push(Item::NoAgentsWarning(agents_availability.to_human_readable())),
+                AgentsAvailability::NoAgents => items.push(Item::NoAgentsWarning(agents_availability.to_human_readable())),
+                AgentsAvailability::Available => {
+                    for agent in &agents {
+                        items.push(Item::AgentButton(agent));
+                    }
+                }
             }
         }
 
@@ -146,6 +167,11 @@ impl Widget for ChatHistory {
                             let item = list.item(cx, item_id, live_id!(AgentHeading));
                             item.draw_all(cx, scope);
                         }
+                        Item::NoAgentsWarning(text) => {
+                            let item = list.item(cx, item_id, live_id!(NoAgentsWarning));
+                            item.set_text(text);
+                            item.draw_all(cx, scope);
+                        }
                         Item::AgentButton(agent) => {
                             let item = list.item(cx, item_id, live_id!(Agent));
                             item.as_entity_button().set_agent(agent);
diff --git a/src/chat/chat_history_card.rs b/src/chat/chat_history_card.rs
index 964256c5..3c4a150b 100644
--- a/src/chat/chat_history_card.rs
+++ b/src/chat/chat_history_card.rs
@@ -360,13 +360,15 @@ impl Widget for ChatHistoryCard {
             .to_uppercase()
             .to_string();
 
-        match chat.borrow().associated_entity {
-            Some(ChatEntityId::Agent(agent)) => {
+        match &chat.borrow().associated_entity {
+            Some(ChatEntityId::Agent(agent_id)) => {
+                let agent = store.chats.get_agent_or_placeholder(&agent_id);
+
                 self.view(id!(avatar_section.model)).set_visible(false);
                 self.chat_agent_avatar(id!(avatar_section.agent))
                     .set_visible(true);
                 self.chat_agent_avatar(id!(avatar_section.agent))
-                    .set_agent(&agent);
+                    .set_agent(agent);
             }
             _ => {
                 self.view(id!(avatar_section.model)).set_visible(true);
diff --git a/src/chat/chat_panel.rs b/src/chat/chat_panel.rs
index e49f93ad..ad8a67a5 100644
--- a/src/chat/chat_panel.rs
+++ b/src/chat/chat_panel.rs
@@ -482,7 +482,7 @@ impl WidgetMatchEvent for ChatPanel {
                 }
                 ModelSelectorAction::AgentSelected(agent) => {
                     if let Some(chat) = store.chats.get_current_chat() {
-                        chat.borrow_mut().associated_entity = Some(ChatEntityId::Agent(agent));
+                        chat.borrow_mut().associated_entity = Some(ChatEntityId::Agent(agent.id));
                         chat.borrow().save();
                     }
 
@@ -506,8 +506,8 @@ impl WidgetMatchEvent for ChatPanel {
                             self.focus_on_prompt_input_pending = true;
                         }
                     }
-                    ChatEntityId::Agent(agent) => {
-                        store.chats.create_empty_chat_with_agent(agent);
+                    ChatEntityId::Agent(agent_id) => {
+                        store.chats.create_empty_chat_with_agent(&agent_id);
                         self.focus_on_prompt_input_pending = true;
                     }
                 },
@@ -816,9 +816,10 @@ impl ChatPanel {
                             .chat_agent_avatar(id!(avatar_section.agent))
                             .set_visible(true);
 
+                        let agent = store.chats.get_agent_or_placeholder(&agent);
                         empty_view
                             .chat_agent_avatar(id!(avatar_section.agent))
-                            .set_agent(&agent);
+                            .set_agent(agent);
                     }
                     _ => {
                         let empty_view = self.view(id!(empty_conversation));
@@ -904,9 +905,10 @@ impl ChatPanel {
                     chat_line_item.set_sender_name(&username);
                     chat_line_item.set_regenerate_button_visible(false);
 
-                    match chat_line_data.entity {
-                        Some(ChatEntityId::Agent(agent)) => {
-                            chat_line_item.set_model_avatar(&agent);
+                    match &chat_line_data.entity {
+                        Some(ChatEntityId::Agent(agent_id)) => {
+                            let agent = store.chats.get_agent_or_placeholder(&agent_id);
+                            chat_line_item.set_model_avatar(agent);
                         }
                         Some(ChatEntityId::ModelFile(_)) => {
                             chat_line_item.set_model_avatar_text(
diff --git a/src/chat/entity_button.rs b/src/chat/entity_button.rs
index e745ffd6..de762c43 100644
--- a/src/chat/entity_button.rs
+++ b/src/chat/entity_button.rs
@@ -23,6 +23,7 @@ live_design!(
         align: { x: 0.0, y: 0.5 },
         padding: { left: 9, top: 4, bottom: 4, right: 9 },
         spacing: 10,
+        server_url_visible: false,
 
         cursor: Hand
         show_bg: true,
@@ -46,6 +47,17 @@ live_design!(
                     color: #000;
                 }
             }
+            server_url = <View> {
+                visible: false,
+                width: Fill,
+                height: Fit,
+                label = <Label> {
+                    draw_text: {
+                        text_style: <REGULAR_FONT>{font_size: 9, height_factor: 1.1},
+                        color: #667085,
+                    }
+                }
+            }
             description = <View> {
                 visible: false,
                 width: Fill,
@@ -105,6 +117,9 @@ pub struct EntityButton {
     #[deref]
     view: View,
 
+    #[live]
+    server_url_visible: bool,
+
     #[rust]
     entity: Option<ChatEntityId>,
 }
@@ -115,6 +130,10 @@ impl Widget for EntityButton {
     }
 
     fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        if self.server_url_visible {
+            self.view(id!(server_url)).set_visible(true);
+        }
+
         self.view.draw_walk(cx, scope, walk)
     }
 }
@@ -144,13 +163,20 @@ impl EntityButton {
         let name_label = self.label(id!(caption));
         let description_label = self.label(id!(description.label));
         let mut avatar = self.chat_agent_avatar(id!(agent_avatar));
+        let server_url = self.label(id!(server_url.label));
 
         name_label.set_text(&entity.name());
 
         if let ChatEntityRef::Agent(agent) = entity {
             avatar.set_visible(true);
             avatar.set_agent(agent);
-            description_label.set_text(&agent.short_description());
+            description_label.set_text(&agent.description);
+            
+            let formatted_server_url = agent.server_id.0
+                .strip_prefix("https://")
+                .or_else(|| agent.server_id.0.strip_prefix("http://"))
+                .unwrap_or(&agent.server_id.0);
+            server_url.set_text(formatted_server_url);
         } else {
             avatar.set_visible(false);
             description_label.set_text("");
diff --git a/src/chat/model_selector.rs b/src/chat/model_selector.rs
index 52d1c03b..f0e88027 100644
--- a/src/chat/model_selector.rs
+++ b/src/chat/model_selector.rs
@@ -397,10 +397,11 @@ impl ModelSelector {
             let selected_view = self.view(id!(selected_agent));
             selected_view.set_visible(true);
 
+            let agent = store.chats.get_agent_or_placeholder(&agent);
             selected_view.apply_over(
                 cx,
                 live! {
-                    label = { text: (agent.name()) }
+                    label = { text: (&agent.name) }
                 },
             );
             selected_view
diff --git a/src/chat/model_selector_item.rs b/src/chat/model_selector_item.rs
index ddeb600d..7a385ec8 100644
--- a/src/chat/model_selector_item.rs
+++ b/src/chat/model_selector_item.rs
@@ -111,7 +111,7 @@ impl WidgetMatchEvent for ModelSelectorItem {
                         cx.action(ModelSelectorAction::ModelSelected(df.clone()));
                     }
                     ModelSelectorEntity::Agent(agent) => {
-                        cx.action(ModelSelectorAction::AgentSelected(*agent));
+                        cx.action(ModelSelectorAction::AgentSelected(agent.clone()));
                     }
                     ModelSelectorEntity::None => {}
                 }
@@ -127,10 +127,11 @@ impl ModelSelectorItemRef {
     }
 
     pub fn set_agent(&mut self, agent: MofaAgent) {
-        let Some(mut inner) = self.borrow_mut() else { return };
-        inner.entity = ModelSelectorEntity::Agent(agent);
-
+        let Some(mut inner) = self.borrow_mut() else {
+            return;
+        };
         inner.chat_agent_avatar(id!(avatar)).set_agent(&agent);
+        inner.entity = ModelSelectorEntity::Agent(agent);
     }
 }
 
diff --git a/src/chat/model_selector_list.rs b/src/chat/model_selector_list.rs
index dc2362b5..8239a791 100644
--- a/src/chat/model_selector_list.rs
+++ b/src/chat/model_selector_list.rs
@@ -3,7 +3,6 @@ use crate::{
     shared::utils::format_model_size,
 };
 use makepad_widgets::*;
-use moly_mofa::MofaBackend;
 use moly_protocol::data::DownloadedFile;
 use std::collections::HashMap;
 
@@ -79,7 +78,7 @@ impl Widget for ModelSelectorList {
         cx.begin_turtle(walk, self.layout);
 
         if self.visible {
-            self.draw_items(cx, store);
+            self.draw_items(cx, &store);
         }
 
         cx.end_turtle_with_area(&mut self.area);
@@ -174,19 +173,21 @@ impl ModelSelectorList {
         }
 
         if moly_mofa::should_be_visible() {
-            let agents = MofaBackend::available_agents();
-            for i in 0..agents.len() {
+            let agents = store.chats.get_agents_list();
+            for (i, agent) in agents.iter().enumerate() {
                 let item_id = LiveId((models_count + 1 + i) as u64).into();
                 let item_widget = self.items.get_or_insert(cx, item_id, |cx| {
                     WidgetRef::new_from_ptr(cx, self.agent_template)
                 });
 
-                let agent_name = &agents[i].name();
+                let agent_name = &agent.name;
                 let current_agent_name = match &chat_entity {
-                    Some(ChatEntityId::Agent(agent)) => Some(agent.name()),
+                    Some(ChatEntityId::Agent(agent_id)) => {
+                        store.chats.available_agents.get(agent_id).map(|a| &a.name)
+                    },
                     _ => None,
                 };
-                let icon_tick_visible = current_agent_name.as_ref() == Some(agent_name);
+                let icon_tick_visible = current_agent_name == Some(agent_name);
 
                 item_widget.apply_over(
                     cx,
@@ -197,9 +198,10 @@ impl ModelSelectorList {
                         }
                     },
                 );
+                
                 item_widget
                     .as_model_selector_item()
-                    .set_agent(agents[i].clone());
+                    .set_agent(agent.clone());
 
                 let _ = item_widget.draw_all(cx, &mut Scope::empty());
                 total_height += item_widget.view(id!(content)).area().rect(cx).size.y;
diff --git a/src/chat/prompt_input.rs b/src/chat/prompt_input.rs
index 88e36f35..a83263ac 100644
--- a/src/chat/prompt_input.rs
+++ b/src/chat/prompt_input.rs
@@ -1,5 +1,4 @@
 use makepad_widgets::*;
-use moly_mofa::MofaBackend;
 
 use crate::{
     data::{
@@ -59,7 +58,9 @@ live_design! {
             height: Fit,
             show_bg: true,
 
-            button = <EntityButton> {}
+            button = <EntityButton> {
+                server_url_visible: true,
+            }
         }
         section_label_template: <Label> {
             padding: {top: 4., bottom: 4.}
@@ -376,11 +377,13 @@ impl PromptInput {
 
     fn on_entity_selected(&mut self, scope: &mut Scope, entity: &ChatEntityId) {
         let mut agent_avatar = self.chat_agent_avatar(id!(agent_avatar));
+        let store = scope.data.get_mut::<Store>().unwrap();
         let label = self.label(id!(selected_label));
 
         match entity {
-            ChatEntityId::Agent(agent) => {
-                label.set_text(&agent.name());
+            ChatEntityId::Agent(agent_id) => {
+                let agent = store.chats.get_agent_or_placeholder(agent_id);
+                label.set_text(&agent.name);
                 agent_avatar.set_agent(agent);
             }
             ChatEntityId::ModelFile(file_id) => {
@@ -457,10 +460,10 @@ impl PromptInput {
             .map(|s| s.to_ascii_lowercase())
             .collect::<Vec<_>>();
 
-        let available_agents = MofaBackend::available_agents();
+        let available_agents = store.chats.get_agents_list();
         let agents: Vec<_> = available_agents
             .iter()
-            .map(|agent| ChatEntityRef::Agent(agent))
+            .map(|agent| ChatEntityRef::Agent(&agent))
             .filter(|entity| {
                 terms
                     .iter()
diff --git a/src/chat/shared.rs b/src/chat/shared.rs
index f7393f38..85f5dbb3 100644
--- a/src/chat/shared.rs
+++ b/src/chat/shared.rs
@@ -1,5 +1,5 @@
 use makepad_widgets::*;
-use moly_mofa::MofaAgent;
+use moly_mofa::{AgentType, MofaAgent};
 
 live_design! {
     use link::theme::*;
@@ -35,6 +35,7 @@ live_design! {
         reasoner_agent_icon: dep("crate://self/resources/images/reasoner_agent_icon.png")
         research_scholar_icon: dep("crate://self/resources/images/research_scholar_agent_icon.png")
         search_assistant_icon: dep("crate://self/resources/images/search_assistant_agent_icon.png")
+        makepad_expert_icon: dep("crate://self/resources/images/makepad_expert_agent_icon.png")
         width: Fit,
         height: Fit,
         image = <Image> { width: 24, height: 24 }
@@ -55,6 +56,9 @@ pub struct ChatAgentAvatar {
     #[live]
     search_assistant_icon: LiveValue,
 
+    #[live]
+    makepad_expert_icon: LiveValue,
+
     // To avoid requesting `cx` on `set_agent`, which would cause a lot of changes in chain.
     #[rust]
     pending_image_update: Option<LiveValue>,
@@ -83,10 +87,11 @@ impl Widget for ChatAgentAvatar {
 
 impl ChatAgentAvatar {
     pub fn set_agent(&mut self, agent: &MofaAgent) {
-        let dep = match agent {
-            MofaAgent::Reasoner | MofaAgent::Example => self.reasoner_agent_icon.clone(),
-            MofaAgent::ResearchScholar => self.research_scholar_icon.clone(),
-            MofaAgent::SearchAssistant => self.search_assistant_icon.clone(),
+        let dep = match agent.agent_type {
+            AgentType::Reasoner => self.reasoner_agent_icon.clone(),
+            AgentType::ResearchScholar => self.research_scholar_icon.clone(),
+            AgentType::SearchAssistant => self.search_assistant_icon.clone(),
+            AgentType::MakepadExpert => self.makepad_expert_icon.clone(),
         };
 
         self.pending_image_update = Some(dep);
diff --git a/src/data/chats/chat.rs b/src/data/chats/chat.rs
index ddb6aaf9..0891246a 100644
--- a/src/data/chats/chat.rs
+++ b/src/data/chats/chat.rs
@@ -1,8 +1,7 @@
 use anyhow::{anyhow, Result};
 use makepad_widgets::Cx;
 use moly_backend::Backend;
-use moly_mofa::MofaAgentCommand::{self, SendTask};
-use moly_mofa::{MofaAgent, MofaBackend};
+use moly_mofa::{MofaAgent, MofaClient};
 use moly_protocol::data::{File, FileID};
 use moly_protocol::open_ai::*;
 use moly_protocol::protocol::Command;
@@ -28,7 +27,7 @@ pub struct ChatEntityAction {
 enum ChatEntityActionKind {
     ModelAppendDelta(String),
     ModelStreamingDone,
-    MofaAgentResult(String, MofaAgent),
+    MofaAgentResult(String),
     MofaAgentCancelled,
 }
 
@@ -398,15 +397,12 @@ impl Chat {
 
     pub fn send_message_to_agent(
         &mut self,
-        agent: MofaAgent,
+        agent: &MofaAgent,
         prompt: String,
-        mae_backend: &MofaBackend,
+        mofa_client: &MofaClient,
     ) {
         let (tx, rx) = mpsc::channel();
-        mae_backend
-            .command_sender
-            .send(SendTask(prompt.clone(), agent.clone(), tx.clone()))
-            .expect("failed to send message to agent");
+        mofa_client.send_message_to_agent(&agent, &prompt, tx);
 
         let next_id = self.messages.last().map(|m| m.id).unwrap_or(0) + 1;
 
@@ -421,8 +417,8 @@ impl Chat {
         self.messages.push(ChatMessage {
             id: next_id + 1,
             role: Role::Assistant,
-            username: Some(agent.name().to_string()),
-            entity: Some(ChatEntityId::Agent(agent.clone())),
+            username: Some(agent.name.clone()),
+            entity: Some(ChatEntityId::Agent(agent.id.clone())),
             content: "".to_string(),
         });
 
@@ -432,11 +428,11 @@ impl Chat {
         std::thread::spawn(move || '_loop: loop {
             match rx.recv() {
                 Ok(moly_mofa::ChatResponse::ChatFinalResponseData(data)) => {
+                    let node_results = serde_json::from_str::<MofaAgentResponse>(&data.choices[0].message.content).unwrap();
                     Cx::post_action(ChatEntityAction {
                         chat_id,
                         kind: ChatEntityActionKind::MofaAgentResult(
-                            data.choices[0].message.content.clone(),
-                            agent.clone(),
+                            node_results.node_results
                         ),
                     });
 
@@ -476,13 +472,12 @@ impl Chat {
         }
     }
 
-    pub fn cancel_agent_interaction(&mut self, mae_backend: &MofaBackend) {
+    pub fn cancel_agent_interaction(&mut self, mofa_client: &MofaClient) {
         if matches!(self.state, ChatState::Idle | ChatState::Cancelled(_)) {
             return;
         }
 
-        let cmd = MofaAgentCommand::CancelTask;
-        mae_backend.command_sender.send(cmd).unwrap();
+        mofa_client.cancel_task();
 
         self.state = ChatState::Cancelled(true);
         let message = self.messages.last_mut().unwrap();
@@ -530,7 +525,7 @@ impl Chat {
                 self.is_streaming = false;
                 self.state = ChatState::Idle;
             }
-            ChatEntityActionKind::MofaAgentResult(response, _agent) => {
+            ChatEntityActionKind::MofaAgentResult(response) => {
                 let last = self.messages.last_mut().unwrap();
                 last.content = response.clone();
                 self.state = ChatState::Idle;
@@ -544,3 +539,10 @@ impl Chat {
         self.save();
     }
 }
+
+#[derive(Serialize, Deserialize)]
+struct MofaAgentResponse {
+    step_name: String,
+    node_results: String,
+    dataflow_status: bool,
+}
diff --git a/src/data/chats/chat_entity.rs b/src/data/chats/chat_entity.rs
index de6f5ad2..21d1c9ce 100644
--- a/src/data/chats/chat_entity.rs
+++ b/src/data/chats/chat_entity.rs
@@ -1,6 +1,6 @@
 //! Hopefully, provisional solution to unify model files and agents in the chat system.
 
-use moly_mofa::MofaAgent;
+use moly_mofa::{AgentId, MofaAgent};
 use moly_protocol::data::{File, FileID};
 use serde::{Deserialize, Serialize};
 
@@ -8,8 +8,7 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum ChatEntityId {
     ModelFile(FileID),
-    /// Since agents are currently fixed enum values, the agent itself is the identifier.
-    Agent(MofaAgent),
+    Agent(AgentId),
 }
 
 /// Reference to either a model file or an agent.
@@ -25,14 +24,14 @@ impl<'a> ChatEntityRef<'a> {
     pub fn id(&self) -> ChatEntityId {
         match self {
             ChatEntityRef::ModelFile(file) => ChatEntityId::ModelFile(file.id.clone()),
-            ChatEntityRef::Agent(agent) => ChatEntityId::Agent(**agent),
+            ChatEntityRef::Agent(agent) => ChatEntityId::Agent(agent.id.clone()),
         }
     }
 
     pub fn name(&self) -> &str {
         match self {
             ChatEntityRef::ModelFile(file) => &file.name,
-            ChatEntityRef::Agent(agent) => agent.name(),
+            ChatEntityRef::Agent(agent) => &agent.name,
         }
     }
 }
diff --git a/src/data/chats/mod.rs b/src/data/chats/mod.rs
index 394a95b2..5826a642 100644
--- a/src/data/chats/mod.rs
+++ b/src/data/chats/mod.rs
@@ -5,44 +5,80 @@ pub mod model_loader;
 use anyhow::{Context, Result};
 use chat::{Chat, ChatEntityAction, ChatID};
 use chat_entity::ChatEntityId;
-use makepad_widgets::ActionTrait;
+use makepad_widgets::{error, ActionDefaultRef, ActionTrait, Cx, DefaultNone};
 use model_loader::ModelLoader;
 use moly_backend::Backend;
-use moly_mofa::{MofaAgent, MofaBackend};
+use moly_mofa::{AgentId, MofaAgent, MofaClient, MofaServerId, MofaServerResponse};
 use moly_protocol::data::*;
 use moly_protocol::protocol::Command;
+use std::collections::HashMap;
 use std::fs;
-use std::sync::mpsc::channel;
+use std::sync::mpsc::{self, channel};
 use std::{cell::RefCell, path::PathBuf, rc::Rc};
 
 use super::filesystem::setup_chats_folder;
 
+#[derive(Clone, Debug)]
+pub struct MofaServer {
+    pub client: MofaClient,
+    pub connection_status: MofaServerConnectionStatus,
+}
+
+impl MofaServer {
+    pub fn is_local(&self) -> bool {
+        self.client.address.starts_with("http://localhost")
+    }
+}
+
+/// The connection status of the server
+#[derive(Debug, Clone, PartialEq)]
+pub enum MofaServerConnectionStatus {
+    Connecting,
+    Connected,
+    Disconnected,
+}
+
+#[derive(Debug, DefaultNone, Clone)]
+pub enum MoFaTestServerAction {
+    Success(String, Vec<MofaAgent>),
+    Failure(Option<String>),
+    None,
+}
+
 pub struct Chats {
     pub backend: Rc<Backend>,
-    pub mae_backend: Rc<MofaBackend>,
     pub saved_chats: Vec<RefCell<Chat>>,
 
     pub loaded_model: Option<File>,
     pub model_loader: ModelLoader,
 
+    pub mofa_servers: HashMap<MofaServerId, MofaServer>,
+    pub available_agents: HashMap<AgentId, MofaAgent>,
+
     /// Set it thru `set_current_chat` method to trigger side effects.
     current_chat_id: Option<ChatID>,
     chats_dir: PathBuf,
 
     override_port: Option<u16>,
+
+    /// Placeholder agent used when an agent is not available
+    /// This is used to avoid recreating it on each call and make borrowing simpler.
+    unknown_agent: MofaAgent,
 }
 
 impl Chats {
-    pub fn new(backend: Rc<Backend>, mae_backend: Rc<MofaBackend>) -> Self {
+    pub fn new(backend: Rc<Backend>) -> Self {
         Self {
             backend,
-            mae_backend,
             saved_chats: Vec::new(),
             current_chat_id: None,
             loaded_model: None,
             model_loader: ModelLoader::new(),
             chats_dir: setup_chats_folder(),
             override_port: None,
+            mofa_servers: HashMap::new(),
+            available_agents: HashMap::new(),
+            unknown_agent: MofaAgent::unknown(),
         }
     }
 
@@ -114,12 +150,16 @@ impl Chats {
     pub fn cancel_chat_streaming(&mut self) {
         if let Some(chat) = self.get_current_chat() {
             let mut chat = chat.borrow_mut();
-            match chat.associated_entity {
+            match &chat.associated_entity {
                 Some(ChatEntityId::ModelFile(_)) => {
                     chat.cancel_streaming(self.backend.as_ref());
                 }
-                Some(ChatEntityId::Agent(_)) => {
-                    chat.cancel_agent_interaction(self.mae_backend.as_ref());
+                Some(ChatEntityId::Agent(agent_id)) => {
+                    if let Some(mofa_client) = self.get_client_for_agent(&agent_id) {
+                        chat.cancel_agent_interaction(&mofa_client);
+                    } else {
+                        error!("No mofa client found for agent: {}", agent_id.0);
+                    }
                 }
                 _ => {}
             }
@@ -188,10 +228,10 @@ impl Chats {
         self.set_current_chat(Some(id));
     }
 
-    pub fn create_empty_chat_with_agent(&mut self, agent: MofaAgent) {
+    pub fn create_empty_chat_with_agent(&mut self, agent_id: &AgentId) {
         self.create_empty_chat();
         if let Some(mut chat) = self.get_current_chat().map(|c| c.borrow_mut()) {
-            chat.associated_entity = Some(ChatEntityId::Agent(agent));
+            chat.associated_entity = Some(ChatEntityId::Agent(agent_id.clone()));
             chat.save();
         }
     }
@@ -232,4 +272,129 @@ impl Chats {
             }
         }
     }
+
+    // Agents
+
+    /// Registers a new MoFa server by creating a new client, automatically testing the connection
+    /// and fetching the available agents.
+    pub fn register_mofa_server(&mut self, address: String) -> MofaServerId {
+        let server_id = MofaServerId(address.clone());
+        let client = MofaClient::new(address.clone());
+        
+        self.mofa_servers.insert(server_id.clone(), MofaServer {
+            client,
+            connection_status: MofaServerConnectionStatus::Connecting,
+        });
+
+        self.test_mofa_server_and_fetch_agents(&address);
+        server_id
+    }
+
+    /// Removes a MoFa server from the list of available servers.
+    pub fn remove_mofa_server(&mut self, address: &str) {
+        self.mofa_servers.remove(&MofaServerId(address.to_string()));
+        self.available_agents.retain(|_, agent| agent.server_id.0 != address);
+    }
+
+    /// Retrieves the corresponding MofaClient for an agent
+    pub fn get_client_for_agent(&self, agent_id: &AgentId) -> Option<&MofaClient> {
+        self.available_agents.get(agent_id)
+            .and_then(|agent| self.mofa_servers.get(&agent.server_id))
+            .map(|server| &server.client)
+    }
+
+    /// Helper method for components that need a sorted vector of agents
+    pub fn get_agents_list(&self) -> Vec<MofaAgent> {
+        let mut agents: Vec<_> = self.available_agents.values().cloned().collect();
+        agents.sort_by(|a, b| a.name.cmp(&b.name));
+        agents
+    }
+
+    /// Tests the connection to a MoFa server by requesting /v1/models.
+    ///
+    /// The connection status is updated at the App level based on the actions dispatched.
+    pub fn test_mofa_server_and_fetch_agents(&mut self, address: &String) {
+        self.mofa_servers.get_mut(&MofaServerId(address.to_string())).unwrap().connection_status = MofaServerConnectionStatus::Connecting;
+        let (tx, rx) = mpsc::channel();
+        if let Some(server) = self.mofa_servers.get(&MofaServerId(address.to_string())) {
+            server.client.fetch_agents(tx.clone());
+        }
+
+        std::thread::spawn(move || match rx.recv() {
+            Ok(MofaServerResponse::Connected(server_address, agents)) => {
+                Cx::post_action(MoFaTestServerAction::Success(server_address, agents));
+            }
+            Ok(MofaServerResponse::Unavailable(server_address)) => {
+                Cx::post_action(MoFaTestServerAction::Failure(Some(server_address)));
+            }
+            Err(e) => {
+                error!("Error receiving response from MoFa backend: {:?}", e);
+                Cx::post_action(MoFaTestServerAction::Failure(None));
+            }
+        });
+    }
+
+    pub fn handle_server_connection_result(&mut self, result: MofaServerResponse) {
+        match result {
+            MofaServerResponse::Connected(address, agents) => {
+                if let Some(server) = self.mofa_servers.get_mut(&MofaServerId(address.clone())) {
+                    server.connection_status = MofaServerConnectionStatus::Connected;
+
+                    for agent in agents {
+                        self.available_agents.insert(agent.id.clone(), agent);
+                    }
+                }
+            }
+            MofaServerResponse::Unavailable(address) => {
+                if let Some(server) = self.mofa_servers.get_mut(&MofaServerId(address)) {
+                    server.connection_status = MofaServerConnectionStatus::Disconnected;
+                }
+            }
+        }
+    }
+
+    pub fn agents_availability(&self) -> AgentsAvailability {
+        if self.mofa_servers.is_empty() {
+            AgentsAvailability::NoServers
+        } else if self.available_agents.is_empty() {
+            // Check the reason for the lack of agents, is it disconnected servers or servers with no agents?
+            if self.mofa_servers.iter().all(|(_id, s)| s.connection_status == MofaServerConnectionStatus::Connected) {
+                AgentsAvailability::NoAgents
+            } else {
+                AgentsAvailability::ServersNotConnected
+            }
+        } else {
+            AgentsAvailability::Available
+        }
+    }
+
+    /// Returns a reference to an agent by ID, falling back to an unknown agent placeholder
+    /// if the agent is not found in the available agents list.
+    /// 
+    /// This is useful when dealing with historical chat references to agents that may
+    /// no longer be available (e.g., server disconnected or agent deleted).
+    /// 
+    /// In the future, we'll want a more sophisticated solution, by potentially storing 
+    /// agent information locally and updating it when a server is connected.
+    pub fn get_agent_or_placeholder(&self, agent_id: &AgentId) -> &MofaAgent {
+        self.available_agents.get(agent_id).unwrap_or(&self.unknown_agent)
+    }
+}
+
+pub enum AgentsAvailability {
+    Available,
+    NoAgents,
+    NoServers,
+    ServersNotConnected,
+}
+
+impl AgentsAvailability {
+    pub fn to_human_readable(&self) -> &'static str {
+        match self {
+            AgentsAvailability::Available => "Agents available",
+            AgentsAvailability::NoAgents => "No agents found in the connected servers.",
+            AgentsAvailability::NoServers => "Not connected to any MoFa servers.",
+            AgentsAvailability::ServersNotConnected => "Could not connect to some servers. Check your MoFa settings.",
+        }
+    }
 }
diff --git a/src/data/store.rs b/src/data/store.rs
index 60ac1432..158c2dad 100644
--- a/src/data/store.rs
+++ b/src/data/store.rs
@@ -1,6 +1,7 @@
 use super::chats::chat::ChatID;
 use super::chats::chat_entity::ChatEntityId;
 use super::chats::model_loader::ModelLoaderStatusChanged;
+use super::chats::MoFaTestServerAction;
 use super::downloads::download::DownloadFileAction;
 use super::filesystem::project_dirs;
 use super::preferences::Preferences;
@@ -8,18 +9,15 @@ use super::search::SortCriteria;
 use super::{chats::Chats, downloads::Downloads, search::Search};
 use anyhow::Result;
 use chrono::{DateTime, Utc};
-use makepad_widgets::{error, Action, ActionDefaultRef, Cx, DefaultNone};
+use makepad_widgets::{Action, ActionDefaultRef, DefaultNone};
 use moly_backend::Backend;
-use moly_mofa::{
-    MofaAgent,
-    MofaAgentCommand::{TestServer, UpdateServerAddress},
-    MofaBackend, TestServerResponse,
-};
+
+use moly_mofa::MofaServerResponse;
 use moly_protocol::data::{Author, DownloadedFile, File, FileID, Model, ModelID, PendingDownload};
 use std::rc::Rc;
-use std::sync::mpsc;
 
 pub const DEFAULT_MAX_DOWNLOAD_THREADS: usize = 3;
+const DEFAULT_MOFA_ADDRESS: &str = "http://localhost:8000";
 
 #[derive(Clone, DefaultNone, Debug)]
 pub enum StoreAction {
@@ -29,13 +27,6 @@ pub enum StoreAction {
     None,
 }
 
-#[derive(Debug, DefaultNone, Clone)]
-pub enum MoFaTestServerAction {
-    Success(String),
-    Failure(Option<String>),
-    None,
-}
-
 #[derive(Clone, Debug)]
 pub struct FileWithDownloadInfo {
     pub file: File,
@@ -56,17 +47,17 @@ pub struct ModelWithDownloadInfo {
     pub download_count: u32,
     pub files: Vec<FileWithDownloadInfo>,
 }
+
 pub struct Store {
     /// This is the backend representation, including the sender and receiver ends of the channels to
     /// communicate with the backend thread.
     pub backend: Rc<Backend>,
 
-    pub mofa_backend: Rc<MofaBackend>,
 
     pub search: Search,
     pub downloads: Downloads,
     pub chats: Chats,
-    pub preferences: Preferences,
+    pub preferences: Preferences
 }
 
 impl Default for Store {
@@ -86,15 +77,12 @@ impl Store {
             DEFAULT_MAX_DOWNLOAD_THREADS,
         ));
 
-        let mofa_backend = Rc::new(MofaBackend::new());
-
         let mut store = Self {
             backend: backend.clone(),
-            mofa_backend: mofa_backend.clone(),
 
             search: Search::new(backend.clone()),
             downloads: Downloads::new(backend.clone()),
-            chats: Chats::new(backend, mofa_backend),
+            chats: Chats::new(backend),
             preferences,
         };
 
@@ -107,7 +95,7 @@ impl Store {
         store.search.load_featured_models();
 
         if moly_mofa::should_be_real() && moly_mofa::should_be_visible() {
-            store.set_test_mofa_server();
+            store.chats.register_mofa_server(DEFAULT_MOFA_ADDRESS.to_string());
         }
         store
     }
@@ -172,8 +160,15 @@ impl Store {
             }
 
             match entity_id {
-                ChatEntityId::Agent(agent) => {
-                    chat.send_message_to_agent(*agent, prompt, &self.mofa_backend);
+                ChatEntityId::Agent(agent_id) => {
+                    if let (Some(client), Some(agent)) = (
+                        self.chats.get_client_for_agent(agent_id),
+                        self.chats.available_agents.get(agent_id)
+                    ) {
+                        chat.send_message_to_agent(agent, prompt, &client);
+                    } else {
+                        eprintln!("client or agent not found: {:?}", agent_id);
+                    }
                 }
                 ChatEntityId::ModelFile(file_id) => {
                     if let Some(file) = self.downloads.get_file(&file_id) {
@@ -189,41 +184,6 @@ impl Store {
         }
     }
 
-    pub fn agents_list(&self) -> Vec<MofaAgent> {
-        MofaBackend::available_agents()
-    }
-
-    pub fn set_mofa_server_address(&mut self, address: String) {
-        let address = address.trim_end_matches('/').to_string();
-        self.mofa_backend
-            .command_sender
-            .send(UpdateServerAddress(address))
-            .expect("failed to update MoFa server address");
-
-        self.set_test_mofa_server();
-    }
-
-    pub fn set_test_mofa_server(&mut self) {
-        let (tx, rx) = mpsc::channel();
-        self.mofa_backend
-            .command_sender
-            .send(TestServer(tx.clone()))
-            .expect("failed to update MoFa server address");
-
-        std::thread::spawn(move || match rx.recv() {
-            Ok(TestServerResponse::Success(server_address)) => {
-                Cx::post_action(MoFaTestServerAction::Success(server_address));
-            }
-            Ok(TestServerResponse::Failure(server_address)) => {
-                Cx::post_action(MoFaTestServerAction::Failure(Some(server_address)));
-            }
-            Err(e) => {
-                error!("Error receiving response from MoFa backend: {:?}", e);
-                Cx::post_action(MoFaTestServerAction::Failure(None));
-            }
-        });
-    }
-
     pub fn edit_chat_message(&mut self, message_id: usize, updated_message: String) {
         if let Some(mut chat) = self.chats.get_current_chat().map(|c| c.borrow_mut()) {
             chat.edit_message(message_id, updated_message);
@@ -255,14 +215,18 @@ impl Store {
             return None;
         };
 
-        match chat.borrow().associated_entity {
+        match &chat.borrow().associated_entity {
             Some(ChatEntityId::ModelFile(ref file_id)) => self
                 .downloads
                 .downloaded_files
                 .iter()
                 .find(|df| df.file.id == *file_id)
                 .map(|df| Some(df.file.name.clone()))?,
-            Some(ChatEntityId::Agent(agent)) => Some(agent.name().to_string()),
+            Some(ChatEntityId::Agent(agent)) => {
+                self.chats.available_agents
+                    .get(&agent)
+                    .map(|a| a.name.clone())
+            }
             None => {
                 // Fallback to loaded model if exists
                 self.chats.loaded_model.as_ref().map(|m| m.name.clone())
@@ -393,4 +357,22 @@ impl Store {
         // support having no chat selected
         self.init_current_chat();
     }
+
+    pub fn handle_mofa_test_server_action(&mut self, action: MoFaTestServerAction) {
+        match action {
+            MoFaTestServerAction::Success(address, agents) => {
+                self.chats.handle_server_connection_result(
+                    MofaServerResponse::Connected(address, agents)
+                );
+            }
+            MoFaTestServerAction::Failure(address) => {
+                if let Some(addr) = address {
+                    self.chats.handle_server_connection_result(
+                        MofaServerResponse::Unavailable(addr)
+                    );
+                }
+            }
+            _ => (),
+        }
+    }
 }
diff --git a/src/landing/model_list.rs b/src/landing/model_list.rs
index b1e5e57b..a087cd59 100644
--- a/src/landing/model_list.rs
+++ b/src/landing/model_list.rs
@@ -1,10 +1,11 @@
 use crate::chat::entity_button::EntityButtonWidgetRefExt;
+use crate::data::chats::AgentsAvailability;
 use crate::data::search::SearchAction;
 use crate::data::store::{Store, StoreAction};
 use crate::landing::search_loading::SearchLoadingWidgetExt;
 use crate::shared::actions::ChatAction;
 use makepad_widgets::*;
-use moly_mofa::{MofaAgent, MofaBackend};
+use moly_mofa::MofaAgent;
 use moly_protocol::data::Model;
 
 live_design! {
@@ -30,6 +31,7 @@ live_design! {
             padding: {left: 15, right: 15},
             spacing: 15,
             align: {x: 0, y: 0.35},
+            server_url_visible: true,
 
             draw_bg: {
                 radius: 5,
@@ -87,8 +89,15 @@ live_design! {
                     second = <AgentCard> {}
                     third = <AgentCard> {}
                 }
+                NoAgentsWarning = <Label> {
+                    draw_text:{
+                        wrap: Word
+                        text_style: {font_size: 10},
+                        color: #3
+                    }
+                }
                 Header = <Label> {
-                    margin: {bottom: 20, top: 35}
+                    margin: {bottom: 10, top: 35}
                     draw_text:{
                         text_style: <BOLD_FONT>{font_size: 16},
                         color: #000
@@ -150,13 +159,14 @@ impl Widget for ModelList {
 
     fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
         let store = scope.data.get::<Store>().unwrap();
-        let agents = MofaBackend::available_agents();
+        let agents = store.chats.get_agents_list();
 
         enum Item<'a> {
             AgentRow {
                 agents: &'a [MofaAgent],
                 margin_bottom: f32,
             },
+            NoAgentsWarning(&'static str),
             Header(&'static str),
             Model(&'a Model),
         }
@@ -166,12 +176,26 @@ impl Widget for ModelList {
         if store.search.keyword.is_none() {
             if moly_mofa::should_be_visible() {
                 items.push(Item::Header("Featured Agents"));
-                items.extend(agents.chunks(3).map(|chunk| Item::AgentRow {
-                    agents: chunk,
-                    margin_bottom: 15.0,
-                }));
-                if let Some(Item::AgentRow { margin_bottom, .. }) = items.last_mut() {
-                    *margin_bottom = 0.0;
+                let agents_availability = store.chats.agents_availability();
+                match agents_availability {
+                    AgentsAvailability::NoServers => items.push(Item::NoAgentsWarning(
+                        agents_availability.to_human_readable(),
+                    )),
+                    AgentsAvailability::ServersNotConnected => items.push(Item::NoAgentsWarning(
+                        agents_availability.to_human_readable(),
+                    )),
+                    AgentsAvailability::NoAgents => items.push(Item::NoAgentsWarning(
+                        agents_availability.to_human_readable(),
+                    )),
+                    AgentsAvailability::Available => {
+                        items.extend(agents.chunks(3).map(|chunk| Item::AgentRow {
+                            agents: chunk,
+                            margin_bottom: 8.0,
+                        }));
+                        if let Some(Item::AgentRow { margin_bottom, .. }) = items.last_mut() {
+                            *margin_bottom = 0.0;
+                        }
+                    }
                 }
             }
             items.push(Item::Header("Models"));
@@ -223,6 +247,11 @@ impl Widget for ModelList {
 
                                 row.draw_all(cx, &mut Scope::empty());
                             }
+                            Item::NoAgentsWarning(text) => {
+                                let item = list.item(cx, item_id, live_id!(NoAgentsWarning));
+                                item.set_text(text);
+                                item.draw_all(cx, &mut Scope::empty());
+                            }
                             Item::Model(model) => {
                                 let item = list.item(cx, item_id, live_id!(Model));
                                 let mut model_with_download_info =
diff --git a/src/settings/mofa_settings.rs b/src/settings/mofa_settings.rs
index 05c645e3..e6442fad 100644
--- a/src/settings/mofa_settings.rs
+++ b/src/settings/mofa_settings.rs
@@ -1,6 +1,7 @@
 use makepad_widgets::*;
 
-use crate::data::store::{MoFaTestServerAction, Store};
+use crate::data::chats::{MofaServer, MofaServerConnectionStatus};
+use crate::data::store::Store;
 
 live_design! {
     use link::theme::*;
@@ -11,210 +12,346 @@ live_design! {
     use crate::shared::widgets::*;
 
     ICON_EDIT = dep("crate://self/resources/icons/edit.svg")
+    ICON_DELETE = dep("crate://self/resources/icons/delete.svg")
+    ICON_REMOTE = dep("crate://self/resources/images/globe_icon.png")
+    ICON_LOCAL = dep("crate://self/resources/images/laptop_icon.png")
+
+    ICON_SUCCESS = dep("crate://self/resources/images/circle_check_icon.png")
+    ICON_LOADER = dep("crate://self/resources/images/loader_icon.png")
+    ICON_FAILURE = dep("crate://self/resources/images/refresh_error_icon.png")
+
+    // Not making this based on <Icon> because button does not support images
+    // (and these SVGs are too complex for Makepad's SVG support)
+    ConnectionStatusButton = <View> {
+        visible: false
+        cursor: Hand
+        width: Fit, height: Fit
+        icon = <Image> {
+            width: 18, height: 18
+            // Override the color of the icon
+            draw_bg: {
+                instance tint_color: #B42318
+
+                fn get_color_scale_pan(self, scale: vec2, pan: vec2) -> vec4 {
+                    let tex_color = sample2d(self.image, self.pos * scale + pan).xyzw;
+                    // Use the alpha channel from the texture but replace RGB with our tint color
+                    // Assuming the icon is black/white with transparency
+                    return vec4(
+                        self.tint_color.rgb * tex_color.a,
+                        tex_color.a
+                    );
+                }
+            }
+        }
+    }
 
-    pub MofaSettings = {{MofaSettings}} {
-        width: Fill, height: Fit
+    MofaServerItem = {{MofaServerItem}} {
+        width: Fill, height: 60
+        show_bg: true
+        draw_bg: {
+            color: #f
+        }
         flow: Down
-        spacing: 20
 
-        <Label> {
-            draw_text:{
-                text_style: <BOLD_FONT>{font_size: 16}
-                color: #000
+        separator = <View> {
+            margin: {left: 20, right: 20, top: 0, bottom: 10}
+            height: 1,
+            show_bg: true,
+            draw_bg: {
+                color: #D9D9D9
             }
-            text: "MoFa options"
         }
 
-        <HorizontalFiller> { height: 10 }
+        <View> {
+            padding: {left: 30, right: 30, top: 0, bottom: 10}
+            align: {x: 0.0, y: 0.5}
+            spacing: 20
+            flow: Right
+
+            icon_remote = <View> {
+                width: Fit, height: Fit
+                visible: true
+                <Image> {
+                    source: (ICON_REMOTE)
+                    width: 18, height: 18
+                }
+            }
 
-        <Label> {
-            draw_text:{
-                text_style: <BOLD_FONT>{font_size: 12}
-                color: #000
+            icon_local = <View> {
+                width: Fit, height: Fit
+                visible: false
+                <Image> {
+                    source: (ICON_LOCAL)
+                    width: 18, height: 18
+                }
             }
-            text: "Server address"
-        }
 
-        address_on_edit = <View> {
-            visible: false,
-            width: Fill, height: Fit
+            address_editable = <View> {
+                width: Fill, height: Fill
+                spacing: 10
+                align: {x: 0.0, y: 0.5}
 
-            mofa_address_input = <MolyTextInput> {
-                width: Fill
-                height: Fit
-                draw_text: {
-                    text_style: <REGULAR_FONT>{font_size: 12}
-                    color: #000
+                mofa_address_label = <Label> {
+                    draw_text:{
+                        text_style: <REGULAR_FONT>{font_size: 12}
+                        color: #000
+                    }
                 }
-                text: "http://localhost:8000"
-            }
-        }
 
-        address_editable = <View> {
-            width: Fit, height: Fit
-            spacing: 10
-            align: {x: 0.0, y: 0.5}
+                <VerticalFiller> {}
 
-            mofa_address_label = <Label> {
-                draw_text:{
-                    text_style: <REGULAR_FONT>{font_size: 12}
-                    color: #000
+                connection_status_success = <ConnectionStatusButton> {
+                    icon = {
+                        source: (ICON_SUCCESS)
+                        draw_bg: {
+                            tint_color: #099250
+                        }
+                    }
                 }
-            }
 
-            edit_mofa_address = <MolyButton> {
-                width: Fit
-                height: Fit
+                connection_status_failure = <ConnectionStatusButton> {
+                    icon = {
+                        source: (ICON_FAILURE)
+                        draw_bg: {
+                            tint_color: #B42318
+                        }
+                    }
+                }
 
-                draw_bg: {
-                    border_width: 1,
-                    radius: 3
+                connection_status_loading = <ConnectionStatusButton> {
+                    visible: true
+                    icon = {
+                        source: (ICON_LOADER)
+                        draw_bg: {
+                            tint_color: #FF8C00
+                        }
+                    }
                 }
 
-                margin: {bottom: 4}
+                remove_server = <MolyButton> {
+                    width: Fit
+                    height: Fit
+
+                    draw_bg: {
+                        border_width: 1,
+                        radius: 3
+                    }
 
-                icon_walk: {width: 14, height: 14}
-                draw_icon: {
-                    svg_file: (ICON_EDIT),
-                    fn get_color(self) -> vec4 {
-                        return #000;
+                    icon_walk: {width: 14, height: 14}
+                    draw_icon: {
+                        svg_file: (ICON_DELETE),
+                        fn get_color(self) -> vec4 {
+                            return #B42318;
+                        }
                     }
                 }
             }
         }
+    }
 
-        mofa_status_label_status = <View> {
-            visible: false,
-            width: Fill, height: Fit
-            <Label> {
-                draw_text:{
-                    text_style: <REGULAR_FONT>{font_size: 10}
-                    color: #000
-                }
-                text: "Checking MoFa server status..."
+    MofaServers = {{MofaServers}} {
+        width: Fill, height: Fill
+        flow: Down
+        spacing: 20
+        <RoundedView> {
+            width: Fill
+            height: Fit
+            padding: {left: 30, right: 30, top: 10, bottom: 10}
+            show_bg: true
+            draw_bg: {
+                color: #f
+                radius: 3
             }
-        }
 
-        mofa_status_label_success = <View> {
-            visible: false,
-            width: Fill, height: Fit
-            <Label> {
-                draw_text:{
-                    text_style: <REGULAR_FONT>{font_size: 10}
-                    color: #099250
-                }
-                text: "MoFa server is running"
+            add_server_input = <MolyTextInput> {
+                width: Fill
+                height: Fit
+                empty_message: "Add a new server"
             }
         }
+        <RoundedView> {
+            width: Fill
+            height: Fill
+            show_bg: true
+            draw_bg: {
+                color: #f
+                radius: 3
+            }
+            padding: 10
 
-        mofa_status_label_failure = <View> {
-            visible: false,
-            width: Fill, height: Fit
-            <Label> {
-                draw_text:{
-                    text_style: <REGULAR_FONT>{font_size: 10}
-                    color: #B42318
-                }
-                text: "MoFa server is not properly running. Please check the address." 
-            } 
+            severs_list = <PortalList> {
+                width: Fill, height: Fill
+                mofa_server_item = <MofaServerItem> {}
+            }
         }
     }
-}
 
-#[derive(Default, Debug, PartialEq)]
-enum MofaAddressEditionState {
-    OnEdit,
-    #[default]
-    Editable,
+    pub MofaSettings = {{MofaSettings}} {
+        width: Fill, height: Fill
+        flow: Down
+        spacing: 20
+
+        <Label> {
+            draw_text:{
+                text_style: <BOLD_FONT>{font_size: 16}
+                color: #000
+            }
+            text: "MoFa Settings"
+        }
+
+        <HorizontalFiller> { height: 10 }
+
+        <Label> {
+            draw_text:{
+                text_style: <BOLD_FONT>{font_size: 12}
+                color: #000
+            }
+            text: "MoFa Servers"
+        }
+
+        <MofaServers> {}
+    }
 }
 
 #[derive(Widget, LiveHook, Live)]
 pub struct MofaSettings {
     #[deref]
     view: View,
-
-    #[rust]
-    address_edition_state: MofaAddressEditionState,
 }
 
 impl Widget for MofaSettings {
     fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
         self.view.handle_event(cx, event, scope);
         self.widget_match_event(cx, event, scope);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
 
+impl WidgetMatchEvent for MofaSettings {}
 
+#[derive(Widget, LiveHook, Live)]
+struct MofaServers {
+    #[deref]
+    view: View,
+}
+
+impl Widget for MofaServers {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        self.view.handle_event(cx, event, scope);
+        self.widget_match_event(cx, event, scope);
     }
 
     fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
-        match self.address_edition_state {
-            MofaAddressEditionState::OnEdit => {
-                self.view.view(id!(address_editable)).set_visible(false);
-                self.view.view(id!(address_on_edit)).set_visible(true);
-            }
-            MofaAddressEditionState::Editable => {
-                self.view.view(id!(address_editable)).set_visible(true);
-                self.view.view(id!(address_on_edit)).set_visible(false);
+        let store = scope.data.get::<Store>().unwrap();
+        let mut servers: Vec<_> = store.chats.mofa_servers.values().cloned().collect();
+        let entries_count = servers.len();
+        let last_item_id = if entries_count > 0 { entries_count } else { 0 };
+        servers.sort_by(|a, b| a.client.address.cmp(&b.client.address));
+        while let Some(item) = self.view.draw_walk(cx, scope, walk).step() {
+            if let Some(mut list) = item.as_portal_list().borrow_mut() {
+                list.set_item_range(cx, 0, last_item_id);
+                while let Some(item_id) = list.next_visible_item(cx) {
+                    if item_id < last_item_id {
+                        let template = live_id!(mofa_server_item);
+                        let item = list.item(cx, item_id, template);
+
+                        // hide the separator for the first item
+                        if item_id == 0 {
+                            item.view(id!(separator)).set_visible(false);
+                        }
+
+                        let server = &servers[item_id].clone();
+                        let mut item_scope = Scope::with_props(server);
+                        item.draw_all(cx, &mut item_scope);
+                    }
+                }
             }
         }
-
-        self.view.draw_walk(cx, scope, walk)
+        DrawStep::done()
     }
 }
 
-impl WidgetMatchEvent for MofaSettings {
+impl WidgetMatchEvent for MofaServers {
     fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions, scope: &mut Scope) {
         let store = scope.data.get_mut::<Store>().unwrap();
 
-        for action in actions {
-            match action.downcast_ref() {
-                Some(MoFaTestServerAction::Success(url)) => {
-                    self.view(id!(mofa_status_label_success)).set_visible(true);
-                    self.view(id!(mofa_status_label_failure)).set_visible(false);
-                    self.view(id!(mofa_status_label_status)).set_visible(false);
-                    self.view.label(id!(mofa_address_label)).set_text(url);
-                    self.redraw(cx);
-                }
-                Some(MoFaTestServerAction::Failure(url)) => {
-                    self.view(id!(mofa_status_label_success)).set_visible(false);
-                    self.view(id!(mofa_status_label_failure)).set_visible(true);
-                    self.view(id!(mofa_status_label_status)).set_visible(false);
-                    if let Some(url) = url {
-                        self.view.label(id!(mofa_address_label)).set_text(url);
-                    }
-                    self.redraw(cx);
-                }
-                _ => {}
-            }
+        let add_server_input = self.view.text_input(id!(add_server_input));
+        if let Some(address) = add_server_input.returned(actions) {
+            store.chats.register_mofa_server(address);
+            add_server_input.set_text("");
+
+            self.redraw(cx);
         }
+    }
+}
+
+#[derive(Widget, LiveHook, Live)]
+struct MofaServerItem {
+    #[deref]
+    view: View,
+
+    #[rust]
+    server_address: String,
+}
+
+impl Widget for MofaServerItem {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        self.view.handle_event(cx, event, scope);
+        self.widget_match_event(cx, event, scope);
+    }
 
-        let mofa_address_input = self.view.text_input(id!(mofa_address_input));
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        let server = scope.props.get::<MofaServer>().unwrap();
+        self.server_address = server.client.address.clone();
 
-        if self.button(id!(edit_mofa_address)).clicked(actions) {
-            self.address_edition_state = MofaAddressEditionState::OnEdit;
+        self.update_connection_status(&server.connection_status);
 
-            let address = self.label(id!(mofa_address_label)).text();
-            mofa_address_input.set_key_focus(cx);
-            mofa_address_input.set_text(&address);
+        self.label(id!(address_editable.mofa_address_label))
+            .set_text(&server.client.address);
 
-            self.redraw(cx);
-        }
+        if server.is_local() {
+            self.view.view(id!(icon_local)).set_visible(true);
+            self.view.view(id!(icon_remote)).set_visible(false);
+        } else {
+            self.view.view(id!(icon_local)).set_visible(false);
+            self.view.view(id!(icon_remote)).set_visible(true);
+        };
 
-        if let Some(address) = mofa_address_input.returned(actions) {
-            self.view(id!(mofa_status_label_success)).set_visible(false);
-            self.view(id!(mofa_status_label_failure)).set_visible(false);
-            self.view(id!(mofa_status_label_status)).set_visible(true);
-            self.view.label(id!(mofa_address_label)).set_text(&address);
-            store.set_mofa_server_address(address);
+        self.view.draw_walk(cx, scope, walk)
+    }
+}
+
+impl WidgetMatchEvent for MofaServerItem {
+    fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions, scope: &mut Scope) {
+        let store = scope.data.get_mut::<Store>().unwrap();
 
-            self.address_edition_state = MofaAddressEditionState::Editable;
+        if self.button(id!(remove_server)).clicked(actions) {
+            store.chats.remove_mofa_server(&self.server_address);
             self.redraw(cx);
         }
 
-        if let TextInputAction::Escape =
-            actions.find_widget_action_cast(mofa_address_input.widget_uid())
+        if let Some(_) = self
+            .view(id!(connection_status_failure))
+            .finger_down(actions)
         {
-            self.address_edition_state = MofaAddressEditionState::Editable;
+            store.chats.test_mofa_server_and_fetch_agents(&self.server_address);
+            self.update_connection_status(&MofaServerConnectionStatus::Connecting);
             self.redraw(cx);
         }
     }
 }
+
+impl MofaServerItem {
+    /// Toggles the visibility of the connection status icons based on the connection status
+    fn update_connection_status(&mut self, connection_status: &MofaServerConnectionStatus) {
+        self.view(id!(connection_status_success))
+            .set_visible(*connection_status == MofaServerConnectionStatus::Connected);
+        self.view(id!(connection_status_failure))
+            .set_visible(*connection_status == MofaServerConnectionStatus::Disconnected);
+        self.view(id!(connection_status_loading))
+            .set_visible(*connection_status == MofaServerConnectionStatus::Connecting);
+    }
+}