diff --git a/DevReadMe.md b/DevReadMe.md
index 90aea1e2ab..cc848881f8 100644
--- a/DevReadMe.md
+++ b/DevReadMe.md
@@ -48,30 +48,31 @@ Currently you must specify at least one _inbound_ and one _outbound_ transport.
 For example:
 
 ```bash
-aca-py      --inbound-transport http 0.0.0.0 8000 \
-            --outbound-transport http
+aca-py start    --inbound-transport http 0.0.0.0 8000 \
+                --outbound-transport http
 ```
 
 or
 
 ```bash
-aca-py      --inbound-transport http 0.0.0.0 8000 \
-            --inbound-transport ws 0.0.0.0 8001 \
-            --outbound-transport ws \
-            --outbound-transport http
+aca-py start    --inbound-transport http 0.0.0.0 8000 \
+                --inbound-transport ws 0.0.0.0 8001 \
+                --outbound-transport ws \
+                --outbound-transport http
 ```
 
 Currently, Aries Cloud Agent Python ships with both inbound and outbound transport drivers for `http` and `websockets`. More information on how to develop your own transports will be coming soon.
 
 Most configuration parameters are provided to the the agent at startup. Refer to the section below for details on all available command-line arguments.
 
-## Command Line Arguments
+### Command Line Arguments
 
 | **argument**                          | **format example**                                                                                                                            | **effect**                                                                                                                                                                                                                              | **required** |
 | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
 | `--inbound-transport`, `-it`          | `--inbound-transport http 0.0.0.0 8000`                                                                                                       | Defines the inbound transport(s) to listen on. This parameter can be passed multiple times to create multiple interfaces. Supported internal transport types are `http` and `ws`.                                                       | `true`       |
 | `--outbound-transport`, `-ot`         | `--outbound-transport http`                                                                                                                   | Defines the outbound transport(s) to support for outgoing messages. This parameter can be passed multiple times to supoort multiple transport types. Supported internal transport types are `http` and `ws`.                            | `true`       |
 | `--log-config`                        | `--log-config /path/to/log/config.ini`                                                                                                        | Provides a custom [python logging config file](https://docs.python.org/3/library/logging.config.html#logging-config-fileformat) to use. By default, a [default logging config](config/default_logging_config.ini) is used.              | `false`      |
+| `--log-file`                        | `--log-file /path/to/logfile`                                                                                                        | Overrides the output destination for the root logger as defined by the log config file.              | `false`      |
 | `--log-level`                         | `--log-level debug`                                                                                                                           | Specifies the python log level.                                                                                                                                                                                                         | `false`      |
 | `--endpoint`, `-e`                    | `--endpoint https://example.com/agent-endpoint`                                                                                               | Specifies the endpoint for which other agents should contact this agent. This endpoint could point to a different agent if routing is configured. The endpoint is used in the formation of a connection with another agent.             | `false`      |
 | `--label`, `-l`                       | `--label "My Agent"`                                                                                                                          | Specifies the label for this agent. This label is publicized to other agents as part of forming a connection.                                                                                                                           | `false`      |
@@ -106,6 +107,16 @@ Most configuration parameters are provided to the the agent at startup. Refer to
 | `--protocol`                          | `--protocol`                                                                                                                                  | Instructs the agent to load an external protocol module.                                                                                                                                                                                | `false`      |
 | `--webhook-url`                       | `--webhook-url`                                                                                                                               | Instructs the agent to send webhooks containing internal state changes to a URL. This is useful for a controller to monitor changes and prompt new behaviour using the admin API.                                                       | `false`      |
 
+### Provisioning a Wallet
+
+It is possible to provision an Indy wallet before running an agent to avoid passing in the wallet seed on every invocation of `aca-py start`.
+
+```bash
+aca-py provision wallet --wallet-type indy --seed $SEED
+```
+
+For additional options, execute `aca-py provision --help`.
+
 ## Developing
 
 ### Prerequisites
diff --git a/aries_cloudagent/__init__.py b/aries_cloudagent/__init__.py
index c5389c6d5b..cefa9c5404 100644
--- a/aries_cloudagent/__init__.py
+++ b/aries_cloudagent/__init__.py
@@ -1,101 +1 @@
-"""Entrypoint."""
-
-import asyncio
-import functools
-import os
-import signal
-
-from aiohttp import ClientSession
-
-from .conductor import Conductor
-from .config.argparse import get_settings, parse_args
-from .config.default_context import DefaultContextBuilder
-from .config.logging import LoggingConfigurator
-from .postgres import load_postgres_plugin
-
-
-async def get_genesis_transactions(genesis_url: str):
-    """Get genesis transactions."""
-    headers = {}
-    headers["Content-Type"] = "application/json"
-    async with ClientSession() as client_session:
-        response = await client_session.get(genesis_url, headers=headers)
-        genesis_txns = await response.text()
-        return genesis_txns
-
-
-async def start_app(conductor: Conductor):
-    """Start up."""
-    await conductor.setup()
-    await conductor.start()
-
-
-async def shutdown_app(conductor: Conductor):
-    """Shut down."""
-    print("\nShutting down")
-    await conductor.stop()
-    tasks = [
-        task
-        for task in asyncio.Task.all_tasks()
-        if task is not asyncio.tasks.Task.current_task()
-    ]
-    for task in tasks:
-        task.cancel()
-    await asyncio.gather(*tasks, return_exceptions=True)
-    asyncio.get_event_loop().stop()
-
-
-def main():
-    """Entrypoint."""
-    args = parse_args()
-    settings = get_settings(args)
-
-    # Set up logging
-    log_config = settings.get("log.config")
-    log_level = settings.get("log.level") or os.getenv("LOG_LEVEL")
-    LoggingConfigurator.configure(log_config, log_level)
-
-    # Fetch genesis transactions if necessary
-    if not settings.get("ledger.genesis_transactions") and settings.get(
-        "ledger.genesis_url"
-    ):
-        loop = asyncio.get_event_loop()
-        settings["ledger.genesis_transactions"] = loop.run_until_complete(
-            get_genesis_transactions(settings["ledger.genesis_url"])
-        )
-
-    # Load postgres plug-in if necessary
-    if (
-        settings.get("wallet.type")
-        and settings.get("wallet.storage_type") == "postgres_storage"
-    ):
-        if args.wallet_storage_type == "postgres_storage":
-            load_postgres_plugin()
-
-    # Support WEBHOOK_URL environment variable
-    webhook_url = os.environ.get("WEBHOOK_URL")
-    if webhook_url:
-        webhook_urls = list(settings.get("admin.webhook_urls") or [])
-        webhook_urls.append(webhook_url)
-        settings["admin.webhook_urls"] = webhook_urls
-
-    # Create the Conductor instance
-    context_builder = DefaultContextBuilder(settings)
-    conductor = Conductor(context_builder)
-
-    # Run the application
-    loop = asyncio.get_event_loop()
-    loop.add_signal_handler(
-        signal.SIGTERM,
-        functools.partial(asyncio.ensure_future, shutdown_app(conductor), loop=loop),
-    )
-    asyncio.ensure_future(start_app(conductor), loop=loop)
-
-    try:
-        loop.run_forever()
-    except KeyboardInterrupt:
-        loop.run_until_complete(shutdown_app(conductor))
-
-
-if __name__ == "__main__":
-    main()  # pragma: no cover
+"""Aries Cloud Agent."""
diff --git a/aries_cloudagent/commands/__init__.py b/aries_cloudagent/commands/__init__.py
new file mode 100644
index 0000000000..57d6388aa3
--- /dev/null
+++ b/aries_cloudagent/commands/__init__.py
@@ -0,0 +1,35 @@
+"""Commands module common setup."""
+
+from importlib import import_module
+from typing import Sequence
+
+
+def available_commands():
+    """Index available commands."""
+    return [
+        {"name": "help", "summary": "Print available commands"},
+        {"name": "provision", "summary": "Provision an agent"},
+        {"name": "start", "summary": "Start a new agent process"},
+    ]
+
+
+def load_command(command: str):
+    """Load the module corresponding with a named command."""
+    module = None
+    module_path = None
+    for cmd in available_commands():
+        if cmd["name"] == command:
+            module = cmd["name"]
+            if "module" in cmd:
+                module_path = cmd["module"]
+            break
+    if module and not module_path:
+        module_path = f"{__package__}.{module}"
+    if module_path:
+        return import_module(module_path)
+
+
+def run_command(command: str, argv: Sequence[str] = None):
+    """Execute a named command with command line arguments."""
+    module = load_command(command) or load_command("help")
+    module.execute(argv)
diff --git a/aries_cloudagent/commands/help.py b/aries_cloudagent/commands/help.py
new file mode 100644
index 0000000000..84904fb496
--- /dev/null
+++ b/aries_cloudagent/commands/help.py
@@ -0,0 +1,23 @@
+"""Help command for indexing available commands."""
+
+from argparse import ArgumentParser
+from typing import Sequence
+
+
+def execute(argv: Sequence[str] = None):
+    """Execute the help command."""
+    from . import available_commands, load_command
+
+    parser = ArgumentParser()
+    subparsers = parser.add_subparsers()
+    for cmd in available_commands():
+        if cmd["name"] == "help":
+            continue
+        module = load_command(cmd["name"])
+        subparser = subparsers.add_parser(cmd["name"], help=cmd["summary"])
+        module.init_argument_parser(subparser)
+    parser.print_help()
+
+
+if __name__ == "__main__":
+    execute()
diff --git a/aries_cloudagent/commands/provision.py b/aries_cloudagent/commands/provision.py
new file mode 100644
index 0000000000..555bc5c48a
--- /dev/null
+++ b/aries_cloudagent/commands/provision.py
@@ -0,0 +1,84 @@
+"""Provision command for setting up agent settings before starting."""
+
+import asyncio
+from argparse import ArgumentParser
+from typing import Sequence
+
+from ..config import argparse as arg
+from ..config.default_context import DefaultContextBuilder
+from ..config.util import common_config
+from ..error import BaseError
+from ..wallet.base import BaseWallet
+from ..wallet.crypto import seed_to_did
+
+
+class ProvisionError(BaseError):
+    """Base exception for provisioning errors."""
+
+
+def init_argument_parser(parser: ArgumentParser):
+    """Initialize an argument parser with the module's arguments."""
+    return arg.load_argument_groups(
+        parser, *arg.group.get_registered(arg.CAT_PROVISION)
+    )
+
+
+async def provision(category: str, settings: dict):
+    """Perform provisioning."""
+    context_builder = DefaultContextBuilder(settings)
+    context = await context_builder.build()
+
+    if category == "wallet":
+        # Initialize wallet
+        wallet: BaseWallet = await context.inject(BaseWallet)
+        if wallet.type != "indy":
+            raise ProvisionError("Cannot provision a non-Indy wallet type")
+        if wallet.created:
+            print("Created new wallet")
+        else:
+            print("Opened existing wallet")
+        print("Wallet type:", wallet.type)
+        print("Wallet name:", wallet.name)
+        wallet_seed = context.settings.get("wallet.seed")
+        public_did_info = await wallet.get_public_did()
+        if public_did_info:
+            # If we already have a registered public did and it doesn't match
+            # the one derived from `wallet_seed` then we error out.
+            # TODO: Add a command to change public did explicitly
+            if wallet_seed and seed_to_did(wallet_seed) != public_did_info.did:
+                raise ProvisionError(
+                    "New seed provided which doesn't match the registered"
+                    + f" public did {public_did_info.did}"
+                )
+        elif wallet_seed:
+            public_did_info = await wallet.create_public_did(seed=wallet_seed)
+            print("Created new public DID")
+        if public_did_info:
+            print("Public DID:", public_did_info.did)
+            print("Verkey:", public_did_info.verkey)
+        else:
+            print("No public DID")
+
+
+def execute(argv: Sequence[str] = None):
+    """Entrypoint."""
+    parser = ArgumentParser()
+    parser.prog += " provision"
+    parser.add_argument(
+        dest="provision_category",
+        type=str,
+        metavar=("<category>"),
+        choices=["wallet"],
+        help="The provision command to invoke",
+    )
+    get_settings = init_argument_parser(parser)
+    args = parser.parse_args(argv)
+    settings = get_settings(args)
+    common_config(settings)
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(provision(args.provision_category, settings))
+
+
+if __name__ == "__main__":
+    execute()
diff --git a/aries_cloudagent/commands/start.py b/aries_cloudagent/commands/start.py
new file mode 100644
index 0000000000..b72dba912f
--- /dev/null
+++ b/aries_cloudagent/commands/start.py
@@ -0,0 +1,87 @@
+"""Entrypoint."""
+
+import asyncio
+import functools
+import os
+import signal
+from argparse import ArgumentParser
+from typing import Coroutine, Sequence
+
+from ..conductor import Conductor
+from ..config import argparse as arg
+from ..config.default_context import DefaultContextBuilder
+from ..config.util import common_config
+
+
+async def start_app(conductor: Conductor):
+    """Start up."""
+    await conductor.setup()
+    await conductor.start()
+
+
+async def shutdown_app(conductor: Conductor):
+    """Shut down."""
+    print("\nShutting down")
+    await conductor.stop()
+
+
+def init_argument_parser(parser: ArgumentParser):
+    """Initialize an argument parser with the module's arguments."""
+    return arg.load_argument_groups(parser, *arg.group.get_registered(arg.CAT_START))
+
+
+def execute(argv: Sequence[str] = None):
+    """Entrypoint."""
+    parser = ArgumentParser()
+    parser.prog += " start"
+    get_settings = init_argument_parser(parser)
+    args = parser.parse_args(argv)
+    settings = get_settings(args)
+    common_config(settings)
+
+    # Support WEBHOOK_URL environment variable
+    webhook_url = os.environ.get("WEBHOOK_URL")
+    if webhook_url:
+        webhook_urls = list(settings.get("admin.webhook_urls") or [])
+        webhook_urls.append(webhook_url)
+        settings["admin.webhook_urls"] = webhook_urls
+
+    # Create the Conductor instance
+    context_builder = DefaultContextBuilder(settings)
+    conductor = Conductor(context_builder)
+
+    # Run the application
+    run_loop(start_app(conductor), shutdown_app(conductor))
+
+
+def run_loop(startup: Coroutine, shutdown: Coroutine):
+    """Execute the application, handling signals and ctrl-c."""
+
+    async def done():
+        """Run shutdown and clean up any outstanding tasks."""
+        await shutdown
+        tasks = [
+            task
+            for task in asyncio.Task.all_tasks()
+            if task is not asyncio.Task.current_task()
+        ]
+        for task in tasks:
+            task.cancel()
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        asyncio.get_event_loop().stop()
+
+    loop = asyncio.get_event_loop()
+    loop.add_signal_handler(
+        signal.SIGTERM, functools.partial(asyncio.ensure_future, done(), loop=loop)
+    )
+    asyncio.ensure_future(startup, loop=loop)
+
+    try:
+        loop.run_forever()
+    except KeyboardInterrupt:
+        loop.run_until_complete(done())
+
+
+if __name__ == "__main__":
+    execute()
diff --git a/aries_cloudagent/commands/tests/__init__.py b/aries_cloudagent/commands/tests/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/aries_cloudagent/commands/tests/test_help.py b/aries_cloudagent/commands/tests/test_help.py
new file mode 100644
index 0000000000..ecaaf4a431
--- /dev/null
+++ b/aries_cloudagent/commands/tests/test_help.py
@@ -0,0 +1,9 @@
+from asynctest import TestCase as AsyncTestCase
+from asynctest import mock as async_mock
+
+from .. import help as command
+
+
+class TestHelp(AsyncTestCase):
+    def test_exec_help(self):
+        command.execute([])
diff --git a/aries_cloudagent/commands/tests/test_provision.py b/aries_cloudagent/commands/tests/test_provision.py
new file mode 100644
index 0000000000..1aac05a42a
--- /dev/null
+++ b/aries_cloudagent/commands/tests/test_provision.py
@@ -0,0 +1,23 @@
+from asynctest import TestCase as AsyncTestCase
+from asynctest import mock as async_mock
+import pytest
+
+from .. import provision as command
+
+
+class TestProvision(AsyncTestCase):
+    def test_bad_category(self):
+        with async_mock.patch.object(
+            command.ArgumentParser, "print_usage"
+        ) as print_usage:
+            with self.assertRaises(SystemExit):
+                command.execute([])
+            print_usage.assert_called_once()
+
+        with self.assertRaises(SystemExit):
+            command.execute(["bad"])
+
+    @pytest.mark.indy
+    def test_provision_wallet(self):
+        test_seed = "testseed000000000000000000000001"
+        command.execute(["wallet", "--wallet-type", "indy", "--seed", test_seed])
diff --git a/aries_cloudagent/commands/tests/test_start.py b/aries_cloudagent/commands/tests/test_start.py
new file mode 100644
index 0000000000..5c7b25ba0f
--- /dev/null
+++ b/aries_cloudagent/commands/tests/test_start.py
@@ -0,0 +1,57 @@
+from asynctest import TestCase as AsyncTestCase
+from asynctest import mock as async_mock
+
+from .. import start as command
+
+
+class TestStart(AsyncTestCase):
+    def test_bad_args(self):
+        with async_mock.patch.object(
+            command.ArgumentParser, "print_usage"
+        ) as print_usage:
+            with self.assertRaises(SystemExit):
+                command.execute([])
+            print_usage.assert_called_once()
+
+        with self.assertRaises(SystemExit):
+            command.execute(["bad"])
+
+    def test_exec_start(self):
+        with async_mock.patch.object(
+            command, "start_app", autospec=True
+        ) as start_app, async_mock.patch.object(
+            command, "run_loop"
+        ) as run_loop, async_mock.patch.object(
+            command, "shutdown_app", autospec=True
+        ) as shutdown_app:
+            command.execute(["-it", "http", "0.0.0.0", "80", "-ot", "http"])
+            start_app.assert_called_once()
+            assert isinstance(start_app.call_args[0][0], command.Conductor)
+            shutdown_app.assert_called_once()
+            assert isinstance(shutdown_app.call_args[0][0], command.Conductor)
+            run_loop.assert_called_once()
+
+    async def test_run_loop(self):
+        startup = async_mock.CoroutineMock()
+        startup_call = startup()
+        shutdown = async_mock.CoroutineMock()
+        shutdown_call = shutdown()
+        with async_mock.patch.object(command, "asyncio", autospec=True) as mock_asyncio:
+            command.run_loop(startup_call, shutdown_call)
+            mock_asyncio.get_event_loop.return_value.add_signal_handler.assert_called_once()
+            mock_asyncio.ensure_future.assert_called_once_with(
+                startup_call, loop=mock_asyncio.get_event_loop.return_value
+            )
+            mock_asyncio.get_event_loop.return_value.run_forever.assert_called_once()
+
+            done_calls = (
+                mock_asyncio.get_event_loop.return_value.add_signal_handler.call_args
+            )
+            done_calls[0][1]()  # exec partial
+            done_coro = mock_asyncio.ensure_future.call_args[0][0]
+            task = async_mock.MagicMock()
+            mock_asyncio.gather = async_mock.CoroutineMock()
+            mock_asyncio.Task.all_tasks.return_value = [task]
+            mock_asyncio.Task.current_task.return_value = task
+            await done_coro
+            shutdown.assert_awaited_once()
diff --git a/aries_cloudagent/config/argparse.py b/aries_cloudagent/config/argparse.py
index 0993473b94..63b29b8d0f 100644
--- a/aries_cloudagent/config/argparse.py
+++ b/aries_cloudagent/config/argparse.py
@@ -1,393 +1,533 @@
 """Command line option parsing."""
 
+import abc
 import os
-import argparse
-from typing import Sequence
+
+from argparse import ArgumentParser, Namespace
+from typing import Type
 
 from .error import ArgsParseError
 
-PARSER = argparse.ArgumentParser(description="Runs an Aries Cloud Agent.")
-
-
-PARSER.add_argument(
-    "-it",
-    "--inbound-transport",
-    dest="inbound_transports",
-    type=str,
-    action="append",
-    nargs=3,
-    required=True,
-    metavar=("<module>", "<host>", "<port>"),
-    help="Choose which interface(s) to listen on",
-)
-
-PARSER.add_argument(
-    "-ot",
-    "--outbound-transport",
-    dest="outbound_transports",
-    type=str,
-    action="append",
-    required=True,
-    metavar="<module>",
-    help="Choose which outbound transport handlers to register",
-)
-
-PARSER.add_argument(
-    "--log-config",
-    dest="log_config",
-    type=str,
-    metavar="<path-to-config>",
-    default=None,
-    help="Specifies a custom logging configuration file",
-)
-
-PARSER.add_argument(
-    "--log-level",
-    dest="log_level",
-    type=str,
-    metavar="<log-level>",
-    default=None,
-    help="Specifies a custom logging level "
-    + "(debug, info, warning, error, critical)",
-)
-
-PARSER.add_argument(
-    "-e",
-    "--endpoint",
-    type=str,
-    metavar="<endpoint>",
-    help="Specify the default endpoint to use when "
-    + "creating connection invitations and requests",
-)
-
-PARSER.add_argument(
-    "-l",
-    "--label",
-    type=str,
-    metavar="<label>",
-    help="Specify the default label to use when creating"
-    + " connection invitations and requests",
-)
-
-
-PARSER.add_argument(
-    "--seed",
-    type=str,
-    metavar="<wallet-seed>",
-    help="Seed to use when creating the public DID",
-)
-
-PARSER.add_argument(
-    "--storage-type",
-    type=str,
-    metavar="<storage-type>",
-    help="Specify the storage implementation to use",
-)
-
-PARSER.add_argument(
-    "--wallet-key",
-    type=str,
-    metavar="<wallet-key>",
-    help="Specify the master key value to use when opening the wallet",
-)
-
-PARSER.add_argument(
-    "--wallet-name", type=str, metavar="<wallet-name>", help="Specify the wallet name"
-)
-
-PARSER.add_argument(
-    "--wallet-type",
-    type=str,
-    metavar="<wallet-type>",
-    help="Specify the wallet implementation to use",
-)
-
-PARSER.add_argument(
-    "--wallet-storage-type",
-    type=str,
-    metavar="<storage-type>",
-    help="Specify the wallet storage implementation to use",
-)
-
-PARSER.add_argument(
-    "--wallet-storage-config",
-    type=str,
-    metavar="<storage-config>",
-    help="Specify the storage configuration to use (required for postgres) "
-    + 'e.g., \'{"url":"localhost:5432"}\'',
-)
-
-PARSER.add_argument(
-    "--wallet-storage-creds",
-    type=str,
-    metavar="<storage-creds>",
-    help="Specify the storage credentials to use (required for postgres) "
-    + 'e.g., \'{"account":"postgres","password":"mysecretpassword",'
-    + '"admin_account":"postgres","admin_password":"mysecretpassword"}\'',
-)
-
-PARSER.add_argument(
-    "--pool-name", type=str, metavar="<pool-name>", help="Specify the pool name"
-)
-
-PARSER.add_argument(
-    "--genesis-transactions",
-    type=str,
-    dest="genesis_transactions",
-    metavar="<genesis-transactions>",
-    help="Specify the genesis transactions as a string",
-)
-
-PARSER.add_argument(
-    "--genesis-url",
-    type=str,
-    dest="genesis_url",
-    metavar="<genesis-url>",
-    help="Specify a url from which to fetch the genesis transactions",
-)
-
-PARSER.add_argument(
-    "--admin",
-    type=str,
-    nargs=2,
-    metavar=("<host>", "<port>"),
-    help="Enable the administration API on a given host and port",
-)
-
-PARSER.add_argument(
-    "--admin-api-key",
-    type=str,
-    metavar="<api-key>",
-    help="Set the api key for the admin API.",
-)
-
-PARSER.add_argument(
-    "--admin-insecure-mode",
-    action="store_true",
-    help="Do not protect the admin API with token authentication.z",
-)
-
-PARSER.add_argument("--debug", action="store_true", help="Enable debugging features")
-
-PARSER.add_argument(
-    "--debug-seed",
-    dest="debug_seed",
-    type=str,
-    metavar="<debug-did-seed>",
-    help="Specify the debug seed to use",
-)
-
-PARSER.add_argument(
-    "--debug-connections",
-    action="store_true",
-    help="Enable additional logging around connections",
-)
-
-PARSER.add_argument(
-    "--public-invites",
-    action="store_true",
-    help="Send invitations and receive requests via the public DID",
-)
-
-PARSER.add_argument(
-    "--auto-accept-invites",
-    action="store_true",
-    help="Auto-accept connection invitations",
-)
-
-PARSER.add_argument(
-    "--auto-accept-requests",
-    action="store_true",
-    help="Auto-accept connection requests",
-)
-
-PARSER.add_argument(
-    "--auto-ping-connection",
-    action="store_true",
-    help="Automatically send a trust ping when a connection response is accepted",
-)
-
-PARSER.add_argument(
-    "--auto-respond-messages",
-    action="store_true",
-    help="Auto-respond to basic messages",
-)
-
-PARSER.add_argument(
-    "--auto-respond-credential-offer",
-    action="store_true",
-    help="Auto-respond to credential offers with credential request",
-)
-
-PARSER.add_argument(
-    "--auto-store-credential",
-    action="store_true",
-    help="Automatically store a credential upon receipt.",
-)
-
-PARSER.add_argument(
-    "--auto-respond-presentation-request",
-    action="store_true",
-    help="Auto-respond to presentation requests with a presentation "
-    + "if exactly one credential exists to satisfy the request",
-)
-
-PARSER.add_argument(
-    "--auto-verify-presentation",
-    action="store_true",
-    help="Automatically verify a presentation when it is received",
-)
-
-PARSER.add_argument(
-    "--no-receive-invites",
-    action="store_true",
-    help="Disable the receive invitations administration function",
-)
-
-PARSER.add_argument(
-    "--help-link",
-    type=str,
-    metavar="<help-url>",
-    help="Define the help URL for the administration interface",
-)
-
-PARSER.add_argument(
-    "--invite",
-    action="store_true",
-    help="Generate and print a new connection invitation URL",
-)
-
-PARSER.add_argument(
-    "--timing",
-    action="store_true",
-    help="Including timing information in response messages",
-)
-
-PARSER.add_argument(
-    "--protocol",
-    dest="external_protocols",
-    type=str,
-    action="append",
-    required=False,
-    metavar="<module>",
-    help="Provide external protocol modules",
-)
-
-PARSER.add_argument(
-    "--webhook-url",
-    action="append",
-    metavar="<url>",
-    help="Send webhooks to a given URL",
-)
-
-
-def parse_args(args: Sequence[str] = None):
-    """Parse command line arguments and return the collection."""
-    return PARSER.parse_args(args)
-
-
-def get_settings(args):
-    """Convert command line arguments to a settings dictionary."""
-    settings = {}
-
-    if args.log_config:
-        settings["log.config"] = args.log_config
-    if args.log_level:
-        settings["log.level"] = args.log_level
-
-    settings["transport.inbound_configs"] = args.inbound_transports
-    settings["transport.outbound_configs"] = args.outbound_transports
-
-    if args.endpoint:
-        settings["default_endpoint"] = args.endpoint
-    if args.label:
-        settings["default_label"] = args.label
-
-    if args.genesis_url:
-        settings["ledger.genesis_url"] = args.genesis_url
-    elif args.genesis_transactions:
-        settings["ledger.genesis_transactions"] = args.genesis_transactions
-
-    if args.storage_type:
-        settings["storage.type"] = args.storage_type
-
-    if args.seed:
-        settings["wallet.seed"] = args.seed
-    if args.wallet_key:
-        settings["wallet.key"] = args.wallet_key
-    if args.wallet_name:
-        settings["wallet.name"] = args.wallet_name
-    if args.wallet_storage_type:
-        settings["wallet.storage_type"] = args.wallet_storage_type
-    if args.wallet_type:
-        settings["wallet.type"] = args.wallet_type
-    if args.wallet_storage_config:
-        settings["wallet.storage_config"] = args.wallet_storage_config
-    if args.wallet_storage_creds:
-        settings["wallet.storage_creds"] = args.wallet_storage_creds
-
-    if args.admin:
-
-        admin_api_key = args.admin_api_key
-        admin_insecure_mode = args.admin_insecure_mode
-
-        if (admin_api_key and admin_insecure_mode) or not (
-            admin_api_key or admin_insecure_mode
-        ):
-            raise ArgsParseError(
-                "Either --admin-api-key or --admin-insecure-mode "
-                + "must be set but not both."
-            )
-
-        settings["admin.admin_api_key"] = admin_api_key
-        settings["admin.admin_insecure_mode"] = admin_insecure_mode
-
-        settings["admin.enabled"] = True
-        settings["admin.host"] = args.admin[0]
-        settings["admin.port"] = args.admin[1]
-        if args.help_link:
-            settings["admin.help_link"] = args.help_link
-        if args.no_receive_invites:
-            settings["admin.no_receive_invites"] = True
-        hook_urls = list(args.webhook_url) if args.webhook_url else []
-        hook_url = os.environ.get("WEBHOOK_URL")
-        if hook_url:
-            hook_urls.append(hook_url)
-        settings["admin.webhook_urls"] = hook_urls
-
-    if args.debug:
-        settings["debug.enabled"] = True
-    if args.debug_connections:
-        settings["debug.connections"] = True
-    if args.debug_seed:
-        settings["debug.seed"] = args.debug_seed
-    if args.invite:
-        settings["debug.print_invitation"] = True
-
-    if args.auto_respond_credential_offer:
-        settings["debug.auto_respond_credential_offer"] = True
-    if args.auto_store_credential:
-        settings["debug.auto_store_credential"] = True
-    if args.auto_respond_presentation_request:
-        settings["debug.auto_respond_presentation_request"] = True
-    if args.auto_verify_presentation:
-        settings["debug.auto_verify_presentation"] = True
-
-    if args.public_invites:
-        settings["public_invites"] = True
-    if args.auto_accept_invites:
-        settings["debug.auto_accept_invites"] = True
-    if args.auto_accept_requests:
-        settings["debug.auto_accept_requests"] = True
-    if args.auto_ping_connection:
-        settings["auto_ping_connection"] = True
-    if args.auto_respond_messages:
-        settings["debug.auto_respond_messages"] = True
-
-    if args.timing:
-        settings["timing.enabled"] = True
-
-    if args.external_protocols:
-        settings["external_protocols"] = args.external_protocols
-
-    return settings
+CAT_PROVISION = "general"
+CAT_START = "start"
+
+
+class ArgumentGroup(abc.ABC):
+    """A class representing a group of related command line arguments."""
+
+    GROUP_NAME = None
+
+    @abc.abstractmethod
+    def add_arguments(parser: ArgumentParser):
+        """Add arguments to the provided argument parser."""
+
+    @abc.abstractmethod
+    def get_settings(args: Namespace) -> dict:
+        """Extract settings from the parsed arguments."""
+
+
+class group:
+    """Decorator for registering argument groups."""
+
+    _registered = []
+
+    def __init__(self, *categories):
+        """Initialize the decorator."""
+        self.categories = tuple(categories)
+
+    def __call__(self, group_cls: ArgumentGroup):
+        """Register a class in the given categories."""
+        setattr(group_cls, "CATEGORIES", self.categories)
+        self._registered.append((self.categories, group_cls))
+        return group_cls
+
+    @classmethod
+    def get_registered(cls, category: str = None):
+        """Fetch the set of registered classes in a category."""
+        return (
+            grp
+            for (cats, grp) in cls._registered
+            if category is None or category in cats
+        )
+
+
+def load_argument_groups(parser: ArgumentParser, *groups: Type[ArgumentGroup]):
+    """Log a set of argument groups into a parser.
+
+    Returns:
+        A callable to convert loaded arguments into a settings dictionary
+
+    """
+    group_inst = []
+    for group in groups:
+        g_parser = parser.add_argument_group(group.GROUP_NAME)
+        inst = group()
+        inst.add_arguments(g_parser)
+        group_inst.append(inst)
+
+    def get_settings(args: Namespace):
+        settings = {}
+        for group in group_inst:
+            settings.update(group.get_settings(args))
+        return settings
+
+    return get_settings
+
+
+@group(CAT_START)
+class AdminGroup(ArgumentGroup):
+    """Admin server settings."""
+
+    GROUP_NAME = "Admin"
+
+    def add_arguments(self, parser: ArgumentParser):
+        """Add admin-specific command line arguments to the parser."""
+        parser.add_argument(
+            "--admin",
+            type=str,
+            nargs=2,
+            metavar=("<host>", "<port>"),
+            help="Enable the administration API on a given host and port",
+        )
+        parser.add_argument(
+            "--admin-api-key",
+            type=str,
+            metavar="<api-key>",
+            help="Set the api key for the admin API.",
+        )
+        parser.add_argument(
+            "--admin-insecure-mode",
+            action="store_true",
+            help="Do not protect the admin API with token authentication.z",
+        )
+        parser.add_argument(
+            "--no-receive-invites",
+            action="store_true",
+            help="Disable the receive invitations administration function",
+        )
+        parser.add_argument(
+            "--help-link",
+            type=str,
+            metavar="<help-url>",
+            help="Define the help URL for the administration interface",
+        )
+        parser.add_argument(
+            "--webhook-url",
+            action="append",
+            metavar="<url>",
+            help="Send webhooks to a given URL",
+        )
+
+    def get_settings(self, args: Namespace):
+        """Extract admin settings."""
+        settings = {}
+        if args.admin:
+            admin_api_key = args.admin_api_key
+            admin_insecure_mode = args.admin_insecure_mode
+
+            if (admin_api_key and admin_insecure_mode) or not (
+                admin_api_key or admin_insecure_mode
+            ):
+                raise ArgsParseError(
+                    "Either --admin-api-key or --admin-insecure-mode "
+                    + "must be set but not both."
+                )
+
+            settings["admin.admin_api_key"] = admin_api_key
+            settings["admin.admin_insecure_mode"] = admin_insecure_mode
+
+            settings["admin.enabled"] = True
+            settings["admin.host"] = args.admin[0]
+            settings["admin.port"] = args.admin[1]
+            if args.help_link:
+                settings["admin.help_link"] = args.help_link
+            if args.no_receive_invites:
+                settings["admin.no_receive_invites"] = True
+            hook_urls = list(args.webhook_url) if args.webhook_url else []
+            hook_url = os.environ.get("WEBHOOK_URL")
+            if hook_url:
+                hook_urls.append(hook_url)
+            settings["admin.webhook_urls"] = hook_urls
+        return settings
+
+
+@group(CAT_START)
+class DebugGroup(ArgumentGroup):
+    """Debug settings."""
+
+    GROUP_NAME = "Debug"
+
+    def add_arguments(self, parser: ArgumentParser):
+        """Add debug command line arguments to the parser."""
+        parser.add_argument(
+            "--debug", action="store_true", help="Enable debugging features"
+        )
+        parser.add_argument(
+            "--debug-seed",
+            dest="debug_seed",
+            type=str,
+            metavar="<debug-did-seed>",
+            help="Specify the debug seed to use",
+        )
+        parser.add_argument(
+            "--debug-connections",
+            action="store_true",
+            help="Enable additional logging around connections",
+        )
+        parser.add_argument(
+            "--invite",
+            action="store_true",
+            help="Generate and print a new connection invitation URL",
+        )
+
+        parser.add_argument(
+            "--auto-accept-invites",
+            action="store_true",
+            help="Auto-accept connection invitations",
+        )
+        parser.add_argument(
+            "--auto-accept-requests",
+            action="store_true",
+            help="Auto-accept connection requests",
+        )
+        parser.add_argument(
+            "--auto-respond-messages",
+            action="store_true",
+            help="Auto-respond to basic messages",
+        )
+        parser.add_argument(
+            "--auto-respond-credential-offer",
+            action="store_true",
+            help="Auto-respond to credential offers with credential request",
+        )
+        parser.add_argument(
+            "--auto-respond-presentation-request",
+            action="store_true",
+            help="Auto-respond to presentation requests with a presentation "
+            + "if exactly one credential exists to satisfy the request",
+        )
+        parser.add_argument(
+            "--auto-store-credential",
+            action="store_true",
+            help="Automatically store a credential upon receipt.",
+        )
+        parser.add_argument(
+            "--auto-verify-presentation",
+            action="store_true",
+            help="Automatically verify a presentation when it is received",
+        )
+
+    def get_settings(self, args: Namespace) -> dict:
+        """Extract debug settings."""
+        settings = {}
+        if args.debug:
+            settings["debug.enabled"] = True
+        if args.debug_connections:
+            settings["debug.connections"] = True
+        if args.debug_seed:
+            settings["debug.seed"] = args.debug_seed
+        if args.invite:
+            settings["debug.print_invitation"] = True
+
+        if args.auto_respond_credential_offer:
+            settings["debug.auto_respond_credential_offer"] = True
+        if args.auto_respond_presentation_request:
+            settings["debug.auto_respond_presentation_request"] = True
+        if args.auto_store_credential:
+            settings["debug.auto_store_credential"] = True
+        if args.auto_verify_presentation:
+            settings["debug.auto_verify_presentation"] = True
+        if args.auto_accept_invites:
+            settings["debug.auto_accept_invites"] = True
+        if args.auto_accept_requests:
+            settings["debug.auto_accept_requests"] = True
+        if args.auto_respond_messages:
+            settings["debug.auto_respond_messages"] = True
+        return settings
+
+
+@group(CAT_PROVISION, CAT_START)
+class GeneralGroup(ArgumentGroup):
+    """General settings."""
+
+    GROUP_NAME = "General"
+
+    def add_arguments(self, parser: ArgumentParser):
+        """Add general command line arguments to the parser."""
+        parser.add_argument(
+            "--storage-type",
+            type=str,
+            metavar="<storage-type>",
+            help="Specify the storage implementation to use",
+        )
+
+    def get_settings(self, args: Namespace) -> dict:
+        """Extract general settings."""
+        settings = {}
+        if args.storage_type:
+            settings["storage.type"] = args.storage_type
+        return settings
+
+
+@group(CAT_START)
+class LedgerGroup(ArgumentGroup):
+    """Ledger settings."""
+
+    GROUP_NAME = "Ledger"
+
+    def add_arguments(self, parser: ArgumentParser):
+        """Add ledger-specific command line arguments to the parser."""
+        parser.add_argument(
+            "--pool-name", type=str, metavar="<pool-name>", help="Specify the pool name"
+        )
+        parser.add_argument(
+            "--genesis-transactions",
+            type=str,
+            dest="genesis_transactions",
+            metavar="<genesis-transactions>",
+            help="Specify the genesis transactions as a string",
+        )
+        parser.add_argument(
+            "--genesis-url",
+            type=str,
+            dest="genesis_url",
+            metavar="<genesis-url>",
+            help="Specify a url from which to fetch the genesis transactions",
+        )
+
+    def get_settings(self, args: Namespace) -> dict:
+        """Extract ledger settings."""
+        settings = {}
+        if args.genesis_url:
+            settings["ledger.genesis_url"] = args.genesis_url
+        elif args.genesis_transactions:
+            settings["ledger.genesis_transactions"] = args.genesis_transactions
+        return settings
+
+
+@group(CAT_PROVISION, CAT_START)
+class LoggingGroup(ArgumentGroup):
+    """Logging settings."""
+
+    GROUP_NAME = "Logging"
+
+    def add_arguments(self, parser: ArgumentParser):
+        """Add logging-specific command line arguments to the parser."""
+        parser.add_argument(
+            "--log-config",
+            dest="log_config",
+            type=str,
+            metavar="<path-to-config>",
+            default=None,
+            help="Specifies a custom logging configuration file",
+        )
+        parser.add_argument(
+            "--log-file",
+            dest="log_file",
+            type=str,
+            metavar="<log-file>",
+            default=None,
+            help="Redirect log output to a named file",
+        )
+        parser.add_argument(
+            "--log-level",
+            dest="log_level",
+            type=str,
+            metavar="<log-level>",
+            default=None,
+            help="Specifies a custom logging level "
+            + "(debug, info, warning, error, critical)",
+        )
+
+    def get_settings(self, args: Namespace) -> dict:
+        """Extract logging settings."""
+        settings = {}
+        if args.log_config:
+            settings["log.config"] = args.log_config
+        if args.log_file:
+            settings["log.file"] = args.log_file
+        if args.log_level:
+            settings["log.level"] = args.log_level
+        return settings
+
+
+@group(CAT_START)
+class ProtocolGroup(ArgumentGroup):
+    """Protocol settings."""
+
+    def add_arguments(self, parser: ArgumentParser):
+        """Add protocol-specific command line arguments to the parser."""
+        parser.add_argument(
+            "--protocol",
+            dest="external_protocols",
+            type=str,
+            action="append",
+            required=False,
+            metavar="<module>",
+            help="Provide external protocol modules",
+        )
+        parser.add_argument(
+            "--auto-ping-connection",
+            action="store_true",
+            help="Automatically send a trust ping when a "
+            + "connection response is accepted",
+        )
+        parser.add_argument(
+            "--public-invites",
+            action="store_true",
+            help="Send invitations and receive requests via the public DID",
+        )
+        parser.add_argument(
+            "--timing",
+            action="store_true",
+            help="Including timing information in response messages",
+        )
+
+    def get_settings(self, args: Namespace) -> dict:
+        """Get protocol settings."""
+        settings = {}
+        if args.external_protocols:
+            settings["external_protocols"] = args.external_protocols
+        if args.auto_ping_connection:
+            settings["auto_ping_connection"] = True
+        if args.public_invites:
+            settings["public_invites"] = True
+        if args.timing:
+            settings["timing.enabled"] = True
+        return settings
+
+
+@group(CAT_START)
+class TransportGroup(ArgumentGroup):
+    """Transport settings."""
+
+    GROUP_NAME = "Transport"
+
+    def add_arguments(self, parser: ArgumentParser):
+        """Add transport-specific command line arguments to the parser."""
+        parser.add_argument(
+            "-it",
+            "--inbound-transport",
+            dest="inbound_transports",
+            type=str,
+            action="append",
+            nargs=3,
+            required=True,
+            metavar=("<module>", "<host>", "<port>"),
+            help="Choose which interface(s) to listen on",
+        )
+
+        parser.add_argument(
+            "-ot",
+            "--outbound-transport",
+            dest="outbound_transports",
+            type=str,
+            action="append",
+            required=True,
+            metavar="<module>",
+            help="Choose which outbound transport handlers to register",
+        )
+
+        parser.add_argument(
+            "-e",
+            "--endpoint",
+            type=str,
+            metavar="<endpoint>",
+            help="Specify the default endpoint to use when "
+            + "creating connection invitations and requests",
+        )
+
+        parser.add_argument(
+            "-l",
+            "--label",
+            type=str,
+            metavar="<label>",
+            help="Specify the default label to use when creating"
+            + " connection invitations and requests",
+        )
+
+    def get_settings(self, args: Namespace):
+        """Extract transport settings."""
+        settings = {}
+        settings["transport.inbound_configs"] = args.inbound_transports
+        settings["transport.outbound_configs"] = args.outbound_transports
+
+        if args.endpoint:
+            settings["default_endpoint"] = args.endpoint
+        if args.label:
+            settings["default_label"] = args.label
+        return settings
+
+
+@group(CAT_PROVISION, CAT_START)
+class WalletGroup(ArgumentGroup):
+    """Wallet settings."""
+
+    GROUP_NAME = "Wallet"
+
+    def add_arguments(self, parser: ArgumentParser):
+        """Add wallet-specific command line arguments to the parser."""
+        parser.add_argument(
+            "--seed",
+            type=str,
+            metavar="<wallet-seed>",
+            help="Seed to use when creating the public DID",
+        )
+        parser.add_argument(
+            "--wallet-key",
+            type=str,
+            metavar="<wallet-key>",
+            help="Specify the master key value to use when opening the wallet",
+        )
+        parser.add_argument(
+            "--wallet-name",
+            type=str,
+            metavar="<wallet-name>",
+            help="Specify the wallet name",
+        )
+        parser.add_argument(
+            "--wallet-type",
+            type=str,
+            metavar="<wallet-type>",
+            help="Specify the wallet implementation to use",
+        )
+        parser.add_argument(
+            "--wallet-storage-type",
+            type=str,
+            metavar="<storage-type>",
+            help="Specify the wallet storage implementation to use",
+        )
+        parser.add_argument(
+            "--wallet-storage-config",
+            type=str,
+            metavar="<storage-config>",
+            help="Specify the storage configuration to use (required for postgres) "
+            + 'e.g., \'{"url":"localhost:5432"}\'',
+        )
+        parser.add_argument(
+            "--wallet-storage-creds",
+            type=str,
+            metavar="<storage-creds>",
+            help="Specify the storage credentials to use (required for postgres) "
+            + 'e.g., \'{"account":"postgres","password":"mysecretpassword",'
+            + '"admin_account":"postgres","admin_password":"mysecretpassword"}\'',
+        )
+
+    def get_settings(self, args: Namespace) -> dict:
+        """Extract wallet settings."""
+        settings = {}
+        if args.seed:
+            settings["wallet.seed"] = args.seed
+        if args.wallet_key:
+            settings["wallet.key"] = args.wallet_key
+        if args.wallet_name:
+            settings["wallet.name"] = args.wallet_name
+        if args.wallet_storage_type:
+            settings["wallet.storage_type"] = args.wallet_storage_type
+        if args.wallet_type:
+            settings["wallet.type"] = args.wallet_type
+        if args.wallet_storage_config:
+            settings["wallet.storage_config"] = args.wallet_storage_config
+        if args.wallet_storage_creds:
+            settings["wallet.storage_creds"] = args.wallet_storage_creds
+        return settings
diff --git a/aries_cloudagent/config/logging.py b/aries_cloudagent/config/logging.py
index 751fb0b38f..94d19f7363 100644
--- a/aries_cloudagent/config/logging.py
+++ b/aries_cloudagent/config/logging.py
@@ -1,6 +1,6 @@
 """Utilities related to logging."""
 
-from logging import getLogger
+from logging import getLogger, FileHandler
 from logging.config import fileConfig
 from os import path
 
@@ -11,7 +11,12 @@ class LoggingConfigurator:
     """Utility class used to configure logging and print an informative start banner."""
 
     @classmethod
-    def configure(cls, logging_config_path: str = None, log_level: str = None):
+    def configure(
+        cls,
+        logging_config_path: str = None,
+        log_level: str = None,
+        log_file: str = None,
+    ):
         """
         Configure logger.
 
@@ -29,6 +34,10 @@ def configure(cls, logging_config_path: str = None, log_level: str = None):
 
         fileConfig(config_path, disable_existing_loggers=False)
 
+        if log_file:
+            getLogger().handlers.clear()
+            getLogger().handlers.append(FileHandler(log_file, encoding="utf-8"))
+
         if log_level:
             log_level = log_level.upper()
             getLogger().setLevel(log_level)
diff --git a/aries_cloudagent/config/tests/test_argparse.py b/aries_cloudagent/config/tests/test_argparse.py
index ffb6475c00..1e041d6e23 100644
--- a/aries_cloudagent/config/tests/test_argparse.py
+++ b/aries_cloudagent/config/tests/test_argparse.py
@@ -1,17 +1,37 @@
+import itertools
+from argparse import ArgumentParser
+
 from asynctest import TestCase as AsyncTestCase, mock as async_mock
 
-from ..argparse import PARSER, get_settings, parse_args
+from .. import argparse
 
 
 class TestArgParse(AsyncTestCase):
-    async def test_parse_settings(self):
-        """Test argument parsing."""
+    async def test_groups(self):
+        """Test optional argument parsing."""
+        parser = ArgumentParser()
+
+        groups = (
+            g
+            for g in argparse.group.get_registered()
+            if g is not argparse.TransportGroup
+        )
+        argparse.load_argument_groups(parser, *groups)
+
+        parser.parse_args([])
+
+    async def test_transport_settings(self):
+        """Test required argument parsing."""
+
+        parser = ArgumentParser()
+        group = argparse.TransportGroup()
+        group.add_arguments(parser)
 
-        with async_mock.patch.object(PARSER, "exit") as exit_parser:
-            parse_args([])
+        with async_mock.patch.object(parser, "exit") as exit_parser:
+            parser.parse_args([])
             exit_parser.assert_called_once()
 
-        result = parse_args(
+        result = parser.parse_args(
             [
                 "--inbound-transport",
                 "http",
@@ -25,7 +45,7 @@ async def test_parse_settings(self):
         assert result.inbound_transports == [["http", "0.0.0.0", "80"]]
         assert result.outbound_transports == ["http"]
 
-        settings = get_settings(result)
+        settings = group.get_settings(result)
 
         assert settings.get("transport.inbound_configs") == [["http", "0.0.0.0", "80"]]
         assert settings.get("transport.outbound_configs") == ["http"]
diff --git a/aries_cloudagent/config/util.py b/aries_cloudagent/config/util.py
new file mode 100644
index 0000000000..7448c4aa4e
--- /dev/null
+++ b/aries_cloudagent/config/util.py
@@ -0,0 +1,45 @@
+"""Entrypoint."""
+
+import asyncio
+import os
+from typing import Any, Mapping
+
+from aiohttp import ClientSession
+
+from .logging import LoggingConfigurator
+from ..postgres import load_postgres_plugin
+
+
+async def get_genesis_transactions(genesis_url: str):
+    """Get genesis transactions."""
+    headers = {}
+    headers["Content-Type"] = "application/json"
+    async with ClientSession() as client_session:
+        response = await client_session.get(genesis_url, headers=headers)
+        genesis_txns = await response.text()
+        return genesis_txns
+
+
+def common_config(settings: Mapping[str, Any]):
+    """Perform common app configuration."""
+    # Set up logging
+    log_config = settings.get("log.config")
+    log_level = settings.get("log.level") or os.getenv("LOG_LEVEL")
+    log_file = settings.get("log.file")
+    LoggingConfigurator.configure(log_config, log_level, log_file)
+
+    # Fetch genesis transactions if necessary
+    if not settings.get("ledger.genesis_transactions") and settings.get(
+        "ledger.genesis_url"
+    ):
+        loop = asyncio.get_event_loop()
+        settings["ledger.genesis_transactions"] = loop.run_until_complete(
+            get_genesis_transactions(settings["ledger.genesis_url"])
+        )
+
+    # Load postgres plug-in if necessary
+    if (
+        settings.get("wallet.type") == "indy"
+        and settings.get("wallet.storage_type") == "postgres_storage"
+    ):
+        load_postgres_plugin()
diff --git a/aries_cloudagent/tests/test_init.py b/aries_cloudagent/tests/test_init.py
deleted file mode 100644
index 138d8865b4..0000000000
--- a/aries_cloudagent/tests/test_init.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# import aries_cloudagent
-
-# from unittest import mock
-# from asynctest import TestCase as AsyncTestCase
-# from asynctest import mock as async_mock
-
-
-# class TestAsyncMain(AsyncTestCase):
-
-#     parsed_transports = [["a", "b", "c"]]
-#     transport_arg_value = "transport"
-#     host_arg_value = "host"
-#     port_arg_value = "port"
-
-#     @mock.patch("aries_cloudagent.asyncio", autospec=True)
-#     @mock.patch("aries_cloudagent.LoggingConfigurator", autospec=True)
-#     @mock.patch("aries_cloudagent.parser.parse_args", autospec=True)
-#     @mock.patch("aries_cloudagent.Conductor", autospec=True)
-#     @mock.patch("aries_cloudagent.start", autospec=True)
-#     def test_main_parse(
-#         self,
-#         mock_start,
-#         mock_conductor,
-#         mock_parse_args,
-#         mock_logging_configurator,
-#         mock_asyncio,
-#     ):
-#         type(mock_parse_args.return_value).transports = self.parsed_transports
-#         aries_cloudagent.main()
-
-#         mock_parse_args.assert_called_once()
-#         mock_start.assert_called_once_with(
-#             [
-#                 {
-#                     "transport": self.parsed_transports[0][0],
-#                     "host": self.parsed_transports[0][1],
-#                     "port": self.parsed_transports[0][2],
-#                 }
-#             ]
-#         )
-
-#     @async_mock.patch("aries_cloudagent.Conductor", autospec=True)
-#     async def test_main(self, mock_conductor):
-#         await aries_cloudagent.start(self.parsed_transports)
-
-#         mock_conductor.assert_called_once_with(self.parsed_transports)
-#         mock_conductor.return_value.start.assert_called_once_with()
diff --git a/aries_cloudagent/wallet/base.py b/aries_cloudagent/wallet/base.py
index d7b3bf0a08..98dbb10d97 100644
--- a/aries_cloudagent/wallet/base.py
+++ b/aries_cloudagent/wallet/base.py
@@ -16,6 +16,8 @@
 class BaseWallet(ABC):
     """Abstract wallet interface."""
 
+    WALLET_TYPE = None
+
     # TODO: break config out into params?
     def __init__(self, config: dict):
         """
@@ -26,6 +28,28 @@ def __init__(self, config: dict):
 
         """
 
+    @property
+    def name(self) -> str:
+        """
+        Accessor for the wallet name.
+
+        Returns:
+            Defaults to None
+
+        """
+        return None
+
+    @property
+    def type(self) -> str:
+        """
+        Accessor for the wallet type.
+
+        Returns:
+            Defaults to None
+
+        """
+        return self.WALLET_TYPE
+
     @property
     def handle(self):
         """
@@ -37,6 +61,11 @@ def handle(self):
         """
         return None
 
+    @property
+    def created(self) -> bool:
+        """Check whether the wallet was created on the last open call."""
+        return None
+
     @property
     def opened(self) -> bool:
         """
diff --git a/aries_cloudagent/wallet/basic.py b/aries_cloudagent/wallet/basic.py
index 334714f393..ce51579b95 100644
--- a/aries_cloudagent/wallet/basic.py
+++ b/aries_cloudagent/wallet/basic.py
@@ -23,6 +23,8 @@
 class BasicWallet(BaseWallet):
     """In-memory wallet implementation."""
 
+    WALLET_TYPE = "basic"
+
     def __init__(self, config: dict = None):
         """
         Initialize a `BasicWallet` instance.
@@ -39,6 +41,16 @@ def __init__(self, config: dict = None):
         self._local_dids = {}
         self._pair_dids = {}
 
+    @property
+    def name(self) -> str:
+        """Accessor for the wallet name."""
+        return self._name
+
+    @property
+    def created(self) -> bool:
+        """Check whether the wallet was created on the last open call."""
+        return True
+
     @property
     def opened(self) -> bool:
         """
diff --git a/aries_cloudagent/wallet/indy.py b/aries_cloudagent/wallet/indy.py
index 2d04a280b1..7538998c94 100644
--- a/aries_cloudagent/wallet/indy.py
+++ b/aries_cloudagent/wallet/indy.py
@@ -23,6 +23,7 @@ class IndyWallet(BaseWallet):
     DEFAULT_KEY = ""
     DEFAULT_NAME = "default"
     DEFAULT_STORAGE_TYPE = None
+    WALLET_TYPE = "indy"
 
     def __init__(self, config: dict = None):
         """
@@ -40,6 +41,7 @@ def __init__(self, config: dict = None):
         super(IndyWallet, self).__init__(config)
         self._auto_create = config.get("auto_create", True)
         self._auto_remove = config.get("auto_remove", False)
+        self._created = False
         self._freshness_time = config.get("freshness_time", False)
         self._handle = None
         self._key = config.get("key") or self.DEFAULT_KEY
@@ -60,6 +62,11 @@ def handle(self):
         """
         return self._handle
 
+    @property
+    def created(self) -> bool:
+        """Check whether the wallet was created on the last open call."""
+        return self._created
+
     @property
     def opened(self) -> bool:
         """
@@ -195,7 +202,7 @@ async def open(self):
         if self.opened:
             return
 
-        created = False
+        self._created = False
         while True:
             try:
                 self._handle = await indy.wallet.open_wallet(
@@ -205,12 +212,13 @@ async def open(self):
                 break
             except IndyError as x_indy:
                 if x_indy.error_code == ErrorCode.WalletNotFoundError:
-                    if created:
+                    if self._created:
                         raise WalletError(
                             "Wallet not found after creation: {}".format(self.name)
                         )
                     if self._auto_create:
                         await self.create(self._auto_remove)
+                        self._created = True
                     else:
                         raise WalletNotFoundError(
                             "Wallet not found: {}".format(self.name)
diff --git a/bin/aca-py b/bin/aca-py
index e5422c1880..5712164a10 100755
--- a/bin/aca-py
+++ b/bin/aca-py
@@ -16,10 +16,17 @@ if ENABLE_PTVSD or "--debug" in sys.argv:
         print("=== Waiting for debugger to attach ===")
         # To pause execution until the debugger is attached:
         ptvsd.wait_for_attach()
-    except ImportError as e:
+    except ImportError:
         print("ptvsd library was not found")
 
 
-from aries_cloudagent import main
+from aries_cloudagent.commands import run_command  # noqa
 
-main()
+if len(sys.argv) > 1:
+    command = sys.argv[1]
+    args = sys.argv[2:]
+else:
+    command = None
+    args = []
+
+run_command(command, args)
diff --git a/demo/runners/support/agent.py b/demo/runners/support/agent.py
index fe5fb21f56..a61fa4d730 100644
--- a/demo/runners/support/agent.py
+++ b/demo/runners/support/agent.py
@@ -265,7 +265,7 @@ def get_process_args(self, bin_path: str = None):
             bin_path = DEFAULT_BIN_PATH
         if bin_path:
             cmd_path = os.path.join(bin_path, cmd_path)
-        return list(flatten((["python3", cmd_path], self.get_agent_args())))
+        return list(flatten((["python3", cmd_path, "start"], self.get_agent_args())))
 
     async def start_process(
         self, python_path: str = None, bin_path: str = None, wait: bool = True
diff --git a/docker/manage b/docker/manage
index 7ecf87ce04..5ee86abf85 100755
--- a/docker/manage
+++ b/docker/manage
@@ -17,11 +17,14 @@ usage() {
 
       demo  - Build the demo docker image and run an integration test or demo.
 
+      provision - Provision an agent
+
+      start - Run an agent.
+
       test  - Run unit tests.
 
       test-indy  - Run unit tests, including Indy-specific tests.
 
-      start - Run an agent.
 EOF
   exit 1
 }
@@ -66,7 +69,11 @@ shift || COMMAND=usage
 case "${COMMAND}" in
 start|up)
   exportEnvironment "$@"
-  ../scripts/run_docker $(getStartupParams "$@")
+  ../scripts/run_docker start $(getStartupParams "$@")
+  ;;
+provision)
+  exportEnvironment "$@"
+  ../scripts/run_docker provision $(getStartupParams "$@")
   ;;
 demo)
   exportEnvironment "$@"