diff --git a/lib/modules/core/core.go b/lib/modules/core/core.go
index ccb14dd..9aa5767 100644
--- a/lib/modules/core/core.go
+++ b/lib/modules/core/core.go
@@ -61,20 +61,15 @@
 
 // NewShell returns a new Shell instance with the core commands installed.
 func NewShell() *modules.Shell {
-	shell := modules.NewShell()
+	shell := modules.NewShell(".*")
 	Install(shell)
 	return shell
 }
 
 // Install installs the core commands into the supplied Shell.
 func Install(shell *modules.Shell) {
-	shell.AddSubprocess(RootMTCommand, "")
-	shell.AddSubprocess(MTCommand, `<mount point>
-	reads NAMESPACE_ROOT from its environment and mounts a new mount table at <mount point>`)
 	shell.AddFunction(LSCommand, ls, `<glob>...
 	issues glob requests using the current processes namespace library`)
-	shell.AddSubprocess(LSExternalCommand, `<glob>...
-	runs a subprocess to issue glob requests using the subprocesses namespace library`)
 	shell.AddFunction(ResolveCommand, resolveObject, `<name>
 	resolves name to obtain an object server address`)
 	shell.AddFunction(ResolveMTCommand, resolveMT, `<name>
@@ -89,8 +84,4 @@
 	turns the namespace cache on or off`)
 	shell.AddFunction(MountCommand, mountServer, `<mountpoint> <server> <ttl> [M][R]
 	invokes namespace.Mount(<mountpoint>, <server>, <ttl>)`)
-	shell.AddSubprocess(EchoClientCommand, `<name> <message>...
-	invokes name.Echo(message)`)
-	shell.AddSubprocess(EchoServerCommand, `<name> <text>
-	runs an Echo server mounted at <name> and configured to return <text>: as a prefix in its response`)
 }
diff --git a/lib/modules/core/echo.go b/lib/modules/core/echo.go
index 4a2e5a5..8456539 100644
--- a/lib/modules/core/echo.go
+++ b/lib/modules/core/echo.go
@@ -15,14 +15,14 @@
 )
 
 func init() {
-	modules.RegisterChild(EchoServerCommand, echoServer)
-	modules.RegisterChild(EchoClientCommand, echoClient)
+	modules.RegisterChild(EchoServerCommand, `<name> <message>...
+	invokes name.Echo(message)`, echoServer)
+	modules.RegisterChild(EchoClientCommand, `<name> <text>
+	runs an Echo server mounted at <name> and configured to return <text>: as a prefix in its response`, echoClient)
 }
 
 type treeDispatcher struct{ id string }
 
-var _ ipc.Dispatcher = (*treeDispatcher)(nil)
-
 func (d treeDispatcher) Lookup(suffix, method string) (ipc.Invoker, security.Authorizer, error) {
 	return ipc.ReflectInvoker(&echoServerObject{d.id, suffix}), nil, nil
 }
