diff --git a/README.md b/README.md
index cb08ff7..ff59e27 100644
--- a/README.md
+++ b/README.md
@@ -329,6 +329,7 @@ my_custom_requests_session = Session()
 aerie_host = AerieHost(
     GRAPHQL_URL,
     GATEWAY_URL,
+    FILESTORE_URL,
     session=my_custom_requests_session
 )
 aerie_host.authenticate(...)
diff --git a/src/aerie_cli/aerie_client.py b/src/aerie_cli/aerie_client.py
index 6c01fd7..811c8c7 100644
--- a/src/aerie_cli/aerie_client.py
+++ b/src/aerie_cli/aerie_client.py
@@ -3,6 +3,7 @@
 from pathlib import Path
 from typing import Dict
 from typing import List
+from typing import Optional
 from typing import Union
 from copy import deepcopy
 
@@ -43,7 +44,11 @@ def __init__(self, aerie_host: AerieHost):
         """
         self.aerie_host = aerie_host
 
-    def get_activity_plan_by_id(self, plan_id: int, full_args: str = None) -> ActivityPlanRead:
+    def get_activity_plan_by_id(
+        self,
+        plan_id: int,
+        full_args: str = None,
+    ) -> ActivityPlanRead:
         """Download activity plan from Aerie
 
         Args:
@@ -160,11 +165,10 @@ def get_plan_id_by_sim_id(self, simulation_dataset_id: int) -> int:
         }
         """
         resp = self.aerie_host.post_to_graphql(
-            get_plan_id_query,
-            simulation_dataset_id=simulation_dataset_id
+            get_plan_id_query, simulation_dataset_id=simulation_dataset_id
         )
-        return resp['simulation']['plan']['id']
-    
+        return resp["simulation"]["plan"]["id"]
+
     def get_tag_id_by_name(self, tag_name: str):
         get_tags_by_name_query = """
         query GetTagByName($name: String) {
@@ -174,7 +178,7 @@ def get_tag_id_by_name(self, tag_name: str):
         }
         """
 
-        #make default color of tag white
+        # make default color of tag white
         create_new_tag = """
         mutation CreateNewTag($name: String, $color: String = "#FFFFFF") {
             insert_tags_one(object: {name: $name, color: $color}) {
@@ -184,17 +188,17 @@ def get_tag_id_by_name(self, tag_name: str):
         """
 
         resp = self.aerie_host.post_to_graphql(
-            get_tags_by_name_query, 
-            name=tag_name
+            get_tags_by_name_query,
+            name=tag_name,
         )
 
-        #if a tag with the specified name exists then returns the ID, else creates a new tag with this name
-        if len(resp) > 0: 
+        # if a tag with the specified name exists then returns the ID, else creates a new tag with this name
+        if len(resp) > 0:
             return resp[0]["id"]
-        else: 
+        else:
             new_tag_resp = self.aerie_host.post_to_graphql(
-                create_new_tag, 
-                name=tag_name
+                create_new_tag,
+                name=tag_name,
             )
 
             return new_tag_resp["id"]
@@ -209,15 +213,15 @@ def add_plan_tag(self, plan_id: int, tag_name: str):
             }
         }
         """
-        
-        #add tag to plan
+
+        # add tag to plan
         resp = self.aerie_host.post_to_graphql(
-            add_tag_to_plan, 
-            plan_id=plan_id, 
-            tag_id=self.get_tag_id_by_name(tag_name)
+            add_tag_to_plan,
+            plan_id=plan_id,
+            tag_id=self.get_tag_id_by_name(tag_name),
         )
 
-        return resp['returning'][0]
+        return resp["returning"][0]
 
     def create_activity_plan(
         self, model_id: int, plan_to_create: ActivityPlanCreate
@@ -239,10 +243,10 @@ def create_activity_plan(
         plan_id = plan_resp["id"]
         plan_revision = plan_resp["revision"]
 
-        #add plan tags if exists from plan_to_create
+        # add plan tags if exists from plan_to_create
         for tag in plan_to_create.tags:
             self.add_plan_tag(plan_id, tag["tag"]["name"])
-                
+
         # This loop exists to make sure all anchor IDs are updated as necessary
 
         # Deep copy activities so we can augment and pop from the list
@@ -292,7 +296,7 @@ def create_activity_plan(
             update_simulation_mutation,
             plan_id=plan_id,
             simulation_start_time=simulation_start_time,
-            simulation_end_time=simulation_end_time
+            simulation_end_time=simulation_end_time,
         )
 
         return plan_id
@@ -308,7 +312,7 @@ def create_activity(self, activity_to_create: Activity, plan_id: int) -> int:
         """
         resp = self.aerie_host.post_to_graphql(
             insert_activity_mutation,
-            activity=api_activity_create.to_dict()
+            activity=api_activity_create.to_dict(),
         )
         activity_id = resp["id"]
 
@@ -318,7 +322,7 @@ def update_activity(
         self,
         activity_id: int,
         activity_to_update: Activity,
-        plan_id: int
+        plan_id: int,
     ) -> int:
         activity_dict: Dict = activity_to_update.to_api_update().to_dict()
         update_activity_mutation = """
@@ -338,7 +342,7 @@ def update_activity(
         )
         return resp["id"]
 
-    def get_all_activity_presets(self, m_id:int) -> List:
+    def get_all_activity_presets(self, m_id: int) -> List:
         get_all_presets_query = """
         query ($model_id: Int!) {
             activity_presets (where: {model_id:{_eq:$model_id}}){
@@ -351,10 +355,7 @@ def get_all_activity_presets(self, m_id:int) -> List:
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(
-            get_all_presets_query,
-            model_id=m_id
-        )
+        resp = self.aerie_host.post_to_graphql(get_all_presets_query, model_id=m_id)
         return resp
 
     def upload_activity_presets(self, upload_obj):
@@ -375,8 +376,7 @@ def upload_activity_presets(self, upload_obj):
         }"""
 
         resp = self.aerie_host.post_to_graphql(
-            upload_activity_presets_query, 
-            object = upload_obj
+            upload_activity_presets_query, object=upload_obj
         )
 
         return resp["returning"]
@@ -410,19 +410,23 @@ def exec_sim_query():
         return sim_dataset_id
 
     def get_resource_timelines(self, plan_id: int):
-        samples = self.get_resource_samples(self.get_simulation_dataset_ids_by_plan_id(plan_id)[0])
+        samples = self.get_resource_samples(
+            self.get_simulation_dataset_ids_by_plan_id(plan_id)[0]
+        )
         api_resource_timeline = ApiResourceSampleResults.from_dict(samples)
         return api_resource_timeline
 
-    def get_resource_samples(self, simulation_dataset_id: int, state_names: List=None):
+    def get_resource_samples(
+        self, simulation_dataset_id: int, state_names: List = None
+    ):
         """Pull resource samples from a simulation dataset, optionally filtering for specific states
 
         Each resource's values are returned in a list of points {x: <time>, y: <value>}.
-        
+
         Times are provided in microseconds from plan start.
 
-        Numeric resources can be either discrete-valued or vary linearly between samples. Samples are processed such 
-        that a linear interpolation between samples will always return a correct value. Two points at the same 
+        Numeric resources can be either discrete-valued or vary linearly between samples. Samples are processed such
+        that a linear interpolation between samples will always return a correct value. Two points at the same
         timestamp indicate a discontinuity.
 
         Args:
@@ -431,7 +435,7 @@ def get_resource_samples(self, simulation_dataset_id: int, state_names: List=Non
 
         Returns:
             Dict: Object with key "resourceSamples," the value of which is a dictionary of resource sample series keyed by resource name.
-        """        
+        """
 
         # checks to see if user inputted specific states. If so, use this query.
         if state_names:
@@ -452,7 +456,11 @@ def get_resource_samples(self, simulation_dataset_id: int, state_names: List=Non
             }
             """
 
-            resp = self.aerie_host.post_to_graphql(resource_profile_query, simulation_dataset_id=simulation_dataset_id, state_names=state_names)
+            resp = self.aerie_host.post_to_graphql(
+                resource_profile_query,
+                simulation_dataset_id=simulation_dataset_id,
+                state_names=state_names,
+            )
 
         else:
             resource_profile_query = """
@@ -471,9 +479,10 @@ def get_resource_samples(self, simulation_dataset_id: int, state_names: List=Non
                 }
             }
             """
-            resp = self.aerie_host.post_to_graphql(resource_profile_query, simulation_dataset_id=simulation_dataset_id)
-        
-        
+            resp = self.aerie_host.post_to_graphql(
+                resource_profile_query, simulation_dataset_id=simulation_dataset_id
+            )
+
         profiles = resp["dataset"]["profiles"]
 
         plan_duration_query = """
@@ -518,7 +527,7 @@ def get_resource_samples(self, simulation_dataset_id: int, state_names: List=Non
                 dynamics = segment["dynamics"]
 
                 # Discrete profiles don't have rates
-                if profile_type == 'discrete':
+                if profile_type == "discrete":
 
                     # Define points at the start and end of this profile segment
                     start_value = {
@@ -544,7 +553,7 @@ def get_resource_samples(self, simulation_dataset_id: int, state_names: List=Non
                         values.append(end_value)
 
                 # Real profiles can have rates over time
-                elif profile_type == 'real':
+                elif profile_type == "real":
 
                     start_value = {
                         "x": segment_start_time,
@@ -571,9 +580,7 @@ def get_resource_samples(self, simulation_dataset_id: int, state_names: List=Non
                     raise ValueError(f"Unknown resource profile type: {profile_type}")
 
             resources[name] = values
-        return {
-            "resourceSamples": resources
-        }
+        return {"resourceSamples": resources}
 
     def get_simulation_results(self, sim_dataset_id: int) -> str:
 
@@ -594,7 +601,8 @@ def get_simulation_results(self, sim_dataset_id: int) -> str:
         }
         """
         resp = self.aerie_host.post_to_graphql(
-            sim_result_query, sim_dataset_id=sim_dataset_id)
+            sim_result_query, sim_dataset_id=sim_dataset_id
+        )
         return resp
 
     def delete_plan(self, plan_id: int) -> str:
@@ -607,20 +615,16 @@ def delete_plan(self, plan_id: int) -> str:
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(
-            delete_plan_mutation, plan_id=plan_id)
+        resp = self.aerie_host.post_to_graphql(delete_plan_mutation, plan_id=plan_id)
 
         return resp["name"]
 
     def upload_file(self, path: str) -> int:
         upload_timestamp = arrow.utcnow().isoformat()
         path_obj = Path(path)
-        server_side_path = (
-                path_obj.stem + "--" + upload_timestamp + path_obj.suffix
-        )
+        server_side_path = path_obj.stem + "--" + upload_timestamp + path_obj.suffix
         with open(path, "rb") as f:
-            resp = self.aerie_host.post_to_gateway_files(
-                server_side_path, f)
+            resp = self.aerie_host.post_to_gateway_files(server_side_path, f)
             return resp["id"]
 
     def upload_mission_model(
@@ -682,8 +686,7 @@ def delete_mission_model(self, model_id: int) -> str:
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(
-            delete_model_mutation, model_id=model_id)
+        resp = self.aerie_host.post_to_graphql(delete_model_mutation, model_id=model_id)
 
         return resp["name"]
 
@@ -702,8 +705,7 @@ def get_mission_models(self) -> List[ApiMissionModelRead]:
         """
 
         resp = self.aerie_host.post_to_graphql(get_mission_model_query)
-        api_mission_models = [
-            ApiMissionModelRead.from_dict(model) for model in resp]
+        api_mission_models = [ApiMissionModelRead.from_dict(model) for model in resp]
 
         return api_mission_models
 
@@ -732,7 +734,8 @@ def create_config_args(self, plan_id: int, args: dict):
         sim_id = plan.sim_id
 
         resp = self.aerie_host.post_to_graphql(
-            update_config_arg_query, sim_id=sim_id, args=args)
+            update_config_arg_query, sim_id=sim_id, args=args
+        )
 
         return resp["arguments"]
 
@@ -777,7 +780,8 @@ def update_config_args(self, plan_id: int, args: dict):
             final_args[arg] = args[arg]
 
         resp = self.aerie_host.post_to_graphql(
-            update_config_arg_query, sim_id=sim_id, args=final_args)
+            update_config_arg_query, sim_id=sim_id, args=final_args
+        )
 
         return resp["arguments"]
 
@@ -794,8 +798,7 @@ def get_config(self, plan_id: int):
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(
-            get_config_query, sim_id=sim_id)
+        resp = self.aerie_host.post_to_graphql(get_config_query, sim_id=sim_id)
 
         return resp["arguments"]
 
@@ -841,7 +844,7 @@ def create_expansion_rule(
         model_id: str,
         parcel_id: str,
         name: str = None,
-        description: str = None
+        description: str = None,
     ) -> int:
         """Submit expansion logic to an Aerie instance
 
@@ -869,18 +872,24 @@ def create_expansion_rule(
             "parcel_id": parcel_id,
             "authoring_mission_model_id": model_id,
             "expansion_logic": expansion_logic,
-            "name": name if (name is not None) else activity_name + arrow.utcnow().format("_YYYY-MM-DDTHH-mm-ss"),
-            "description": description if (description is not None) else ""
+            "name": (
+                name
+                if (name is not None)
+                else activity_name + arrow.utcnow().format("_YYYY-MM-DDTHH-mm-ss")
+            ),
+            "description": description if (description is not None) else "",
         }
-        data = self.aerie_host.post_to_graphql(
-            create_expansion_logic_query,
-            rule=rule
-        )
+        data = self.aerie_host.post_to_graphql(create_expansion_logic_query, rule=rule)
 
         return data["id"]
 
     def create_expansion_set(
-        self, parcel_id: int, model_id: int, expansion_ids: List[int], name: str, description: str=None
+        self,
+        parcel_id: int,
+        model_id: int,
+        expansion_ids: List[int],
+        name: str,
+        description: str = None,
     ) -> int:
         """Create an Aerie expansion set given a list of activity IDs
 
@@ -920,7 +929,7 @@ def create_expansion_set(
             mission_model_id=model_id,
             expansion_ids=expansion_ids,
             name=name,
-            description="" if description is None else description
+            description="" if description is None else description,
         )
         return data["id"]
 
@@ -1001,7 +1010,8 @@ def get_rule_ids_by_activity_type(self, activity_type: str) -> List[int]:
             }
         """
         data = self.aerie_host.post_to_graphql(
-            get_expansion_ids_query, activity_type=activity_type)
+            get_expansion_ids_query, activity_type=activity_type
+        )
         rule_ids = [int(v["id"]) for v in data]
         rule_ids.sort()
         return rule_ids
@@ -1064,7 +1074,8 @@ def get_simulation_dataset_ids_by_plan_id(self, plan_id: int) -> List[int]:
         }
         """
         data = self.aerie_host.post_to_graphql(
-            get_simulation_dataset_query, plan_id=plan_id)
+            get_simulation_dataset_query, plan_id=plan_id
+        )
         return [d["id"] for d in data[0]["simulation_datasets"]]
 
     def expand_simulation(
@@ -1116,8 +1127,7 @@ def list_expansion_runs(self, simulation_dataset_id: int) -> List[ExpansionRun]:
         }
         """
         resp = self.aerie_host.post_to_graphql(
-            get_runs_query,
-            simulation_dataset_id=simulation_dataset_id
+            get_runs_query, simulation_dataset_id=simulation_dataset_id
         )
         return [ExpansionRun.from_dict(r) for r in resp]
 
@@ -1125,7 +1135,7 @@ def get_expansion_run(
         self, expansion_run_id: int, include_commands: bool = False
     ) -> ExpansionRun:
         """
-        Get metadata about an expansion run and, optionally, all expanded 
+        Get metadata about an expansion run and, optionally, all expanded
         activity instance commands/errors.
         """
         get_run_query = """
@@ -1146,7 +1156,7 @@ def get_expansion_run(
         resp = self.aerie_host.post_to_graphql(
             get_run_query,
             expansion_run_id=expansion_run_id,
-            include_commands=include_commands
+            include_commands=include_commands,
         )
         return ExpansionRun.from_dict(resp[0])
 
@@ -1271,8 +1281,7 @@ def list_sequences(self, simulation_dataset_id: int) -> List[str]:
         }
         """
         data = self.aerie_host.post_to_graphql(
-            list_sequences_query,
-            simulation_dataset_id=simulation_dataset_id
+            list_sequences_query, simulation_dataset_id=simulation_dataset_id
         )
         return [s["seq_id"] for s in data]
 
@@ -1293,7 +1302,7 @@ def delete_sequence(self, seq_id: str, simulation_dataset_id: int) -> None:
         self.aerie_host.post_to_graphql(
             delete_sequence_query,
             seq_id=seq_id,
-            simulation_dataset_id=simulation_dataset_id
+            simulation_dataset_id=simulation_dataset_id,
         )
 
     def get_all_expansion_run_commands(self, expansion_run_id: int) -> List:
@@ -1355,8 +1364,7 @@ def get_all_activity_types(self, model_id: int) -> List[str]:
             }
         }
         """
-        data = self.aerie_host.post_to_graphql(
-            get_types_query, model_id=model_id)
+        data = self.aerie_host.post_to_graphql(get_types_query, model_id=model_id)
         activity_types = [o["name"] for o in data]
         return activity_types
 
@@ -1448,7 +1456,9 @@ def get_scheduling_goals_by_specification(self, spec_id):
             }
         }
         """
-        resp = self.aerie_host.post_to_graphql(list_all_goals_by_spec_query, spec=spec_id)
+        resp = self.aerie_host.post_to_graphql(
+            list_all_goals_by_spec_query, spec=spec_id
+        )
 
         return resp
 
