@@ -437,7 +437,7 @@ async with await runloop.devbox.create(name="temp-devbox") as devbox:
 
 #### Devbox Logs
 
-Retrieve logs from a devbox, optionally filtered by execution ID or shell name:
+Retrieve logs from a devbox, optionally filtered by execution ID:
 
 ```python
 # Get all devbox logs
@@ -448,17 +448,14 @@ for log in logs.logs:
 # Filter logs by execution ID
 result = devbox.cmd.exec('echo "hello"')
 exec_logs = devbox.logs(execution_id=result.execution_id)
-
-# Filter logs by shell name
-shell_logs = devbox.logs(shell_name="my-shell")
 ```
 
 **Key methods:**
 
 - `devbox.get_info()` - Get devbox details and status
 - `devbox.cmd.exec()` - Execute commands synchronously
 - `devbox.cmd.exec_async()` - Execute commands asynchronously
-- `devbox.logs()` - Retrieve devbox logs (optionally filter by execution_id or shell_name)
+- `devbox.logs()` - Retrieve devbox logs (optionally filter by execution_id)
 - `devbox.file.read()` - Read file contents
 - `devbox.file.write()` - Write file contents
 - `devbox.file.upload()` - Upload files
 
@@ -33,15 +33,15 @@
     AsyncNetworkPolicyOps,
     AsyncStorageObjectOps,
 )
-from .devbox import Devbox, NamedShell
+from .devbox import Devbox
 from .secret import Secret
 from .snapshot import Snapshot
 from .blueprint import Blueprint
 from .execution import Execution
 from .async_axon import AsyncAxon, AsyncAxonSqlOps
 from .mcp_config import McpConfig
 from .async_agent import AsyncAgent
-from .async_devbox import AsyncDevbox, AsyncNamedShell
+from .async_devbox import AsyncDevbox
 from .async_secret import AsyncSecret
 from .secret_by_id import SecretById
 from .async_snapshot import AsyncSnapshot
@@ -113,6 +113,4 @@
     "AsyncMcpConfig",
     "GatewayConfig",
     "AsyncGatewayConfig",
-    "NamedShell",
-    "AsyncNamedShell",
 ]
@@ -37,7 +37,6 @@
 from ..types.devbox_create_params import DevboxBaseCreateParams
 from ..types.axons.sql_batch_params import SqlBatchParams
 from ..types.axons.sql_query_params import SqlQueryParams
-from ..types.devbox_execute_async_params import DevboxNiceExecuteAsyncParams
 
 LogCallback = Callable[[str], None]
 