diff --git a/lib/modules/core/mounttable.go b/lib/modules/core/mounttable.go
index b013862..f1ff8fa 100644
--- a/lib/modules/core/mounttable.go
+++ b/lib/modules/core/mounttable.go
@@ -17,9 +17,12 @@
 )
 
 func init() {
-	modules.RegisterChild(RootMTCommand, rootMountTable)
-	modules.RegisterChild(MTCommand, mountTable)
-	modules.RegisterChild(LSExternalCommand, ls)
+	modules.RegisterChild(RootMTCommand, "", rootMountTable)
+	modules.RegisterChild(MTCommand, `<mount point>
+	reads NAMESPACE_ROOT from its environment and mounts a new mount table at <mount point>`, mountTable)
+	modules.RegisterChild(LSExternalCommand, `<glob>...
+	issues glob requests using the current processes namespace library`,
+		ls)
 }
 
 func mountTable(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
diff --git a/lib/modules/exec.go b/lib/modules/exec.go
index db7f7be..5ca6f09 100644
--- a/lib/modules/exec.go
+++ b/lib/modules/exec.go
@@ -6,6 +6,7 @@
 	"io"
 	"os"
 	"os/exec"
+	"regexp"
 	"strings"
 	"sync"
 	"time"
@@ -202,10 +203,10 @@
 
 const ShellEntryPoint = "VEYRON_SHELL_HELPER_PROCESS_ENTRY_POINT"
 
-func RegisterChild(name string, main Main) {
+func RegisterChild(name, help string, main Main) {
 	child.Lock()
 	defer child.Unlock()
-	child.mains[name] = main
+	child.mains[name] = &childEntryPoint{main, help}
 }
 
 // DispatchInTest will execute the requested subproccess command from within
@@ -238,16 +239,36 @@
 }
 
 func (child *childRegistrar) dispatch() error {
+	ch, _ := vexec.GetChildHandle()
+	// Only signal that the child is ready or failed if we successfully get
+	// a child handle. We most likely failed to get a child handle
+	// because the subprocess was run directly from the command line.
+
 	command := os.Getenv(ShellEntryPoint)
 	if len(command) == 0 {
-		return fmt.Errorf("Failed to find entrypoint %q", ShellEntryPoint)
+		err := fmt.Errorf("Failed to find entrypoint %q", ShellEntryPoint)
+		if ch != nil {
+			ch.SetFailed(err)
+		}
+		return err
 	}
+
 	child.Lock()
 	m := child.mains[command]
 	child.Unlock()
+
 	if m == nil {
-		return fmt.Errorf("Shell command %q not registered", command)
+		err := fmt.Errorf("Shell command %q not registered", command)
+		if ch != nil {
+			ch.SetFailed(err)
+		}
+		return err
 	}
+
+	if ch != nil {
+		ch.SetReady()
+	}
+
 	go func(pid int) {
 		for {
 			_, err := os.FindProcess(pid)
@@ -258,14 +279,34 @@
 			time.Sleep(time.Second)
 		}
 	}(os.Getppid())
-	ch, err := vexec.GetChildHandle()
-	if err == nil {
-		// Only signal that the child is ready if we successfully get
-		// a child handle. We most likely failed to get a child handle
-		// because the subprocess was run directly from the command line.
-		ch.SetReady()
+
+	return m.fn(os.Stdin, os.Stdout, os.Stderr, osEnvironMap(), flag.Args()...)
+}
+
+func (child *childRegistrar) addSubprocesses(sh *Shell, pattern string) error {
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return err
 	}
-	return m(os.Stdin, os.Stdout, os.Stderr, osEnvironMap(), flag.Args()...)
+	child.Lock()
+	defer child.Unlock()
+	found := false
+	for name, subproc := range child.mains {
+		if re.MatchString(name) {
+			sh.addSubprocess(name, subproc.help)
+			found = true
+		}
+	}
+	if !found {
+		return fmt.Errorf("patterh %q failed to match any registered commands", pattern)
+	}
+	return nil
+}
+
+// AddRegisteredSubprocesses adds any commands that match the regexp pattern
+// to the supplied shell.
+func AddRegisteredSubprocesses(sh *Shell, pattern string) error {
+	return child.addSubprocesses(sh, pattern)
 }
 
 // WaitForEof returns when a read on its io.Reader parameter returns io.EOF
diff --git a/lib/modules/modules_internal_test.go b/lib/modules/modules_internal_test.go
index c5e686e..f60b2bb 100644
--- a/lib/modules/modules_internal_test.go
+++ b/lib/modules/modules_internal_test.go
@@ -9,7 +9,7 @@
 )
 
 func init() {
-	RegisterChild("echos", Echo)
+	RegisterChild("echos", "[args]*", Echo)
 }
 
 func Echo(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
@@ -24,16 +24,14 @@
 
 func assertNumHandles(t *testing.T, sh *Shell, n int) {
 	if got, want := len(sh.handles), n; got != want {
-		_, file, line, _ := runtime.Caller(2)
+		_, file, line, _ := runtime.Caller(1)
 		t.Errorf("%s:%d: got %d, want %d", filepath.Base(file), line, got, want)
 	}
 }
 
 func TestState(t *testing.T) {
-	sh := NewShell()
-
+	sh := NewShell("echos")
 	sh.AddSubprocess("echonotregistered", "[args]*")
-	sh.AddSubprocess("echos", "[args]*")
 	sh.AddFunction("echof", Echo, "[args]*")
 	assertNumHandles(t, sh, 0)
 
diff --git a/lib/modules/modules_test.go b/lib/modules/modules_test.go
index 7320eb6..e4357ef 100644
--- a/lib/modules/modules_test.go
+++ b/lib/modules/modules_test.go
@@ -5,6 +5,7 @@
 	"bytes"
 	"fmt"
 	"io"
+	"os"
 	"testing"
 	"time"
 
@@ -12,9 +13,9 @@
 )
 
 func init() {
-	modules.RegisterChild("envtest", PrintEnv)
-	modules.RegisterChild("echo", Echo)
-	modules.RegisterChild("errortest", ErrorMain)
+	modules.RegisterChild("envtest", "envtest: <variables to print>...", PrintEnv)
+	modules.RegisterChild("echo", "[args]*", Echo)
+	modules.RegisterChild("errortest", "", ErrorMain)
 }
 
 func Echo(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
@@ -106,27 +107,37 @@
 }
 
 func TestChild(t *testing.T) {
-	sh := modules.NewShell()
+	sh := modules.NewShell("envtest")
 	defer sh.Cleanup(nil, nil)
 	key, val := "simpleVar", "foo & bar"
 	sh.SetVar(key, val)
-	sh.AddSubprocess("envtest", "envtest: <variables to print>...")
 	testCommand(t, sh, "envtest", key, val)
 }
 
+func TestChildNoRegistration(t *testing.T) {
+	sh := modules.NewShell()
+	defer sh.Cleanup(os.Stderr, os.Stderr)
+	key, val := "simpleVar", "foo & bar"
+	sh.SetVar(key, val)
+	testCommand(t, sh, "envtest", key, val)
+	_, err := sh.Start("non-existent-command", "random", "args")
+	if err == nil || err.Error() != `Shell command "non-existent-command" not registered` {
+		t.Fatalf("unexpected error %v", err)
+	}
+}
+
 func TestFunction(t *testing.T) {
-	sh := modules.NewShell()
+	sh := modules.NewShell(".*")
 	defer sh.Cleanup(nil, nil)
 	key, val := "simpleVar", "foo & bar & baz"
 	sh.SetVar(key, val)
-	sh.AddFunction("envtest", PrintEnv, "envtest: <variables to print>...")
-	testCommand(t, sh, "envtest", key, val)
+	sh.AddFunction("envtestf", PrintEnv, "envtest: <variables to print>...")
+	testCommand(t, sh, "envtestf", key, val)
 }
 
 func TestErrorChild(t *testing.T) {
-	sh := modules.NewShell()
+	sh := modules.NewShell("errortest")
 	defer sh.Cleanup(nil, nil)
-	sh.AddSubprocess("errortest", "")
 	h, err := sh.Start("errortest")
 	if err != nil {
 		t.Fatalf("unexpected error: %s", err)
@@ -160,8 +171,7 @@
 }
 
 func TestShutdownSubprocess(t *testing.T) {
-	sh := modules.NewShell()
-	sh.AddSubprocess("echo", "[args]*")
+	sh := modules.NewShell("echo")
 	testShutdown(t, sh)
 }
 
diff --git a/lib/modules/shell.go b/lib/modules/shell.go
index b467fbc..96ed5d5 100644
--- a/lib/modules/shell.go
+++ b/lib/modules/shell.go
@@ -42,7 +42,6 @@
 
 import (
 	"flag"
-	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -70,18 +69,28 @@
 	help    string
 }
 
-type childRegistrar struct {
-	sync.Mutex
-	mains map[string]Main
+type childEntryPoint struct {
+	fn   Main
+	help string
 }
 
-var child = &childRegistrar{mains: make(map[string]Main)}
+type childRegistrar struct {
+	sync.Mutex
+	mains map[string]*childEntryPoint
+}
+
+var child = &childRegistrar{mains: make(map[string]*childEntryPoint)}
 
 // NewShell creates a new instance of Shell. If this new instance is
 // is a test and no identity has been configured in the environment
 // via VEYRON_IDENTITY then CreateAndUseNewID will be used to configure a new
 // ID for the shell and its children.
-func NewShell() *Shell {
+// NewShell takes optional regexp patterns that can be used to specify
+// subprocess commands that are implemented in the same binary as this shell
+// (i.e. have been registered using modules.RegisterChild) to be
+// automatically added to it. If the patterns fail to match any such command
+// then they have no effect.
+func NewShell(patterns ...string) *Shell {
 	// TODO(cnicolaou): should create a new identity if one doesn't
 	// already exist
 	sh := &Shell{
@@ -94,6 +103,9 @@
 			panic(err)
 		}
 	}
+	for _, pattern := range patterns {
+		child.addSubprocesses(sh, pattern)
+	}
 	return sh
 }
 
@@ -125,10 +137,14 @@
 // as a subprocess. In addition, the child process must call RegisterChild
 // using the same name used here and provide the function to be executed
 // in the child.
-func (sh *Shell) AddSubprocess(name string, help string) {
+func (sh *Shell) AddSubprocess(name, help string) {
 	if !child.hasCommand(name) {
 		vlog.Infof("Warning: %q is not registered with modules.Dispatcher", name)
 	}
+	sh.addSubprocess(name, help)
+}
+
+func (sh *Shell) addSubprocess(name string, help string) {
 	entryPoint := ShellEntryPoint + "=" + name
 	sh.mu.Lock()
 	sh.cmds[name] = &commandDesc{func() command { return newExecHandle(entryPoint) }, help}
@@ -168,15 +184,22 @@
 // Start starts the specified command, it returns a Handle which can be used
 // for interacting with that command. The Shell tracks all of the Handles
 // that it creates so that it can shut them down when asked to.
-func (sh *Shell) Start(command string, args ...string) (Handle, error) {
+// Commands may have already been registered with the Shell using AddFunction
+// or AddSubprocess, but if not, they will treated as subprocess commands
+// and an attempt made to run them. Such 'dynamically' started subprocess
+// commands are not remembered the by Shell and do not provide a 'help'
+// message etc; their handles are remembered and will be acted on by
+// the Cleanup method. If the non-registered subprocess command does not
+// exist then the Start command will return an error.
+func (sh *Shell) Start(name string, args ...string) (Handle, error) {
 	sh.mu.Lock()
-	cmd := sh.cmds[command]
-	if cmd == nil {
-		sh.mu.Unlock()
-		return nil, fmt.Errorf("command %q is not available", command)
-	}
-	expanded := append([]string{command}, sh.expand(args...)...)
+	cmd := sh.cmds[name]
 	sh.mu.Unlock()
+	if cmd == nil {
+		entryPoint := ShellEntryPoint + "=" + name
+		cmd = &commandDesc{func() command { return newExecHandle(entryPoint) }, ""}
+	}
+	expanded := append([]string{name}, sh.expand(args...)...)
 	h, err := cmd.factory().start(sh, expanded...)
 	if err != nil {
 		return nil, err
diff --git a/lib/signals/signals_test.go b/lib/signals/signals_test.go
index 3114304..ade0df3 100644
--- a/lib/signals/signals_test.go
+++ b/lib/signals/signals_test.go
@@ -33,10 +33,10 @@
 }
 
 func init() {
-	modules.RegisterChild("handleDefaults", handleDefaults)
-	modules.RegisterChild("handleCustom", handleCustom)
-	modules.RegisterChild("handleCustomWithStop", handleCustomWithStop)
-	modules.RegisterChild("handleDefaultsIgnoreChan", handleDefaultsIgnoreChan)
+	modules.RegisterChild("handleDefaults", "", handleDefaults)
+	modules.RegisterChild("handleCustom", "", handleCustom)
+	modules.RegisterChild("handleCustomWithStop", "", handleCustomWithStop)
+	modules.RegisterChild("handleDefaultsIgnoreChan", "", handleDefaultsIgnoreChan)
 }
 
 func stopLoop(stdin io.Reader, ch chan<- struct{}) {