@@ -1472,13 +1482,9 @@ def create_dictionary(self, dictionary: str) -> int:
             }
         }
         """
-        resp = self.aerie_host.post_to_graphql(
-            query,
-            dictionary=dictionary
-        )
+        resp = self.aerie_host.post_to_graphql(query, dictionary=dictionary)
         return next(iter(resp.values()))["id"]
 
-
     def list_dictionaries(self) -> Dict[DictionaryType, List[DictionaryMetadata]]:
         """List all command, parameter, and channel dictionaries
 
@@ -1486,7 +1492,8 @@ def list_dictionaries(self) -> Dict[DictionaryType, List[DictionaryMetadata]]:
             List[DictionaryMetadata]
         """
 
-        command_dictionaries = self.aerie_host.post_to_graphql("""query ListDictionaries {
+        command_dictionaries = self.aerie_host.post_to_graphql(
+            """query ListDictionaries {
             command_dictionary {
                 id
                 version
@@ -1495,8 +1502,10 @@ def list_dictionaries(self) -> Dict[DictionaryType, List[DictionaryMetadata]]:
                 mission
             }
         }
-        """)
-        channel_dictionaries = self.aerie_host.post_to_graphql("""query ListDictionaries {
+        """
+        )
+        channel_dictionaries = self.aerie_host.post_to_graphql(
+            """query ListDictionaries {
             channel_dictionary {
                 id
                 version
@@ -1505,8 +1514,10 @@ def list_dictionaries(self) -> Dict[DictionaryType, List[DictionaryMetadata]]:
                 mission
             }
         }
-        """)
-        parameter_dictionaries = self.aerie_host.post_to_graphql("""query ListDictionaries {
+        """
+        )
+        parameter_dictionaries = self.aerie_host.post_to_graphql(
+            """query ListDictionaries {
             parameter_dictionary {
                 id
                 version
@@ -1515,27 +1526,35 @@ def list_dictionaries(self) -> Dict[DictionaryType, List[DictionaryMetadata]]:
                 mission
             }
         }
-        """)
+        """
+        )
         return {
-            DictionaryType.COMMAND: [DictionaryMetadata.from_dict(i) for i in command_dictionaries],
-            DictionaryType.CHANNEL: [DictionaryMetadata.from_dict(i) for i in channel_dictionaries],
-            DictionaryType.PARAMETER: [DictionaryMetadata.from_dict(
-                i) for i in parameter_dictionaries]
-        }
-
-    def delete_dictionary(self, id: int, dictionary_type: Union[str, DictionaryType]) -> None:
+            DictionaryType.COMMAND: [
+                DictionaryMetadata.from_dict(i) for i in command_dictionaries
+            ],
+            DictionaryType.CHANNEL: [
+                DictionaryMetadata.from_dict(i) for i in channel_dictionaries
+            ],
+            DictionaryType.PARAMETER: [
+                DictionaryMetadata.from_dict(i) for i in parameter_dictionaries
+            ],
+        }
+
+    def delete_dictionary(
+        self, id: int, dictionary_type: Union[str, DictionaryType]
+    ) -> None:
         """Delete AMPCS dictionary
 
         Args:
             id (int): _description_
             dictionary_type (Union[str, DictionaryType]): _description_
         """
-        
+
         if not isinstance(dictionary_type, DictionaryType):
             dictionary_type = DictionaryType(dictionary_type)
 
         queries = {
-                DictionaryType.COMMAND: """
+            DictionaryType.COMMAND: """
             mutation DeleteCommandDictionary($id: Int!) {
                 delete_command_dictionary_by_pk(id: $id) {
                     id
@@ -1549,13 +1568,13 @@ def delete_dictionary(self, id: int, dictionary_type: Union[str, DictionaryType]
                 }
             }
             """,
-                DictionaryType.PARAMETER: """
+            DictionaryType.PARAMETER: """
             mutation DeleteParameterDictionary($id: Int!) {
                 delete_parameter_dictionary_by_pk(id: $id) {
                     id
                 }
             }
-            """
+            """,
         }
         self.aerie_host.post_to_graphql(queries[dictionary_type], id=id)
 
@@ -1567,8 +1586,8 @@ def create_sequence_adaptation(self, adaptation: str) -> int:
 
         Returns:
             int: ID of sequence adaptation
-        """        
-        
+        """
+
         query = """
         mutation CreateSequenceAdaptation($adaptation: sequence_adaptation_insert_input!) {
             createSequenceAdaptation: insert_sequence_adaptation_one(object: $adaptation) {
@@ -1576,7 +1595,9 @@ def create_sequence_adaptation(self, adaptation: str) -> int:
             }
         }
         """
-        resp = self.aerie_host.post_to_graphql(query, adaptation={"adaptation": adaptation})
+        resp = self.aerie_host.post_to_graphql(
+            query, adaptation={"adaptation": adaptation}
+        )
 
         return resp["id"]
 
@@ -1586,7 +1607,7 @@ def list_sequence_adaptations(self) -> List[SequenceAdaptationMetadata]:
         Returns:
             List[SequenceAdaptationMetadata]: Metadata for all existing sequence adaptations
         """
-        
+
         query = """
         query ListSequenceAdaptations {
             sequence_adaptation {
@@ -1608,7 +1629,7 @@ def update_sequence_adaptation(self, adaptation: str, id: int) -> None:
             adaptation (str): String contents of adaptation JS file
             id (int): ID of sequence adaptation to update
         """
-        
+
         query = """
         mutation UpdateSequenceAdaptation($adaptation: String!, $id: Int!) {
             update_sequence_adaptation_by_pk(pk_columns: {id: $id}, _set: {adaptation: $adaptation}) {
@@ -1616,7 +1637,9 @@ def update_sequence_adaptation(self, adaptation: str, id: int) -> None:
             }
         }
         """
-        self.aerie_host.post_to_graphql(query, adaptation={"adaptation": adaptation}, id=id)
+        self.aerie_host.post_to_graphql(
+            query, adaptation={"adaptation": adaptation}, id=id
+        )
 
     def delete_sequence_adaptation(self, id: int) -> None:
         """Delete Phoenix Editor sequence adaptation
@@ -1654,15 +1677,14 @@ def create_parcel(self, parcel: Parcel) -> int:
                     id
                 }
             }
-            """, parcel=parcel.to_api_create().to_dict()
+            """,
+            parcel=parcel.to_api_create().to_dict(),
         )
         parcel_id = resp["id"]
 
         parameter_dictionaries = [
-            {
-                "parameter_dictionary_id": p,
-                "parcel_id": parcel_id
-            } for p in parcel.parameter_dictionary_ids
+            {"parameter_dictionary_id": p, "parcel_id": parcel_id}
+            for p in parcel.parameter_dictionary_ids
         ]
         self.aerie_host.post_to_graphql(
             """
@@ -1672,7 +1694,7 @@ def create_parcel(self, parcel: Parcel) -> int:
                 }
             }
             """,
-            parameter_dictionaries=parameter_dictionaries
+            parameter_dictionaries=parameter_dictionaries,
         )
         return parcel_id
 
@@ -1680,7 +1702,7 @@ def list_parcels(self) -> List[Parcel]:
         """List sequencing parcels
 
         Returns:
-            List[Parcel]: 
+            List[Parcel]:
         """
 
         resp = self.aerie_host.post_to_graphql(
@@ -1706,7 +1728,7 @@ def delete_parcel(self, id: int) -> None:
 
         Args:
             id (int): ID of parcel to delete
-        """        
+        """
 
         self.aerie_host.post_to_graphql(
             """
@@ -1716,7 +1738,7 @@ def delete_parcel(self, id: int) -> None:
                 }
             }
             """,
-            id=id
+            id=id,
         )
 
     def upload_scheduling_goals(self, upload_object):
@@ -1738,17 +1760,16 @@ def upload_scheduling_goals(self, upload_object):
             ...
         ]
         """
-        
+
         upload_scheduling_goals_query = """
         mutation InsertGoal($input: [scheduling_goal_definition_insert_input!]!){
             insert_scheduling_goal_definition(objects: $input){
                 returning {goal_id}
             }
         }"""
-        
+
         resp = self.aerie_host.post_to_graphql(
-            upload_scheduling_goals_query,
-            input=upload_object
+            upload_scheduling_goals_query, input=upload_object
         )
 
         return resp["returning"]
@@ -1763,8 +1784,7 @@ def get_scheduling_specification_for_plan(self, plan_id):
         """
 
         resp = self.aerie_host.post_to_graphql(
-            get_scheduling_specification_for_plan_query, 
-            plan_id=plan_id
+            get_scheduling_specification_for_plan_query, plan_id=plan_id
         )
         return resp[0]["id"]
 
@@ -1777,10 +1797,7 @@ def get_goal_id_for_name(self, name):
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(
-            get_goal_id_for_name_query,
-            name=name
-        )
+        resp = self.aerie_host.post_to_graphql(get_goal_id_for_name_query, name=name)
         if len(resp) == 0:
             raise RuntimeError(f"No goals found with name {name}.")
         elif len(resp) > 1:
@@ -1814,11 +1831,10 @@ def add_goals_to_specifications(self, upload_object):
         }
         """
         resp = self.aerie_host.post_to_graphql(
-            add_goal_to_specification_query, 
-            object = upload_object
+            add_goal_to_specification_query, object=upload_object
         )
 
-        return resp['returning']
+        return resp["returning"]
 
     def delete_scheduling_goal(self, goal_id):
         return self.delete_scheduling_goals(list([goal_id]))
@@ -1837,11 +1853,10 @@ def delete_scheduling_goals(self, goal_id_list):
         """
 
         resp_for_deleting_from_specs = self.aerie_host.post_to_graphql(
-            delete_scheduling_goals_from_all_specs_query, 
-            id_list=goal_id_list
+            delete_scheduling_goals_from_all_specs_query, id_list=goal_id_list
         )
 
-        # Note that deleting the scheduling goal metadata entry will take care of the 
+        # Note that deleting the scheduling goal metadata entry will take care of the
         # scheduling goal definition entry too
         delete_scheduling_goals_query = """
         mutation DeleteSchedulingGoals($id_list: [Int!]!) {
@@ -1852,8 +1867,7 @@ def delete_scheduling_goals(self, goal_id_list):
         """
 
         resp = self.aerie_host.post_to_graphql(
-            delete_scheduling_goals_query, 
-            id_list=goal_id_list
+            delete_scheduling_goals_query, id_list=goal_id_list
         )
 
         return resp["returning"]
@@ -1867,14 +1881,13 @@ def get_plan_revision(self, planId):
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(
-            get_plan_revision_query, 
-            plan_id=planId
-        )
+        resp = self.aerie_host.post_to_graphql(get_plan_revision_query, plan_id=planId)
 
         return resp[0]["revision"]
 
-    def __expand_activity_arguments(self, plan: ActivityPlanRead, full_args: str = None) -> ActivityPlanRead:
+    def __expand_activity_arguments(
+        self, plan: ActivityPlanRead, full_args: str = None
+    ) -> ActivityPlanRead:
         if full_args is None or full_args == "" or full_args.lower() == "false":
             return plan
         expand_all = full_args.lower() == "true"
@@ -1901,7 +1914,8 @@ def __expand_activity_arguments(self, plan: ActivityPlanRead, full_args: str = N
                     model_id=plan.model_id,
                 )
                 activity.arguments = ApiEffectiveActivityArguments.from_dict(
-                    resp).arguments
+                    resp
+                ).arguments
         return plan
 
     def upload_constraint(self, constraint):
@@ -1913,9 +1927,10 @@ def upload_constraint(self, constraint):
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(upload_constraint_query, constraint=constraint)
+        resp = self.aerie_host.post_to_graphql(
+            upload_constraint_query, constraint=constraint
+        )
         return resp["constraint_id"]
-    
 
     def add_constraint_to_plan(self, constraint_id, plan_id):
         """
@@ -1933,12 +1948,12 @@ def add_constraint_to_plan(self, constraint_id, plan_id):
 
         """
         resp = self.aerie_host.post_to_graphql(
-            add_constraint_to_specification_query, 
-            constraint_id = constraint_id,
-            plan_id = plan_id
+            add_constraint_to_specification_query,
+            constraint_id=constraint_id,
+            plan_id=plan_id,
         )
 
-        return resp['constraint_id']
+        return resp["constraint_id"]
 
     def delete_constraint(self, id):
 
@@ -1955,8 +1970,7 @@ def delete_constraint(self, id):
         """
 
         resp_for_deleting_from_specs = self.aerie_host.post_to_graphql(
-            delete_constraint_from_all_specs_query, 
-            id=id
+            delete_constraint_from_all_specs_query, id=id
         )
 
         delete_constraint_query = """
@@ -1969,7 +1983,7 @@ def delete_constraint(self, id):
 
         resp = self.aerie_host.post_to_graphql(delete_constraint_query, id=id)
         return resp["id"]
-    
+
     def update_constraint(self, id, definition):
         old_update_constraint_query = """
         mutation UpdateConstraint($constarint_id: Int!, $constraint: constraint_definition_set_input!) {
@@ -1995,9 +2009,11 @@ def update_constraint(self, id, definition):
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(update_constraint_query, constarint_id=id, definition=definition)
+        resp = self.aerie_host.post_to_graphql(
+            update_constraint_query, constarint_id=id, definition=definition
+        )
         return resp
-    
+
     def get_constraint_by_id(self, id):
         get_constraint_by_id_query = """
         query get_constraint($constraint_id: Int!) {
@@ -2018,9 +2034,11 @@ def get_constraint_by_id(self, id):
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(get_constraint_by_id_query, constraint_id=id)
+        resp = self.aerie_host.post_to_graphql(
+            get_constraint_by_id_query, constraint_id=id
+        )
         return resp
-    
+
     def get_constraint_specification_for_plan(self, plan_id):
         get_constraint_specification_for_plan_query = """
         query GetConstraintSpecificationForPlan($plan_id: Int!) {
@@ -2031,8 +2049,7 @@ def get_constraint_specification_for_plan(self, plan_id):
         """
 
         resp = self.aerie_host.post_to_graphql(
-            get_constraint_specification_for_plan_query, 
-            plan_id=plan_id
+            get_constraint_specification_for_plan_query, plan_id=plan_id
         )
         return resp[0]["id"]
 
@@ -2140,12 +2157,9 @@ def add_directive_metadata_schemas(self, schemas: list) -> list:
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(
-            add_schemas_query,
-            schemas=schemas
-        )
+        resp = self.aerie_host.post_to_graphql(add_schemas_query, schemas=schemas)
         return resp
-        
+
     def delete_directive_metadata_schema(self, key) -> list:
         """Delete metadata schemas
 
@@ -2160,10 +2174,7 @@ def delete_directive_metadata_schema(self, key) -> list:
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(
-            delete_schema_query,
-            key=key
-        )
+        resp = self.aerie_host.post_to_graphql(delete_schema_query, key=key)
         return resp["key"]
 
     def list_plan_collaborators(self, plan_id: int) -> list:
@@ -2185,10 +2196,7 @@ def list_plan_collaborators(self, plan_id: int) -> list:
         }
         """
 
-        resp = self.aerie_host.post_to_graphql(
-            query,
-            plan_id=plan_id
-        )
+        resp = self.aerie_host.post_to_graphql(query, plan_id=plan_id)
         return [c["collaborator"] for c in resp["collaborators"]]
 
     def add_plan_collaborator(self, plan_id: int, user: str):
@@ -2206,11 +2214,7 @@ def add_plan_collaborator(self, plan_id: int, user: str):
         }
         """
 
-        self.aerie_host.post_to_graphql(
-            query,
-            plan_id=plan_id,
-            collaborator=user
-        )
+        self.aerie_host.post_to_graphql(query, plan_id=plan_id, collaborator=user)
 
     def delete_plan_collaborator(self, plan_id: int, user: str):
         """Delete a plan collaborator