@@ -89,11 +88,17 @@ class SDKDevboxCreateFromImageParams(DevboxBaseCreateParams, LongPollingRequestO
     pass
 
 
-class SDKDevboxExecuteParams(DevboxNiceExecuteAsyncParams, ExecuteStreamingCallbacks, LongPollingRequestOptions):
+class DevboxCommandOptions(TypedDict, total=False):
+    """Optional API fields shared by command execution helpers."""
+
+    attach_stdin: Optional[bool]
+
+
+class SDKDevboxExecuteParams(DevboxCommandOptions, ExecuteStreamingCallbacks, LongPollingRequestOptions):
     pass
 
 
-class SDKDevboxExecuteAsyncParams(DevboxNiceExecuteAsyncParams, ExecuteStreamingCallbacks, LongRequestOptions):
+class SDKDevboxExecuteAsyncParams(DevboxCommandOptions, ExecuteStreamingCallbacks, LongRequestOptions):
     pass
 
 
 
@@ -17,6 +17,7 @@
     LogCallback,
     BaseRequestOptions,
     LongRequestOptions,
+    DevboxCommandOptions,
     PollingRequestOptions,
     SDKDevboxExecuteParams,
     ExecuteStreamingCallbacks,
@@ -38,7 +39,6 @@
 from ..types.devboxes import ExecutionUpdateChunk
 from .async_execution import AsyncExecution, _AsyncStreamingGroup
 from .async_execution_result import AsyncExecutionResult
-from ..types.devbox_execute_async_params import DevboxNiceExecuteAsyncParams
 from ..types.devboxes.devbox_logs_list_view import DevboxLogsListView
 from ..types.devbox_async_execution_detail_view import DevboxAsyncExecutionDetailView
 
@@ -168,18 +168,15 @@ async def logs(
         self,
         *,
         execution_id: str | None = None,
-        shell_name: str | None = None,
         **options: Unpack[BaseRequestOptions],
     ) -> DevboxLogsListView:
         """Retrieve logs for the devbox.
 
         Returns all logs from a running or completed devbox. Optionally filter
-        by execution ID or shell name.
+        by execution ID.
 
         :param execution_id: Filter logs by execution ID, defaults to None
         :type execution_id: str | None, optional
-        :param shell_name: Filter logs by shell name, defaults to None
-        :type shell_name: str | None, optional
         :param options: Optional request configuration
         :return: Log entries for the devbox
         :rtype: :class:`~runloop_api_client.types.devboxes.devbox_logs_list_view.DevboxLogsListView`
@@ -192,7 +189,6 @@ async def logs(
         return await self._client.devboxes.logs.list(
             self._id,
             execution_id=execution_id if execution_id is not None else omit,
-            shell_name=shell_name if shell_name is not None else omit,
             **options,
         )
 
@@ -376,39 +372,6 @@ def net(self) -> AsyncNetworkInterface:
         """
         return AsyncNetworkInterface(self)
 
-    def shell(self, shell_name: str | None = None) -> AsyncNamedShell:
-        """Create a named shell instance for stateful command execution.
-
-        Named shells are stateful and maintain environment variables and the current working
-        directory (CWD) across commands, just like a real shell on your local computer.
-        Commands executed through the same named shell instance will execute sequentially -
-        the shell can only run one command at a time with automatic queuing. This ensures
-        that environment changes and directory changes from one command are preserved for
-        the next command.
-
-        :param shell_name: The name of the persistent shell session. If not provided, a UUID will be generated automatically.
-        :type shell_name: str | None, optional
-        :return: An AsyncNamedShell instance for executing commands in the named shell
-        :rtype: AsyncNamedShell
-
-        Example:
-            >>> # Create a named shell with a custom name
-            >>> shell = await devbox.shell("my-session")
-            >>> # Create a named shell with an auto-generated UUID name
-            >>> shell2 = await devbox.shell()
-            >>> # Commands execute sequentially and share state
-            >>> await shell.exec("cd /app")
-            >>> await shell.exec("export MY_VAR=value")
-            >>> result = await shell.exec("echo $MY_VAR")  # Will output 'value'
-            >>> result = await shell.exec("pwd")  # Will output '/app'
-        """
-        if shell_name is None:
-            # uuid_utils is not typed
-            from uuid_utils import uuid7  # type: ignore
-
-            shell_name = str(uuid7())
-        return AsyncNamedShell(self, shell_name)
-
     # ------------------------------------------------------------------ #
     # Internal helpers
     # ------------------------------------------------------------------ #
@@ -519,7 +482,7 @@ async def exec(
         execution: DevboxAsyncExecutionDetailView = await client.devboxes.execute_async(
             devbox.id,
             command=command,
-            **filter_params(params, DevboxNiceExecuteAsyncParams),
+            **filter_params(params, DevboxCommandOptions),
             **filter_params(params, LongRequestOptions),
         )
         streaming_group = devbox._start_streaming(
@@ -579,7 +542,7 @@ async def exec_async(
         execution: DevboxAsyncExecutionDetailView = await client.devboxes.execute_async(
             devbox.id,
             command=command,
-            **filter_params(params, DevboxNiceExecuteAsyncParams),
+            **filter_params(params, DevboxCommandOptions),
             **filter_params(params, LongRequestOptions),
         )
 
@@ -681,103 +644,6 @@ async def upload(
         )
 
 
-class AsyncNamedShell:
-    """Interface for executing commands in a persistent, stateful shell session.
-
-    Named shells are stateful and maintain environment variables and the current working
-    directory (CWD) across commands. Commands executed through the same named shell
-    instance will execute sequentially - the shell can only run one command at a time
-    with automatic queuing. This ensures that environment changes and directory changes
-    from one command are preserved for the next command.
-
-    Use :meth:`AsyncDevbox.shell` to create a named shell instance. If you use the same
-    shell name, it will re-attach to the existing named shell, preserving its state.
-
-    Example:
-        >>> shell = await devbox.shell("my-session")
-        >>> await shell.exec("cd /app")
-        >>> await shell.exec("export MY_VAR=value")
-        >>> result = await shell.exec("echo $MY_VAR")  # Will output 'value'
-        >>> result = await shell.exec("pwd")  # Will output '/app'
-    """
-
-    def __init__(self, devbox: AsyncDevbox, shell_name: str) -> None:
-        """Initialize the named shell.
-
-        :param devbox: The async devbox instance to execute commands on
-        :type devbox: AsyncDevbox
-        :param shell_name: The name of the persistent shell session
-        :type shell_name: str
-        """
-        self._devbox = devbox
-        self._shell_name = shell_name
-
-    async def exec(
-        self,
-        command: str,
-        **params: Unpack[SDKDevboxExecuteParams],
-    ) -> AsyncExecutionResult:
-        """Execute a command in the named shell and wait for it to complete.
-
-        The command will execute in the persistent shell session, maintaining environment
-        variables and the current working directory from previous commands. Commands are
-        queued and execute sequentially - only one command runs at a time in the named shell.
-
-        Optionally provide callbacks to stream logs in real-time. When callbacks are provided,
-        this method waits for both the command to complete AND all streaming data to be
-        processed before returning.
-
-        :param command: The command to execute
-        :type command: str
-        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKDevboxExecuteParams` for available parameters
-        :return: Wrapper with exit status and output helpers
-        :rtype: AsyncExecutionResult
-
-        Example:
-            >>> shell = await devbox.shell("my-session")
-            >>> result = await shell.exec("ls -la")
-            >>> print(await result.stdout())
-            >>> # With streaming callbacks
-            >>> result = await shell.exec("npm install", stdout=lambda line: print(f"[LOG] {line}"))
-        """
-        # Ensure shell_name is set and cannot be overridden by user params
-        params["shell_name"] = self._shell_name
-        return await self._devbox.cmd.exec(command, **params)
-
-    async def exec_async(
-        self,
-        command: str,
-        **params: Unpack[SDKDevboxExecuteAsyncParams],
-    ) -> AsyncExecution:
-        """Execute a command in the named shell asynchronously without waiting for completion.
-
-        The command will execute in the persistent shell session, maintaining environment
-        variables and the current working directory from previous commands. Commands are
-        queued and execute sequentially - only one command runs at a time in the named shell.
-
-        Optionally provide callbacks to stream logs in real-time as they are produced.
-        Callbacks fire in real-time as logs arrive. When you call execution.result(),
-        it will wait for both the command to complete and all streaming to finish.
-
-        :param command: The command to execute
-        :type command: str
-        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKDevboxExecuteAsyncParams` for available parameters
-        :return: Handle for managing the running process
-        :rtype: AsyncExecution
-
-        Example:
-            >>> shell = await devbox.shell("my-session")
-            >>> execution = await shell.exec_async("long-running-task.sh", stdout=lambda line: print(f"[LOG] {line}"))
-            >>> # Do other work while command runs...
-            >>> result = await execution.result()
-            >>> if result.success:
-            ...     print("Task completed successfully!")
-        """
-        # Ensure shell_name is set and cannot be overridden by user params
-        params["shell_name"] = self._shell_name
-        return await self._devbox.cmd.exec_async(command, **params)
-
-
 class AsyncNetworkInterface:
     """Interface for networking operations on a devbox.