diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Revision history for pms-domain-service
 
+## 0.1.5.0 -- 2026-05-31
+
+* Added pms-infra-agent-socket, pms-infra-agent-serial.
+
 ## 0.1.4.0 -- 2026-05-15
 
 * Add file system tools.
diff --git a/pms-domain-service.cabal b/pms-domain-service.cabal
--- a/pms-domain-service.cabal
+++ b/pms-domain-service.cabal
@@ -20,7 +20,7 @@
 -- PVP summary:     +-+------- breaking API changes
 --                  | | +----- non-breaking API additions
 --                  | | | +--- code changes with no API change
-version:            0.1.4.0
+version:            0.1.5.0
 
 -- A short (one-line) description of the package.
 synopsis:           pms-domain-service
diff --git a/src/PMS/Domain/Service/DS/State/Run/ToolsCall.hs b/src/PMS/Domain/Service/DS/State/Run/ToolsCall.hs
--- a/src/PMS/Domain/Service/DS/State/Run/ToolsCall.hs
+++ b/src/PMS/Domain/Service/DS/State/Run/ToolsCall.hs
@@ -58,6 +58,18 @@
       go dat "agent-proc-read"      = agentProcReadCommand dat
       go dat "agent-proc-write"     = agentProcWriteCommand dat
       go dat "agent-proc-terminate" = agentProcTerminateCommand dat
+      go dat "agent-socket-open"       = agentSocketOpenCommand dat
+      go dat "agent-socket-close"      = agentSocketCloseCommand dat
+      go dat "agent-socket-read"       = agentSocketReadCommand dat
+      go dat "agent-socket-read-byte"  = agentSocketReadByteCommand dat
+      go dat "agent-socket-write"      = agentSocketWriteCommand dat
+      go dat "agent-socket-write-byte" = agentSocketWriteByteCommand dat
+      go dat "agent-serial-open"       = agentSerialOpenCommand dat
+      go dat "agent-serial-close"      = agentSerialCloseCommand dat
+      go dat "agent-serial-read"       = agentSerialReadCommand dat
+      go dat "agent-serial-read-byte"  = agentSerialReadByteCommand dat
+      go dat "agent-serial-write"      = agentSerialWriteCommand dat
+      go dat "agent-serial-write-byte" = agentSerialWriteByteCommand dat
       go dat "socket-open"       = socketOpenCommand dat
       go dat "socket-close"      = socketCloseCommand dat
       go dat "socket-read"       = socketReadCommand dat
@@ -257,6 +269,150 @@
               }
   cmdQ <- view DM.agentProcessQueueDomainData <$> lift ask
   liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentProcessWriteCommand cmdDat
+
+
+-- |
+-- 
+agentSocketOpenCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSocketOpenCommand dat = do
+  let cmdDat = DM.AgentSocketOpenCommandData {
+                DM._jsonrpcAgentSocketOpenCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._nameAgentSocketOpenCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
+              , DM._argumentsAgentSocketOpenCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketOpenCommand cmdDat
+
+
+-- |
+-- 
+agentSocketCloseCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSocketCloseCommand dat = do
+  let cmdDat = DM.AgentSocketCloseCommandData {
+                DM._jsonrpcAgentSocketCloseCommandData = dat^.DM.jsonrpcMcpToolsCallRequestData
+              }
+  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketCloseCommand cmdDat
+
+
+-- |
+-- 
+agentSocketReadCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSocketReadCommand dat = do
+  let cmdDat = DM.AgentSocketReadCommandData {
+                DM._jsonrpcAgentSocketReadCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._argumentsAgentSocketReadCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketReadCommand cmdDat
+
+
+-- |
+-- 
+agentSocketReadByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSocketReadByteCommand dat = do
+  let cmdDat = DM.AgentSocketReadByteCommandData {
+                DM._jsonrpcAgentSocketReadByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._argumentsAgentSocketReadByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketReadByteCommand cmdDat
+
+
+-- |
+-- 
+agentSocketWriteCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSocketWriteCommand dat = do
+  let cmdDat = DM.AgentSocketWriteCommandData {
+                DM._jsonrpcAgentSocketWriteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._argumentsAgentSocketWriteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketWriteCommand cmdDat
+
+
+-- |
+-- 
+agentSocketWriteByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSocketWriteByteCommand dat = do
+  let cmdDat = DM.AgentSocketWriteByteCommandData {
+                DM._jsonrpcAgentSocketWriteByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._argumentsAgentSocketWriteByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketWriteByteCommand cmdDat
+
+
+-- |
+-- 
+agentSerialOpenCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSerialOpenCommand dat = do
+  let cmdDat = DM.AgentSerialOpenCommandData {
+                DM._jsonrpcAgentSerialOpenCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._nameAgentSerialOpenCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
+              , DM._argumentsAgentSerialOpenCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialOpenCommand cmdDat
+
+
+-- |
+-- 
+agentSerialCloseCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSerialCloseCommand dat = do
+  let cmdDat = DM.AgentSerialCloseCommandData {
+                DM._jsonrpcAgentSerialCloseCommandData = dat^.DM.jsonrpcMcpToolsCallRequestData
+              }
+  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialCloseCommand cmdDat
+
+
+-- |
+-- 
+agentSerialReadCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSerialReadCommand dat = do
+  let cmdDat = DM.AgentSerialReadCommandData {
+                DM._jsonrpcAgentSerialReadCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._argumentsAgentSerialReadCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialReadCommand cmdDat
+
+
+-- |
+-- 
+agentSerialReadByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSerialReadByteCommand dat = do
+  let cmdDat = DM.AgentSerialReadByteCommandData {
+                DM._jsonrpcAgentSerialReadByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._argumentsAgentSerialReadByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialReadByteCommand cmdDat
+
+
+-- |
+-- 
+agentSerialWriteCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSerialWriteCommand dat = do
+  let cmdDat = DM.AgentSerialWriteCommandData {
+                DM._jsonrpcAgentSerialWriteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._argumentsAgentSerialWriteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialWriteCommand cmdDat
+
+
+-- |
+-- 
+agentSerialWriteByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
+agentSerialWriteByteCommand dat = do
+  let cmdDat = DM.AgentSerialWriteByteCommandData {
+                DM._jsonrpcAgentSerialWriteByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
+              , DM._argumentsAgentSerialWriteByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
+              }
+  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
+  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialWriteByteCommand cmdDat
 
 
 -- |