@@ -2230,10 +2234,67 @@ def delete_plan_collaborator(self, plan_id: int, user: str):
         """
 
         resp = self.aerie_host.post_to_graphql(
-            query,
-            plan_id=plan_id,
-            collaborator=user
+            query, plan_id=plan_id, collaborator=user
         )
 
         if resp is None:
             raise RuntimeError(f"Failed to delete plan collaborator")
+
+    def create_workspace(
+        self,
+        name: str,
+        parcel_id: int,
+        disk_location: Optional[str] = None,
+    ):
+        """create a new workspace"""
+
+        if disk_location is None:
+            disk_location = name
+
+        return self.aerie_host.create_workspace(name, parcel_id, disk_location)
+
+    def list_workspaces(self):
+        """list workspaces in file store"""
+
+        query = """
+        query {
+            workspace {
+                id
+                name
+                disk_location
+            }
+        }
+        """
+
+        resp = self.aerie_host.post_to_graphql(query)
+        return resp
+
+    def put_workspace_file(
+        self,
+        workspace_id: int,
+        filepath: str,
+        contents: bytes,
+    ) -> str:
+        return self.aerie_host.put_workspace_file(workspace_id, filepath, contents)
+
+    def put_workspace_directory(
+        self,
+        workspace_id: int,
+        filepath: str,
+    ) -> str:
+        return self.aerie_host.put_workspace_directory(workspace_id, filepath)
+
+    def get_workspace_file(
+        self,
+        workspace_id: int,
+        filepath: str,
+    ) -> bytes:
+        return self.aerie_host.get_workspace_file(workspace_id, filepath)
+
+    def list_files(
+        self,
+        workspace_id: int,
+        prefix: Optional[str],
+        depth: Optional[int],
+    ):
+        return self.aerie_host.list_files(workspace_id, prefix, depth)
diff --git a/src/aerie_cli/aerie_host.py b/src/aerie_cli/aerie_host.py
index c7d1c9e..3a999e7 100644
--- a/src/aerie_cli/aerie_host.py
+++ b/src/aerie_cli/aerie_host.py
@@ -1,4 +1,6 @@
 import json
+from posixpath import basename
+from urllib.parse import urlencode
 import requests
 from copy import deepcopy
 from typing import Dict
@@ -13,8 +15,10 @@
     "3.1.0",
     "3.1.1",
     "3.2.0",
+    "3.4.0",
 ]
 
+
 class AerieHostVersionError(RuntimeError):
     pass
 
@@ -54,7 +58,9 @@ def __init__(self, encoded_jwt: str) -> None:
             self.allowed_roles = payload["https://hasura.io/jwt/claims"][
                 "x-hasura-allowed-roles"
             ]
-            self.default_role = payload["https://hasura.io/jwt/claims"]["x-hasura-default-role"]
+            self.default_role = payload["https://hasura.io/jwt/claims"][
+                "x-hasura-default-role"
+            ]
             self.username = payload["username"]
 
         except KeyError:
@@ -78,6 +84,7 @@ def __init__(
         self,
         graphql_url: str,
         gateway_url: str,
+        filestore_url: str,
         session: requests.Session = None,
         configuration_name: str = None,
     ) -> None:
@@ -92,6 +99,7 @@ def __init__(
         self.session = session if session else requests.Session()
         self.graphql_url = graphql_url
         self.gateway_url = gateway_url
+        self.filestore_url = filestore_url
         self.configuration_name = configuration_name
         self.aerie_jwt = None
         self.active_role = None
@@ -127,9 +135,7 @@ def post_to_graphql(self, query: str, **kwargs) -> Dict:
             if "success" in resp_json.keys() and not resp_json["success"]:
                 raise RuntimeError("GraphQL request was not successful")
             elif "errors" in resp_json.keys():
-                raise RuntimeError(
-                    f"GraphQL Error: {json.dumps(resp_json['errors'])}"
-                )
+                raise RuntimeError(f"GraphQL Error: {json.dumps(resp_json['errors'])}")
             else:
                 data = next(iter(resp.json()["data"].values()))
 
@@ -201,6 +207,78 @@ def post_to_gateway_files(self, file_name: str, file_contents: bytes) -> Dict:
         else:
             raise RuntimeError(f"Error uploading file: {file_name}")
 
+    def create_workspace(
+        self,
+        name: str,
+        parcel_id: int,
+        disk_location: str,
+    ) -> int:
+        file_url = f"{self.filestore_url}/ws/create"
+        resp = self.session.post(
+            file_url,
+            json={
+                "workspaceLocation": disk_location,
+                "parcelId": parcel_id,
+                "workspaceName": name,
+            },
+            headers=self.get_auth_headers(),
+        )
+        workspace_id = int(resp.text)
+        return workspace_id
+
+    def put_workspace_file(
+        self,
+        workspace_id: int,
+        path: str,
+        file_contents: bytes,
+    ) -> str:
+        """Save file contents to workspace"""
+        file_url = f"{self.filestore_url}/ws/{workspace_id}/{path}?type=file"
+        self.session.put(
+            file_url,
+            files={"file": (basename(path), file_contents)},
+            headers=self.get_auth_headers(),
+        )
+        return file_url
+
+    def put_workspace_directory(
+        self,
+        workspace_id: int,
+        path: str,
+    ) -> str:
+        """Save directory to workspace"""
+        file_url = f"{self.filestore_url}/ws/{workspace_id}/{path}?type=directory"
+        self.session.put(
+            file_url,
+            headers=self.get_auth_headers(),
+        )
+        return file_url
+
+    def get_workspace_file(
+        self,
+        workspace_id: int,
+        path: str,
+    ) -> bytes:
+        """Save file contents from workspace"""
+        file_url = f"{self.filestore_url}/ws/{workspace_id}/{path}"
+        resp = self.session.get(
+            file_url,
+            headers=self.get_auth_headers(),
+        )
+        return resp.content
+
+    def list_files(
+        self,
+        workspace_id: int,
+        prefix: Optional[str],
+        depth: Optional[int],
+    ):
+        """List"""
+        sub_dir = "" if prefix is None else f"/{prefix}"
+        qs = "" if depth is None else f'?{urlencode({"depth": depth})}'
+        list_url = f"{self.filestore_url}/ws/{workspace_id}{sub_dir}{qs}"
+        return self.session.get(list_url, headers=self.get_auth_headers())
+
     def change_role(self, new_role: str) -> None:
         """Change role for Aerie interaction
 
@@ -217,7 +295,7 @@ def change_role(self, new_role: str) -> None:
 
     def check_auth(self) -> bool:
         """Checks if session is correctly authenticated with Aerie host
-        
+
         Looks for errors received after pinging GATEWAY_URL/auth/session.
         Also returns False if the session has not yet been authenticated (no JWT).
 
@@ -254,11 +332,14 @@ def is_auth_enabled(self) -> bool:
             bool: False if authentication is disabled, otherwise True
         """
         # Try to login using blank credentials. If "Authentication is disabled" is returned, we can safely skip auth
-        resp = self.session.post(self.gateway_url + "/auth/login", json={"username": "", "password": ""},)
+        resp = self.session.post(
+            self.gateway_url + "/auth/login",
+            json={"username": "", "password": ""},
+        )
 
         if resp.ok:
             try:
-                resp_json = process_gateway_response(resp)                
+                resp_json = process_gateway_response(resp)
                 if (
                     "message" in resp_json.keys()
                     and resp_json["message"] == "Authentication is disabled"
@@ -311,8 +392,10 @@ def check_aerie_version(self) -> None:
         except (RuntimeError, KeyError):
             # If the Gateway responded, the route doesn't exist
             if resp.text and "Aerie Gateway" in resp.text:
-                raise AerieHostVersionError("Incompatible Aerie version: host version unknown")
-            
+                raise AerieHostVersionError(
+                    "Incompatible Aerie version: host version unknown"
+                )
+
             # Otherwise, it could just be a failed connection
             raise
 
@@ -372,6 +455,7 @@ class AerieHostConfiguration:
     name: str
     graphql_url: str
     gateway_url: str
+    filestore_url: str
     username: Optional[str] = field(default=None)
     external_auth: Optional[ExternalAuthConfiguration] = field(default=None)
 
@@ -381,19 +465,27 @@ def from_dict(cls, config: Dict) -> "AerieHostConfiguration":
             name = config["name"]
             graphql_url = config["graphql_url"]
             gateway_url = config["gateway_url"]
+            filestore_url = config["filestore_url"]
             username = config["username"] if "username" in config.keys() else None
-            external_auth = ExternalAuthConfiguration.from_dict(config["external_auth"]) if "external_auth" in config.keys() else None
+            external_auth = (
+                ExternalAuthConfiguration.from_dict(config["external_auth"])
+                if "external_auth" in config.keys()
+                else None
+            )
 
         except KeyError as e:
             raise ValueError(f"Configuration missing required field: {e.args[0]}")
 
-        return cls(name, graphql_url, gateway_url, username, external_auth)
+        return cls(
+            name, graphql_url, gateway_url, filestore_url, username, external_auth
+        )
 
     def to_dict(self) -> Dict:
         retval = {
             "name": self.name,
             "graphql_url": self.graphql_url,
-            "gateway_url": self.gateway_url
+            "gateway_url": self.gateway_url,
+            "filestore_url": self.filestore_url,
         }
 
         if self.username is not None:
diff --git a/src/aerie_cli/app.py b/src/aerie_cli/app.py
index 7ffed17..40ff098 100644
--- a/src/aerie_cli/app.py
+++ b/src/aerie_cli/app.py
@@ -2,6 +2,7 @@
 
 `app` is the CLI application with which all commands, subcommands, and callbacks are registered.
 """
+
 import typer
 from typing import Optional
 
@@ -12,6 +13,7 @@
 from aerie_cli.commands import constraints
 from aerie_cli.commands import scheduling
 from aerie_cli.commands import metadata
+from aerie_cli.commands import workspace
 
 from aerie_cli.commands.command_context import CommandContext
 from aerie_cli.__version__ import __version__
@@ -34,6 +36,7 @@
 app.add_typer(constraints.app, name="constraints")
 app.add_typer(scheduling.app, name="scheduling")
 app.add_typer(metadata.app, name="metadata")
+app.add_typer(workspace.app, name="workspace")
 
 
 def print_version(print_version: bool):
@@ -86,12 +89,20 @@ def activate_session(
         None, "--name", "-n", help="Name for this configuration", metavar="NAME"
     ),
     username: str = typer.Option(
-        None, "--username", "-u", help="Specify/override configured Aerie username", metavar="USERNAME"
+        None,
+        "--username",
+        "-u",
+        help="Specify/override configured Aerie username",
+        metavar="USERNAME",
     ),
     role: str = typer.Option(
         None, "--role", "-r", help="Specify a non-default role", metavar="ROLE"
     ),
-    force: bool = typer.Option(False, "--force", help="Force connection to Aerie host and ignore version compatibility")
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="Force connection to Aerie host and ignore version compatibility",
+    ),
 ):
     """
     Activate a session with an Aerie host using a given configuration
diff --git a/src/aerie_cli/commands/command_context.py b/src/aerie_cli/commands/command_context.py
index 69e6d83..86119ea 100644
--- a/src/aerie_cli/commands/command_context.py
+++ b/src/aerie_cli/commands/command_context.py
@@ -1,10 +1,14 @@
 import typer
 from aerie_cli.aerie_client import AerieClient
-from aerie_cli.utils.sessions import get_active_session_client, start_session_from_configuration
+from aerie_cli.utils.sessions import (
+    get_active_session_client,
+    start_session_from_configuration,
+)
 from aerie_cli.aerie_host import AerieHostConfiguration
 
 app = typer.Typer()
 
+
 class CommandContext:
     hasura_admin_secret: str = None
     alternate_configuration: AerieHostConfiguration = None
@@ -33,8 +37,12 @@ def get_client(cls) -> AerieClient:
         if cls.hasura_admin_secret:
             if client.aerie_host.aerie_jwt is None:
                 raise RuntimeError(f"Unauthenticated Aerie session")
-            client.aerie_host.session.headers["x-hasura-admin-secret"] = cls.hasura_admin_secret
+            client.aerie_host.session.headers["x-hasura-admin-secret"] = (
+                cls.hasura_admin_secret
+            )
             client.aerie_host.session.headers["x-hasura-role"] = "aerie_admin"
-            client.aerie_host.session.headers["x-hasura-user-id"] = client.aerie_host.aerie_jwt.username
+            client.aerie_host.session.headers["x-hasura-user-id"] = (
+                client.aerie_host.aerie_jwt.username
+            )
 
         return client
diff --git a/src/aerie_cli/commands/workspace.py b/src/aerie_cli/commands/workspace.py
new file mode 100644
index 0000000..553f6f2
--- /dev/null
+++ b/src/aerie_cli/commands/workspace.py
@@ -0,0 +1,149 @@
+from genericpath import isdir
+from os import walk
+from posixpath import join, normpath, relpath
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from aerie_cli.commands.command_context import CommandContext
+
+app = typer.Typer()
+
+app.command()
+
+
+@app.command()
+def create(
+    name: str = typer.Option(
+        ...,
+        "--name",
+        "-n",
+        help="The name of the workspace",
+    ),
+    parcel: int = typer.Option(
+        ...,
+        "--parcel_id",
+        "-p",
+        help="The parcel id",
+    ),
+):
+    """Create workspace and provide parcel foreign key"""
+    client = CommandContext.get_client()
+    resp = client.create_workspace(name=name, parcel_id=parcel)
+    typer.echo(f"Created new workspaces with id: {resp}")
+
+
+@app.command()
+def list(
+    workspace_id: Optional[int] = typer.Option(
+        None, "--workspace_id", "-w", help="Workspace id to list"
+    ),
+    base_directory: Optional[str] = typer.Option(
+        None, "--base_directory", "-b", help="Path of directory within workspace"
+    ),
+    depth: Optional[int] = typer.Option(
+        None, "--depth", "-d", help="Path of directory within workspace"
+    ),
+):
+    """List workspaces or their contents if a workspace_id is provided.
+
+    Depth is counted as number of levels below,
+    0 indicates only the current level,
+    1 includes next level of children"""
+
+    if workspace_id is None:
+        list_workspaces()
+    else:
+        list_workspace_contents(workspace_id, base_directory, depth)
+
+
+def list_workspaces():
+    client = CommandContext.get_client()
+    resp = client.list_workspaces()
+
+    # Create output table
+    table = Table(title="Current Workspaces")
+    table.add_column("Workspace ID", style="magenta")
+    table.add_column("Workspace Name", no_wrap=True)
+    table.add_column("Workspace Disk Location", no_wrap=True)
+    for workspace in resp:
+        table.add_row(
+            str(workspace["id"]),
+            workspace["name"],
+            workspace["disk_location"],
+        )
+
+    console = Console()
+    console.print(table)
+
+
+def list_workspace_contents(
+    workspace_id: int,
+    prefix: Optional[str] = None,
+    depth: Optional[int] = -1,
+):
+    client = CommandContext.get_client()
+    resp = client.list_files(workspace_id, prefix, depth)
+    console = Console()
+    console.print(resp.text)
+
+
+@app.command()
+def save(
+    workspace_id: int = typer.Option(
+        ..., "--workspace_id", "-w", help="Id of workspace to save file to"
+    ),
+    workspace_path: str = typer.Option(
+        ..., "--path", "-p", help="The relative path within the workspace"
+    ),
+    local_path: str = typer.Option(..., "--file", "-f", help="The local path"),
+):
+    """Save file passed in via local_path to workspace_path within workspace_id"""
+    client = CommandContext.get_client()
+
+    for filepath in contained_files(local_path):
+        if isdir(filepath):
+            client.put_workspace_directory(workspace_id, filepath)
+        else:
+            ws_path = normpath(join(workspace_path, relpath(filepath, local_path)))
+            with open(filepath, "rb") as f:
+                resp = client.put_workspace_file(
+                    workspace_id=workspace_id,
+                    filepath=ws_path,
+                    contents=f.read(),
+                )
+                typer.echo(f'File saved to "{resp}"')
+
+
+def contained_files(path: str):
+    """Returns directory paths first to not rely on file store creating them automatically"""
+    yield path
+    if isdir(path):
+        for dirpath, dirs, files in walk(path):
+            for d in dirs:
+                yield join(dirpath, d)
+            for f in files:
+                yield join(dirpath, f)
+
+
+@app.command()
+def get(
+    workspace_id: int = typer.Option(
+        ..., "--workspace_id", "-w", help="Id of workspace to get file from"
+    ),
+    workspace_path: str = typer.Option(
+        ..., "--path", "-p", help="The relative path within the workspace"
+    ),
+    local_path: Optional[str] = typer.Option(
+        None, "--file", "-f", help="The local path to write file to"
+    ),
+):
+    client = CommandContext.get_client()
+    resp = client.get_workspace_file(workspace_id, workspace_path)
+    if local_path is not None:
+        with open(local_path, "wb") as f:
+            f.write(resp)
+    else:
+        typer.echo(resp)
diff --git a/src/aerie_cli/persistent.py b/src/aerie_cli/persistent.py
index 55ff53c..5c1c578 100644
--- a/src/aerie_cli/persistent.py
+++ b/src/aerie_cli/persistent.py
@@ -16,14 +16,14 @@
 from aerie_cli.aerie_host import AerieHost, AerieHostConfiguration
 
 # TODO add app version s.t. changes to configuration formats can be managed
-APP_DIRS = AppDirs('aerie_cli')
-CONFIGURATION_FILE_DIRECTORY = Path(
-    APP_DIRS.user_config_dir).resolve().absolute()
-CONFIGURATION_FILE_PATH = CONFIGURATION_FILE_DIRECTORY.joinpath('config.json')
+APP_DIRS = AppDirs("aerie_cli")
+CONFIGURATION_FILE_DIRECTORY = Path(APP_DIRS.user_config_dir).resolve().absolute()
+CONFIGURATION_FILE_PATH = CONFIGURATION_FILE_DIRECTORY.joinpath("config.json")
 
 SESSION_FILE_DIRECTORY = Path(APP_DIRS.user_config_dir).resolve().absolute()
-SESSION_TIMESTAMP_FSTRING = r'%Y-%jT%H-%M-%S.%f'
+SESSION_TIMESTAMP_FSTRING = r"%Y-%jT%H-%M-%S.%f"
 SESSION_TIMEOUT = timedelta(hours=12)
+SESSION_FILE_PATTERN = "*.aerie_cli.session"
 
 
 def delete_all_persistent_files():
@@ -49,10 +49,14 @@ def get_configurations(cls) -> List[AerieHostConfiguration]:
         return cls._configurations
 
     @classmethod
-    def get_configuration_by_name(cls, configuration_name: str) -> AerieHostConfiguration:
+    def get_configuration_by_name(
+        cls, configuration_name: str
+    ) -> AerieHostConfiguration:
         cls._initialize()
         try:
-            return next(filter(lambda c: c.name == configuration_name, cls._configurations))
+            return next(
+                filter(lambda c: c.name == configuration_name, cls._configurations)
+            )
         except StopIteration:
             raise ValueError(f"Unknown configuration: {configuration_name}")
 
@@ -60,8 +64,7 @@ def get_configuration_by_name(cls, configuration_name: str) -> AerieHostConfigur
     def create_configuration(cls, configuration: AerieHostConfiguration) -> None:
         cls._initialize()
         if configuration.name in [c.name for c in cls._configurations]:
-            raise ValueError(
-                f"Configuration already exists: {configuration.name}")
+            raise ValueError(f"Configuration already exists: {configuration.name}")
 
         cls._configurations.append(configuration)
         cls.write_configurations()
@@ -71,7 +74,7 @@ def update_configuration(cls, configuration: AerieHostConfiguration) -> None:
         cls._initialize()
         old_configuration = cls.get_configuration_by_name(configuration.name)
         idx = cls._configurations.index(old_configuration)
-        cls._configurations[idx] = (configuration)
+        cls._configurations[idx] = configuration
         cls.write_configurations()
 
     @classmethod
@@ -85,21 +88,23 @@ def delete_configuration(cls, configuration_name: str) -> None:
     def write_configurations(cls) -> None:
         confs = [c.to_dict() for c in cls._configurations]
         CONFIGURATION_FILE_DIRECTORY.mkdir(exist_ok=True, parents=True)
-        with open(CONFIGURATION_FILE_PATH, 'w') as fid:
+        with open(CONFIGURATION_FILE_PATH, "w") as fid:
             json.dump(confs, fid, indent=2)
 
     @classmethod
     def read_configurations(cls) -> None:
         CONFIGURATION_FILE_DIRECTORY.mkdir(exist_ok=True, parents=True)
         if CONFIGURATION_FILE_PATH.is_file():
-            with open(CONFIGURATION_FILE_PATH, 'r') as fid:
+            with open(CONFIGURATION_FILE_PATH, "r") as fid:
                 try:
                     raw_confs = json.load(fid)
                 except json.JSONDecodeError:
                     raise RuntimeError(
-                        f"Unable to read configuration file: {str(CONFIGURATION_FILE_PATH)}")
+                        f"Unable to read configuration file: {str(CONFIGURATION_FILE_PATH)}"
+                    )
             cls._configurations = [
-                AerieHostConfiguration.from_dict(c) for c in raw_confs]
+                AerieHostConfiguration.from_dict(c) for c in raw_confs
+            ]
         else:
             cls._configurations = []
 
@@ -123,7 +128,8 @@ def _load_active_session(cls) -> None:
 
         # Get any/all open sessions. List in chronological order, newest first
         session_files: List[Path] = [
-            f for f in SESSION_FILE_DIRECTORY.glob('*.aerie_cli.session')]
+            f for f in SESSION_FILE_DIRECTORY.glob(SESSION_FILE_PATTERN)
+        ]
         session_files.sort(reverse=True)
 
         if not len(session_files):
@@ -137,9 +143,13 @@ def _load_active_session(cls) -> None:
         session_file = session_files[0]
         try:
             t = datetime.strptime(
-                session_file.name[:-(len('.aerie_cli.session'))], SESSION_TIMESTAMP_FSTRING)
+                session_file.name[: -(len(".aerie_cli.session"))],
+                SESSION_TIMESTAMP_FSTRING,
+            )
         except Exception:
-            raise RuntimeError(f"Cannot parse session timestamp: {session_file.name}. Try deactivating your session.")
+            raise RuntimeError(
+                f"Cannot parse session timestamp: {session_file.name}. Try deactivating your session."
+            )
 
         # If session hasn't been used since timeout, mark as inactive
         if (datetime.now(timezone.utc).replace(tzinfo=None) - t) > SESSION_TIMEOUT:
@@ -148,7 +158,7 @@ def _load_active_session(cls) -> None:
 
         # Un-pickle the session
         try:
-            with open(session_file, 'rb') as fid:
+            with open(session_file, "rb") as fid:
                 session: AerieHost = pickle.load(fid)
         except Exception:
             session_file.unlink()
@@ -171,16 +181,20 @@ def set_active_session(cls, session: AerieHost) -> bool:
             return False
 
         session_files: List[Path] = [
-            f for f in SESSION_FILE_DIRECTORY.glob('*.aerie_cli.session')]
+            f for f in SESSION_FILE_DIRECTORY.glob(SESSION_FILE_PATTERN)
+        ]
         for session_file in session_files:
             session_file.unlink()
 
         cls._active_session = session
 
-        session_file = datetime.now(timezone.utc).strftime(SESSION_TIMESTAMP_FSTRING) + '.aerie_cli.session'
+        session_file = (
+            datetime.now(timezone.utc).strftime(SESSION_TIMESTAMP_FSTRING)
+            + ".aerie_cli.session"
+        )
         session_file = SESSION_FILE_DIRECTORY.joinpath(session_file)
 
-        with open(session_file, 'wb') as fid:
+        with open(session_file, "wb") as fid:
             pickle.dump(session, fid)
 
         return True
@@ -198,8 +212,7 @@ def unset_active_session(cls) -> str:
         except NoActiveSessionError:
             return None
 
-        fs: List[Path] = [
-            f for f in SESSION_FILE_DIRECTORY.glob('*.aerie_cli.session')]
+        fs: List[Path] = [f for f in SESSION_FILE_DIRECTORY.glob(SESSION_FILE_PATTERN)]
         for fn in fs:
             fn.unlink()
 
@@ -212,8 +225,7 @@ def reset(cls) -> None:
         cls._active_session = None
 
         # Get any/all open sessions. List in chronological order, newest first
-        fs: List[Path] = [
-            f for f in SESSION_FILE_DIRECTORY.glob('*.aerie_cli.session')]
+        fs: List[Path] = [f for f in SESSION_FILE_DIRECTORY.glob(SESSION_FILE_PATTERN)]
         if not len(fs):
             return
         # Delete all session files
diff --git a/src/aerie_cli/schemas/api.py b/src/aerie_cli/schemas/api.py
index 5315003..bc79b5e 100644
--- a/src/aerie_cli/schemas/api.py
+++ b/src/aerie_cli/schemas/api.py
@@ -24,6 +24,7 @@
 
 import json
 
+
 def convert_to_time_delta(t: Union[str, timedelta]) -> timedelta:
     """Convert a string to timedelta.
 
@@ -33,6 +34,7 @@ def convert_to_time_delta(t: Union[str, timedelta]) -> timedelta:
         return t
     return postgres_interval_to_timedelta(t)
 
+
 def serialize_api(inst: type, field: Attribute, value: Any):
     if isinstance(value, timedelta):
         return timedelta_to_postgres_interval(value)
@@ -40,21 +42,26 @@ def serialize_api(inst: type, field: Attribute, value: Any):
         return str(value)
     return value
 
+
 class ApiSerialize:
     @classmethod
     def from_dict(cls, dictionary: Dict) -> "ApiSerialize":
         return cls(**dictionary)
+
     def to_dict(self) -> Dict:
         return asdict(self, value_serializer=serialize_api)
+
     @classmethod
     def from_json(cls, dictionary: Dict) -> "ApiSerialize":
         return cls(**json.loads(dictionary))
 
+
 @define
 class ApiEffectiveActivityArguments(ApiSerialize):
     arguments: Dict[str, Any]
     success: bool
 
+
 @define
 class ActivityBase(ApiSerialize):
     """Base dataclass for an activity directive
@@ -63,14 +70,10 @@ class ActivityBase(ApiSerialize):
     """
 
     type: str
-    start_offset: timedelta = field(
-        converter = convert_to_time_delta
-    )
+    start_offset: timedelta = field(converter=convert_to_time_delta)
     metadata: Optional[Dict[str, str]] = field(factory=lambda: {}, kw_only=True)
     name: Optional[str] = field(factory=lambda: "", kw_only=True)
-    arguments: Optional[Dict[str, Any]] = field(
-        factory=lambda: [], kw_only=True
-    )
+    arguments: Optional[Dict[str, Any]] = field(factory=lambda: [], kw_only=True)
     anchor_id: Optional[int] = field(default=None, kw_only=True)
     anchored_to_start: Optional[bool] = field(default=None, kw_only=True)
 
@@ -79,7 +82,9 @@ def __attrs_post_init__(self):
         # Enforce that anchored_to_start must be specified if an anchor ID is given
         if self.anchored_to_start is None:
             if self.anchor_id is not None:
-                raise ValueError(f"anchor_id was specified but anchored_to_start was not")
+                raise ValueError(
+                    "anchor_id was specified but anchored_to_start was not"
+                )
             self.anchored_to_start = True
 
 
@@ -112,37 +117,40 @@ class ApiActivityRead(ActivityBase):
 
     id: int
 
+
 @define
 class ApiActivityPlanBase(ApiSerialize):
     model_id: int
     name: str
-    start_time: Arrow = field(
-        converter=arrow.get
-    )
+    start_time: Arrow = field(converter=arrow.get)
+
 
 @define
 class ApiActivityPlanCreate(ApiActivityPlanBase):
     duration: timedelta = field(
-        converter = convert_to_time_delta,
+        converter=convert_to_time_delta,
     )
 
+
 @define
 class ApiActivityPlanRead(ApiActivityPlanBase):
     id: int
     simulations: List[int]
     duration: timedelta = field(
-        converter = convert_to_time_delta,
+        converter=convert_to_time_delta,
     )
     activity_directives: Optional[List[ApiActivityRead]] = field(
-        default = None,
+        default=None,
         converter=converters.optional(
-            lambda listOfDicts: [ApiActivityRead.from_dict(d) if isinstance(d, dict) else d for d in listOfDicts])
+            lambda listOfDicts: [
+                ApiActivityRead.from_dict(d) if isinstance(d, dict) else d
+                for d in listOfDicts
+            ]
+        ),
     )
     tags: Optional[List[Dict]] = field(
-        default = [], 
-        converter=converters.optional(
-            lambda listOfDicts: [d for d in listOfDicts]
-        )
+        default=[],
+        converter=converters.optional(lambda listOfDicts: [d for d in listOfDicts]),
     )
 
 
@@ -150,12 +158,10 @@ class ApiActivityPlanRead(ApiActivityPlanBase):
 class ApiAsSimulatedActivity(ApiSerialize):
     type: str
     parent_id: Optional[str]
-    start_timestamp: Arrow = field(
-        converter = arrow.get
-    )
+    start_timestamp: Arrow = field(converter=arrow.get)
     children: List[str]
     duration: timedelta = field(
-        converter = lambda microseconds: timedelta(microseconds=microseconds)
+        converter=lambda microseconds: timedelta(microseconds=microseconds)
     )
     arguments: Dict[str, Any]
 
@@ -163,16 +169,14 @@ class ApiAsSimulatedActivity(ApiSerialize):
 @define
 class ApiSimulatedResourceSample(ApiSerialize):
     x: timedelta = field(
-        converter = lambda microseconds: timedelta(microseconds=microseconds)
+        converter=lambda microseconds: timedelta(microseconds=microseconds)
     )
     y: Any
 
 
 @define
 class ApiSimulationResults(ApiSerialize):
-    start: Arrow = field(
-        converter = arrow.get
-    )
+    start: Arrow = field(converter=arrow.get)
     activities: Dict[str, ApiAsSimulatedActivity]
     unfinishedActivities: Any
     # TODO: implement constraints
@@ -206,7 +210,17 @@ class ApiParcelCreate(ApiSerialize):
     channel_dictionary_id: int
     sequence_adaptation_id: int
 
+
 @define
 class ApiParcelRead(ApiParcelCreate):
     id: int
     parameter_dictionaries: Dict[str, int]
+
+
+@define
+class ApiWorkspaceCreate(ApiSerialize):
+    name: str
+    owner: str
+    parcel_id: int
+    disk_location: str
+    updated_by: str
diff --git a/src/aerie_cli/utils/sessions.py b/src/aerie_cli/utils/sessions.py
index dc85a83..f60968f 100644
--- a/src/aerie_cli/utils/sessions.py
+++ b/src/aerie_cli/utils/sessions.py
@@ -3,10 +3,16 @@
 import typer
 from copy import deepcopy
 
-from aerie_cli.aerie_host import AerieHost, AerieHostConfiguration, ExternalAuthConfiguration, AerieJWT
+from aerie_cli.aerie_host import (
+    AerieHost,
+    AerieHostConfiguration,
+    ExternalAuthConfiguration,
+    AerieJWT,
+)
 from aerie_cli.aerie_client import AerieClient
 from aerie_cli.persistent import PersistentSessionManager
 
+
 def get_active_session_client():
     """Instantiate AerieClient with the active host session
 
@@ -27,12 +33,14 @@ def get_localhost_client() -> AerieClient:
     return AerieClient(aerie_host)
 
 
-def get_preauthenticated_client_native(encoded_jwt: str, graphql_url: str, gateway_url: str) -> AerieClient:
+def get_preauthenticated_client_native(
+    encoded_jwt: str, graphql_url: str, gateway_url: str
+) -> AerieClient:
     """Get AerieClient instance preauthenticated with native Aerie JWT auth
 
     Args:
         encoded_jwt (str): base64-encoded Aerie JWT
-        graphql_url (str) 
+        graphql_url (str)
         gateway_url (str)
 
     Raises:
@@ -48,7 +56,9 @@ def get_preauthenticated_client_native(encoded_jwt: str, graphql_url: str, gatew
     return AerieClient(aerie_host)
 
 
-def get_preauthenticated_client_cookie(cookies: dict, encoded_jwt: str, graphql_url: str, gateway_url: str) -> AerieClient:
+def get_preauthenticated_client_cookie(
+    cookies: dict, encoded_jwt: str, graphql_url: str, gateway_url: str
+) -> AerieClient:
     """Get AerieClient instance preauthenticated with an external cookie(s) and JWT
 
     Args:
@@ -102,7 +112,9 @@ def authenticate_with_external(
         if secret_var_name in secret_post_vars.keys():
             post_vars[secret_var_name] = secret_post_vars[secret_var_name]
         else:
-            post_vars[secret_var_name] = typer.prompt(f"External authentication - {secret_var_name}", hide_input=True)
+            post_vars[secret_var_name] = typer.prompt(
+                f"External authentication - {secret_var_name}", hide_input=True
+            )
 
     resp = session.post(configuration.auth_url, json=post_vars)
 
@@ -115,11 +127,11 @@ def authenticate_with_external(
 
 
 def start_session_from_configuration(
-    configuration: AerieHostConfiguration, 
-    username: str = None, 
+    configuration: AerieHostConfiguration,
+    username: str = None,
     password: str = None,
     secret_post_vars: Dict[str, str] = None,
-    force: bool = False
+    force: bool = False,
 ):
     """Start and authenticate an Aerie Host session, with prompts if necessary
 
@@ -128,8 +140,8 @@ def start_session_from_configuration(
     If password is not provided but the Aerie instance has authentication enabled, it will be requested via CLI prompt.
     If the Aerie instance has authentication disabled, a password is not necessary.
 
-    If external authentication is specified in the configuration, `secret_post_vars` can be used to pass in 
-    credentials. If external auth is specified with secrets and matching credentials aren't provided, they will be 
+    If external authentication is specified in the configuration, `secret_post_vars` can be used to pass in
+    credentials. If external auth is specified with secrets and matching credentials aren't provided, they will be
     requested via CLI prompt.
 
     Args:
@@ -140,17 +152,20 @@ def start_session_from_configuration(
         force (bool, optional): Force connection to Aerie host and ignore version compatibility. Defaults to False.
 
     Returns:
-        AerieHost: 
+        AerieHost:
     """
 
     if configuration.external_auth is None:
         session = requests.Session()
     else:
-        session = authenticate_with_external(configuration.external_auth, secret_post_vars)
+        session = authenticate_with_external(
+            configuration.external_auth, secret_post_vars
+        )
 
     hs = AerieHost(
         configuration.graphql_url,
         configuration.gateway_url,
+        configuration.filestore_url,
         session,
         configuration.name,
     )
diff --git a/tests/unit_tests/test_aerie_host.py b/tests/unit_tests/test_aerie_host.py
index 29a0570..1447a1d 100644
--- a/tests/unit_tests/test_aerie_host.py
+++ b/tests/unit_tests/test_aerie_host.py
@@ -7,7 +7,8 @@
 
 class MockJWT:
     def __init__(self, *args, **kwargs):
-        self.default_role = 'viewer'
+        self.default_role = "viewer"
+
 
 class MockResponse:
     def __init__(self, json: Dict, text: str = None, ok: bool = True) -> None:
@@ -33,15 +34,16 @@ def post(self, *args, **kwargs) -> MockResponse:
         return self.mock_response
 
 
-def get_mock_aerie_host(json: Dict = None, text: str = None, ok: bool = True) -> AerieHost:
+def get_mock_aerie_host(
+    json: Dict = None, text: str = None, ok: bool = True
+) -> AerieHost:
     mock_response = MockResponse(json, text, ok)
     mock_session = MockSession(mock_response)
-    return AerieHost("", "", mock_session)
+    return AerieHost("", "", "", mock_session)
 
 
 def test_check_aerie_version():
-    aerie_host = get_mock_aerie_host(
-        json={"version": COMPATIBLE_AERIE_VERSIONS[0]})
+    aerie_host = get_mock_aerie_host(json={"version": COMPATIBLE_AERIE_VERSIONS[0]})
 
     aerie_host.check_aerie_version()
 
@@ -51,8 +53,10 @@ def test_authenticate_invalid_version(capsys, monkeypatch):
 
     def mock_get(*_, **__):
         return MockResponse({"version": "1.0.0"})
+
     def mock_post(*_, **__):
         return MockResponse({"token": ""})
+
     def mock_check_auth(*_, **__):
         return True
 
@@ -72,8 +76,10 @@ def test_authenticate_invalid_version_force(capsys, monkeypatch):
 
     def mock_get(*_, **__):
         return MockResponse({"version": "1.0.0"})
+
     def mock_post(*_, **__):
         return MockResponse({"token": ""})
+
     def mock_check_auth(*_, **__):
         return True
 
@@ -97,8 +103,7 @@ def test_no_version_endpoint():
 
 
 def test_version_broken_gateway():
-    aerie_host = get_mock_aerie_host(
-        text="502 Bad Gateway or something", ok=True)
+    aerie_host = get_mock_aerie_host(text="502 Bad Gateway or something", ok=True)
 
     with pytest.raises(RuntimeError) as e:
         aerie_host.check_aerie_version()