diff --git a/README.md b/README.md
index ac0c2c70..b7d79501 100644
--- a/README.md
+++ b/README.md
@@ -247,8 +247,6 @@ and how the output from one task will be consumed by another task(s). Such a wor
 also known as Directed Acyclic Graph (DAG).
 
 Here is an example of creating a sky and generating an octree as two consecutive steps.
-Note that the values are place-holders and can be overwritten by input parameters file.
-
 
 ```yaml
 
@@ -267,24 +265,13 @@ flow:
         inputs:
           parameters:
             - name: scene_files
-              value:
-                - "{{steps.generate_sky_steps.outputs.sky_file}}"
-                - "{{workflow.inputs.parameters.folder}}"/model/static/scene.mat
-                - "{{workflow.inputs.parameters.folder}}"/model/static/scene.rad
+              value: |
+                "{{tasks.generate_sky_steps.outputs.sky_file}}"
+                "{{workflow.inputs.parameters.folder}}"/model/static/scene.mat
+                "{{workflow.inputs.parameters.folder}}"/model/static/scene.rad
 
 ```
 
-As you can see it is common to use the output of one step as an input for another step or
-reference one of the workflow inputs as an input for one of the steps or tasks. Queenbee
-supports the following words as prefix variable names inside the `flow` section:
-
-- workflow: "{{workflow.xx.yy}} is used for workflow level parameters.
-- tasks: "{{tasks.task_name.xx.yy}} is used in DAG task to refer to other tasks.
-- inputs: "{{inputs.xx.yy}}" is used in operators.
-- item: "{{item}}" or "{{item.key_name}}" is used in loops. You can change item to a
-  different keyword by setting up `loop_var` in `loop_control`.
-
-
 Now let's think about a longer workflow which also includes ray-tracing using the
 generated octree. We need to add two new steps to the workflow:
 
@@ -298,8 +285,7 @@ generating the sensor grids we we do not need to wait for generating sky to be f
 Finally, the last step of ray-tracing will need both the grid and the octree.
 
 To describe such flows we will use a Directed Acyclic Graph or DAG. Here
-is the updated process. Note the the keyword `step` is changed to `tasks` and each `task`
-has a key for `dependency`.
+is the updated process.
 
 Also since the step for generating grids can generate more than one grid we are using
 loop to run ray-tracing for all these grids in parallel.
@@ -325,7 +311,7 @@ loop to run ray-tracing for all these grids in parallel.
 ```yaml
 
 flow:
-  - name: jjjjj
+  - name: sample-workflow
   - tasks:
     - name: generate_sky_task
       template: generate_sky
@@ -374,6 +360,46 @@ Outputs can also return `parameters` that are generated in the `process` section
 workflow. 
 
 
+## Variables
+
+As you can see it is common to use the output of one task as an input for another task or
+reference one of the workflow inputs as an input for one of the steps or tasks. Queenbee
+supports the following words as prefix variable names:
+
+### Global variables
+
+| Variable | Description|
+|----------|------------|
+| `workflow.name` | Replaced by workflow name |
+| `workflow.id` | Replaced by workflow id |
+| `workflow.inputs.parameters.<NAME>` | Replaced by `value` for parameter `<NAME>` |
+| `workflow.inputs.artifacts.<NAME>` | Replaced by `path` for artifact `<NAME>` |
+| `workflow.operators.<OPERATORNAME>.image` | Replaced by image name for operator `<OPERATORNAME>` |
+
+### Flow variables
+
+| Variable | Description|
+|----------|------------|
+| `tasks.<TASKNAME>.outputs.parameters.<NAME>` | Output parameter of any previous task |
+| `tasks.<TASKNAME>.outputs.artifacts.<NAME>` | Output artifact of any previous task |
+
+### Task variables
+
+| Variable | Description|
+|----------|------------|
+| `inputs.parameters.<NAME>` | Input parameter of task `<NAME>`|
+| `inputs.artifacts.<NAME>` | Input artifact of task `<NAME>`|
+| `outputs.parameters.<NAME>` | Output parameter of task `<NAME>`|
+| `outputs.artifacts.<NAME>` | Output artifact of task `<NAME>`|
+
+### Loops
+
+| Variable | Description|
+|----------|------------|
+| `item` | Replaced by the value of item |
+| `item.<FIELDNAME>` | Replaced by the field value of the item |
+
+
 # TODO: Command Line Interface
 
 You can also use queenbee from command line. The most commonly used commands are:
diff --git a/queenbee/schema/arguments.py b/queenbee/schema/arguments.py
index 4c9a5c38..ede4d2e9 100644
--- a/queenbee/schema/arguments.py
+++ b/queenbee/schema/arguments.py
@@ -9,9 +9,10 @@
     2. Artifact: An ``artifact`` is a file or folder that can be identified by a url or
         a path.
 """
-from queenbee.schema.qutil import BaseModel
+from queenbee.schema.qutil import BaseModel, find_dup_items
 from queenbee.schema.artifact_location import VerbEnum
-from pydantic import Field
+import queenbee.schema.variable as qbvar
+from pydantic import Field, root_validator
 from typing import List, Any, Optional, Dict
 
 
@@ -40,22 +41,69 @@ class Parameter(BaseModel):
 
     path: str = Field(
         None,
-        description='load parameters from a file. File can be a JSON / YAML or a text file.'
+        description='Load parameters values from a JSON file.'
     )
 
+    @root_validator
+    def validate_vars(cls, values):
+        """Validate input values."""
+        name = values.get('name')
+        value = values.get('value')
+        path = values.get('path')
+        if value and path:
+            raise ValueError(
+                f'You should either set value or path for parameter {name}.'
+            )
+
+        value = value if value is not None else path
+        if not value or isinstance(value, (int, float)):
+            return values
+        # check if it is a referenced variable
+        ref_var = qbvar.get_ref_variable(value)
+
+        if ref_var:
+            for rv in ref_var:
+                qbvar.validate_ref_variable_format(rv)
+
+        return values
+
+    @property
+    def current_value(self):
+        """Try to get the current value.
+
+        This method checks the ``value`` property first and if it is None it will return
+        the value for ``path``.
+        """
+        return self.value if self.value is not None else self.path
+
+    @property
+    def ref_vars(self) -> Dict[str, List[str]]:
+        """Get referenced variables if any.
+
+        """
+        value = self.current_value
+        if not value:
+            return {}
+
+        ref_var = qbvar.get_ref_variable(value)
+        if not ref_var:
+            return {}
+
+        return {'value': ref_var} if self.value is not None else {'path': ref_var}
+
 
 class Artifact(BaseModel):
-    """Artifact indicates an artifact to place at a specified path"""
+    """Artifact indicates an artifact to be placed at a specified path."""
 
     name: str = Field(
         ...,
-        description='name of the artifact. must be unique within a task\'s '
+        description='Name of the artifact. Must be unique within a task\'s '
         'inputs / outputs.'
     )
 
     location: str = Field(
-        None,
-        description="Name of the Artifact Location to source this artifact from."
+        None,  # is it possible to create an artifact with no artifact location?
+        description="Name of the artifact_location to source this artifact from."
     )
 
     source_path: str = Field(
@@ -75,14 +123,65 @@ class Artifact(BaseModel):
 
     headers: Optional[Dict[str, str]] = Field(
         None,
-        description="An object with Key Value pairs of HTTP headers. For artifacts from URL Location only"
+        description='An object with Key Value pairs of HTTP headers. '
+        'For artifacts from URL location only.'
     )
 
     verb: Optional[VerbEnum] = Field(
         None,
-        description="The HTTP verb to use when making the request. For artifacts from URL Location only"
+        description='The HTTP verb to use when making the request. '
+        'For artifacts from URL location only.'
     )
 
+    @root_validator
+    def validate_vars(cls, values):
+        """Validate input values."""
+        input_values = [
+            v for v in (values.get('location'), values.get('path'),
+            values.get('source_path')) if v is not None
+        ]
+
+        if not input_values:
+            return values
+
+        for value in values:
+            # check if it is a referenced variable
+            ref_var = qbvar.get_ref_variable(value)
+            if not ref_var:
+                continue
+            for rv in ref_var:
+                qbvar.validate_ref_variable_format(rv)
+
+        return values
+
+    @property
+    def current_value(self):
+        """Try to get the current value.
+
+        This method checks the ``path`` property first and if it is None it will return
+        the value for ``source_path``.
+        """
+        return self.path if self.path is not None else self.source_path
+
+    @property
+    def ref_vars(self) -> Dict[str, List[str]]:
+        """Get referenced variables if any."""
+        ref_values = {}
+        values = [
+            v for v in (self.location, self.path, self.source_path)
+            if v is not None
+        ]
+
+        if not values:
+            return ref_values
+
+        for value in values:
+            ref_var = qbvar.get_ref_variable(value)
+            if ref_var:
+                ref_values[value] = ref_var
+
+        return ref_values
+
 
 class Arguments(BaseModel):
     """Arguments to a task or a workflow.
@@ -104,3 +203,35 @@ class Arguments(BaseModel):
         description='Artifacts is the list of file and folder arguments to pass to the '
         'task or workflow.'
     )
+
+    @root_validator
+    def unique_names(cls, values):
+        params = values.get('parameters')
+        if params:
+            param_names = [par.name for par in params]
+            if len(param_names) != len(set(param_names)):
+                dup = find_dup_items(param_names)
+                raise ValueError(f'Duplicate parameter names: {dup}')
+        artifacts = values.get('artifacts')
+        if artifacts:
+            artifact_names = [par.name for par in artifacts]
+            if len(artifact_names) != len(set(artifact_names)):
+                dup = find_dup_items(artifact_names)
+                raise ValueError(f'Duplicate artifact names: {dup}')
+        return values
+
+    def get_parameter_value(self, name):
+        """Get a parameter value by name."""
+        param = [par for par in self.parameters if par.name == name]
+        if not param:
+            raise ValueError(f'Invalid parameter name: {name}')
+        return param[0].current_value
+
+    def get_artifact_value(self, name):
+        """Get an artifact value by name."""
+        if not self.artifacts:
+            raise ValueError('Arguments has no artifacts')
+        param = [par for par in self.artifacts if par.name == name]
+        if not param:
+            raise ValueError(f'Invalid artifact name: {name}')
+        return param[0].current_value
diff --git a/queenbee/schema/artifact_location.py b/queenbee/schema/artifact_location.py
index a4417817..b2e0bd12 100644
--- a/queenbee/schema/artifact_location.py
+++ b/queenbee/schema/artifact_location.py
@@ -25,7 +25,7 @@ class VerbEnum(str, Enum):
 class ArtifactLocation(BaseModel):
     """ArtifactLocation
 
-    An Artifact Location System
+    An Artifact Location System.
     """
 
     name: str = Field(
@@ -35,7 +35,7 @@ class ArtifactLocation(BaseModel):
 
     root: str = Field(
         ...,
-        description="The root path to the artifacts."
+        description='The root path to the artifacts.'
     )
 
 
diff --git a/queenbee/schema/function.py b/queenbee/schema/function.py
index a5289dcb..94febe64 100644
--- a/queenbee/schema/function.py
+++ b/queenbee/schema/function.py
@@ -54,36 +54,6 @@ class Function(BaseModel):
         description='List of output arguments.'
     )
 
-    @validator('inputs')
-    def check_workflow_reference(cls, v):
-        if v == None:
-            return v
-
-        input_params = v.parameters
-
-        if input_params == None:
-            return v
-
-        ref_params = []
-
-        for param in input_params:
-            if not isinstance(param, (str, bytes)):
-                continue
-            if not param.value:
-                continue
-            if 'workflow.' in param.value:
-                ref_params.append(param)
-        if len(ref_params) > 0:
-            params = ['{}: {}'.format(param.name, param.value)
-                      for param in ref_params]
-            warnings.warn(
-                'Referencing workflow parameters in a template function makes the'
-                ' function less reusable. Try using inputs / outputs of the function'
-                ' instead and assign workflow values in flow section when calling'
-                ' this function.\n\t- {}'.format('\n\t-'.join(params))
-            )
-        return v
-
     def validate_all(self):
         """Check that all the elements of the function are valid together"""
         self.check_command_referenced_values()
diff --git a/queenbee/schema/parser.py b/queenbee/schema/parser.py
index 3eaff8c4..335cafb4 100644
--- a/queenbee/schema/parser.py
+++ b/queenbee/schema/parser.py
@@ -44,12 +44,12 @@ def _import_dict_data(dictionary, folder):
 
 
 def parse_file(input_file):
-    """Parse queenbee objects from an input JSON / YAML file.
+    """Parse queenbee objects from an input JSON or YAML file.
 
     This method will replace 'import_from' keys with the content from files recursively. 
 
     Args:
-        input_file: A YAML / JSON input file.
+        input_file: A YAML or JSON input file.
 
     Returns:
         The content of the input file as a dictionary.
diff --git a/queenbee/schema/qutil.py b/queenbee/schema/qutil.py
index e664978e..fa7794f8 100644
--- a/queenbee/schema/qutil.py
+++ b/queenbee/schema/qutil.py
@@ -1,13 +1,13 @@
-"""Queenbee utility methods."""
+"""Queenbee utility functions."""
 from pydantic import BaseModel as PydanticBaseModel
 from .parser import parse_file
 import yaml
 import json
+import collections
+from typing import List
 
 # set up yaml.dump to keep the order of the input dictionary
 # from https://stackoverflow.com/a/31609484/4394669
-
-
 def _keep_name_order_in_yaml():
     represent_dict_order = \
         lambda self, data:  self.represent_mapping(
@@ -58,3 +58,9 @@ def from_file(cls, filepath):
 
     def __repr__(self):
         return self.yaml()
+
+
+def find_dup_items(values: List) -> List:
+    """Find duplicate items in a list.""" 
+    dup = [t for t, c in collections.Counter(values).items() if c > 1]
+    return dup
diff --git a/queenbee/schema/variable.py b/queenbee/schema/variable.py
new file mode 100644
index 00000000..1c349fde
--- /dev/null
+++ b/queenbee/schema/variable.py
@@ -0,0 +1,94 @@
+"""A collection of methods to handle queenbee referenced variables.
+
+See README.md for a human readable version of valid variables.
+"""
+from .parser import parse_double_quotes_vars
+from typing import List, Union
+
+
+def get_ref_variable(value: Union[bytes, str]) -> List:
+    """Get referenced variable if any."""
+    return parse_double_quotes_vars(value)
+
+def _validate_workflow_var_format(value: str):
+    """Validate workflow vars."""
+    add_info = ''
+    parts = value.split('.')
+    if len(parts) == 2:
+        # workflow.id, workflow.name, item.field_name
+        typ, attr = parts
+        if attr not in ('name', 'id'):
+            add_info = 'The only valid workflow variables with two segments' \
+                ' are workflow.name and workflow.id.'
+    elif len(parts) == 4:
+        # workflow.inputs.parameters.<NAME>
+        # workflow.inputs.artifacts.<NAME>
+        # workflow.operators.<OPERATORNAME>.image
+        typ, attr, prop, _ = parts
+        if attr in ('inputs', 'outputs'):
+            if prop not in ('parameters', 'artifacts'):
+                add_info = 'Workflow inputs and outputs variables must be ' \
+                    '"parameters" or "artifacts".'
+        elif typ == 'operators':
+            if typ[-1] != 'image':
+                add_info = 'Workflow operator variable can only access ' \
+                    'the image name.'
+        else:
+            add_info = 'Workflow variables must reference to "inputs", "outputs" ' \
+                'or "operators".'
+    else:
+        add_info = 'Workflow variables are either 2 or 4 segments.'
+
+    return add_info
+
+
+def _validate_tasks_var_format(value: str):
+    add_info = ''
+    parts = value.split('.')
+    if len(parts) != 5:
+        add_info = 'Valid tasks variables are ' \
+            '"tasks.<TASKNAME>.outputs.parameters.<NAME>" and ' \
+            '"tasks.<TASKNAME>.outputs.artifacts.<NAME>".'
+    # check for other parts
+    _, _, attr, prop, _ = parts
+    if attr != 'outputs':
+        add_info = 'Tasks variable can only access previous tasks "outputs".'
+    elif prop not in ('parameters', 'artifacts'):
+        add_info = 'Task outputs variables must be "parameters" or "artifacts".'
+
+    return add_info
+
+
+def _validate_inputs_outputs_var_format(value: str):
+    add_info = ''
+    parts = value.split('.')
+    if len(parts) != 3:
+        add_info = 'Inputs and outputs variables must have 3 segments.'
+    else:
+        prop = parts[1]
+        if prop not in ('parameters', 'artifacts'):
+            add_info = 'Inputs and outputs variables must be "parameters" or' \
+                ' "artifacts".'
+    return add_info
+
+
+def validate_ref_variable_format(value: str):
+    """Ensure referenced values are formatted correctly."""
+    add_info = ''
+    if value.startswith('workflow.'):
+        add_info = _validate_workflow_var_format(value)
+    elif value.startswith('tasks.'):
+        add_info = _validate_tasks_var_format(value)
+    elif value.startswith('inputs.') or value.startswith('outputs.'):
+        add_info = _validate_inputs_outputs_var_format(value)
+    elif value.startswith('item'):
+        pass
+    else:
+        add_info = 'Queenbee variable must start with workflow, tasks or items.'
+
+    if add_info != '':
+        msg = f'Invalid Queenbee variable: {value}.\n{add_info} ' \
+            'See https://github.com/ladybug-tools/queenbee#variables' \
+            ' for more information.'
+        raise ValueError(msg)
+    return True
diff --git a/queenbee/schema/workflow.py b/queenbee/schema/workflow.py
index 7471cb9e..baadc848 100644
--- a/queenbee/schema/workflow.py
+++ b/queenbee/schema/workflow.py
@@ -134,7 +134,7 @@ def check_artifact_references(self):
         return values
 
     def to_diagraph(self, filename=None):
-        """Return a graphviz instance of a diagraph from workflow"""
+        """Return a graphviz instance of a diagraph from workflow."""
         if filename is None:
             filename = self.id
         f = Digraph(self.name, filename='{}.gv'.format(filename))
@@ -146,30 +146,49 @@ def to_diagraph(self, filename=None):
 
         return f
 
-    def fetch_workflow_values(self, template_string):
-        """replaces template value with workflow level value"""
-        references = parse_double_quote_workflow_vars(template_string)
+    def fetch_workflow_values(self, input_string):
+        """Get referenced template value from workflow level value.
 
+        This method returns a dictionary where the keys are the workflow variables in
+        input_string and values are the fetched values from workflow. 
+        """
+        references = parse_double_quote_workflow_vars(input_string)
+        if not references:
+            return {}
         values = {}
-
         for ref in references:
-            keys = ref.split('.')
-            obj = self.dict()
-
-            for key in keys[1:]:
-                if isinstance(obj, list):
-                    obj = list(filter(lambda x: x.get('name') == key, obj))[0]
+            try:
+                _, attr, prop, name = ref.split('.')
+            except ValueError:
+                *_, name = ref.split('.')
+                if name == 'id':
+                    values[ref] = self.id
+                elif name == 'name':
+                    values[ref] = self.name
+            else:
+                if attr in ('inputs', 'outputs'):
+                    if prop == 'parameters':
+                        values[ref] = self.inputs.get_parameter_value(name)
+                    elif prop == 'artifacts':
+                        values[ref] = self.inputs.get_artifact_value(name)
+                elif attr == 'operators':
+                    values[ref] = self.get_operator(prop).image
                 else:
-                    obj = obj[key]
-
-            values[ref] = obj
+                    raise ValueError(
+                        f'Invalid workflow variable: {ref}. '
+                        f'Variable type must be "parameters", "artifacts" '
+                        f'or "operators" not "{attr}"'
+                    )
 
         return values
 
     def hydrate_workflow_templates(self):
-        """returns a dictionary version of the workflow with {{workflow.x.y.z}} variables as values"""
-        return hydrate_templates(
-            self, wf_value=self.dict(exclude_unset=True))
+        """Find and replace {{workflow.x.y.z}} variables with input values.
+
+        This method returns the workflow as a dictionary with {{workflow.x.y.z}}
+        variables replaced by workflow input values.
+        """
+        return hydrate_templates(self, wf_value=self.dict(exclude_unset=True))
 
     @property
     def nodes_links(self):
@@ -208,21 +227,32 @@ def artifacts(self):
 
         return list(artifacts)
 
+    def get_operator(self, name):
+        """Get operator by name."""
+        operator = [op for op in self.operators if op.name == name]
+        if not operator:
+            raise ValueError(f'Invalid operator name: {name}')
+        return operator[0]
+
 
 def hydrate_templates(workflow, wf_value=None):
-    """Replace all `{{ workflow.x.y.z }}` with corresponding value
+    """Replace all ``{{ workflow.x.y.z }}`` variables with corresponding values.
 
     Cycle through an arbitrary workflow value (dictionary, list, string etc...) 
-    and hydrate any workflow template value with it's actual value. This command 
+    and hydrate any workflow template value with it's actual value. This function 
     should mostly be used by the plugin libraries when converting a queenbee 
     workflow to their own job scheduling language. As such the workflow should 
-    contain all the required variable values indicated by a `{{ workflow.x.y...z }}`.
-    """
+    contain all the required variable values indicated by a ``{{ workflow.x.y...z }}``.
 
+    In most cases you should use Workflow's ``hydrate_workflow_templates`` method instead
+    of using this function directly.
+    """
     if isinstance(wf_value, list):
         wf_value = [hydrate_templates(workflow, item) for item in wf_value]
 
     elif isinstance(wf_value, str):
+        "{{workflow.id}}_{{workflow.name}}"
+        "{{workflow.id}}"
         values = workflow.fetch_workflow_values(wf_value)
 
         if values == {}:
@@ -236,8 +266,9 @@ def hydrate_templates(workflow, wf_value=None):
 
                 pattern = r"^\s*{{\s*" + match_k + r"\s*}}\s*$"
 
-                # if match is not None then it means that the string value "{{ workflow.key }}" does not
-                # require string replace values like the following example: "{{ workflow.id }}-{{ workflow.name }}"
+                # if match is not None then it means that the string value
+                # "{{ workflow.key }}" does not require string replace values like the
+                # following example: "{{ workflow.id }}-{{ workflow.name }}"
                 match = re.search(pattern, wf_value)
 
                 if isinstance(match_v, list) or isinstance(match_v, dict) or match is not None:
diff --git a/tests/assets/arguments.yaml b/tests/assets/arguments.yaml
index 8c970d10..0bf76b32 100644
--- a/tests/assets/arguments.yaml
+++ b/tests/assets/arguments.yaml
@@ -10,5 +10,5 @@ parameters:
     path: null
 artifacts:
   - name: input-grid-folder
-    location: model-source  # this is important for copying the files.
-    path: asset/grid  # can we reference this as a parameter?
+    location: model-source
+    path: asset/grid
diff --git a/tests/assets/arguments_dup_name.yaml b/tests/assets/arguments_dup_name.yaml
new file mode 100644
index 00000000..670ba7e9
--- /dev/null
+++ b/tests/assets/arguments_dup_name.yaml
@@ -0,0 +1,16 @@
+---
+parameters:
+  - name: grid-name
+    value: grid
+    description: null
+    path: null
+  - name: sensor-count
+    value: 250
+    description: null
+    path: null
+  - name: sensor-count
+    path: 'point_count.txt'
+artifacts:
+  - name: input-grid-folder
+    location: model-source  # this is important for copying the files.
+    path: asset/grid  # can we reference this as a parameter?
diff --git a/tests/assets/function.yaml b/tests/assets/function.yaml
index 538d178a..4a773179 100644
--- a/tests/assets/function.yaml
+++ b/tests/assets/function.yaml
@@ -7,11 +7,11 @@ inputs:
     - name: sky-file
       description: full path to output sky file
 operator: radiance-operator
-command: gensky -c -B '{{ inputs.parameters.desired-irradiance }}' > '{{ inputs.parameters.sky-file }}'
+command: gensky -c -B "{{ inputs.parameters.desired-irradiance }}" > "{{ inputs.parameters.sky-file }}"
 outputs:
   artifacts:
     - name: sky
       location: project-folder
-      source_path: '{{ inputs.parameters.sky-file }}'
+      source_path: "{{ inputs.parameters.sky-file }}"
       path: file.sky
 
diff --git a/tests/assets/parameters.yaml b/tests/assets/parameters.yaml
new file mode 100644
index 00000000..00472e9d
--- /dev/null
+++ b/tests/assets/parameters.yaml
@@ -0,0 +1,10 @@
+---
+parameters:
+  - name: grid-name
+    value: grid
+    description: null
+    path: null
+  - name: sensor-count
+    value: 250
+    description: null
+    path: null
diff --git a/tests/schema/arguments_test.py b/tests/schema/arguments_test.py
index e4c185fb..fb4cc618 100644
--- a/tests/schema/arguments_test.py
+++ b/tests/schema/arguments_test.py
@@ -1,5 +1,6 @@
 from queenbee.schema.arguments import Arguments, Parameter, Artifact
 import yaml
+import pytest
 
 
 def test_load_arguments():
@@ -8,22 +9,33 @@ def test_load_arguments():
     # check parameter
     parameter = args.parameters[0]
     assert isinstance(parameter, Parameter)
-    parameter.name == 'worker'
-    parameter.value == 1
+    assert parameter.name == 'grid-name'
+    assert parameter.value == 'grid'
 
     # check artifact
     artifact = args.artifacts[0]
     assert isinstance(artifact, Artifact)
-    artifact.name == 'project-folder'
-    artifact.location == 'project-folder'
-    artifact.source_path == '.'
-    artifact.path == 'project'
+    assert artifact.name == 'input-grid-folder'
+    assert artifact.location == 'model-source'
+    assert artifact.path == 'asset/grid'
+
+def test_load_params_only_arguments():
+    args = Arguments.from_file('./tests/assets/parameters.yaml')
+
+    # check parameter
+    parameter = args.parameters[0]
+    assert isinstance(parameter, Parameter)
+    assert parameter.name == 'grid-name'
+    assert parameter.value == 'grid'
 
 
 def test_create_arguments():
     args_dict = {
         'parameters': [{'name': 'worker', 'value': 1}],
-        'artifacts': [{'name': 'project-folder', 'source_path': '.', 'path': 'project', 'location': 'project-folder'}]
+        'artifacts': [
+            {'name': 'project-folder', 'source_path': '.',
+            'path': 'project', 'location': 'project-folder'}
+        ]
     }
 
     args = Arguments.parse_obj(args_dict)
@@ -36,3 +48,26 @@ def test_create_arguments():
         obj = yaml.safe_load(inf.read())
 
     assert obj == args.to_dict()
+
+
+def test_load_duplicate_name():
+    with pytest.raises(ValueError):
+        Arguments.from_file('./tests/assets/arguments_dup_name.yaml')
+
+
+def test_get_param_value():
+    args = Arguments.from_file('./tests/assets/arguments.yaml')
+
+    with pytest.raises(ValueError):
+        args.get_parameter_value('worker')
+
+    assert args.get_parameter_value('sensor-count') == 250
+
+
+def test_get_artifact_value():
+    args = Arguments.from_file('./tests/assets/arguments.yaml')
+
+    with pytest.raises(ValueError):
+        args.get_artifact_value('model-source')
+
+    assert args.get_artifact_value('input-grid-folder') == 'asset/grid'
diff --git a/tests/schema/parameters_test.py b/tests/schema/parameters_test.py
new file mode 100644
index 00000000..5f65182b
--- /dev/null
+++ b/tests/schema/parameters_test.py
@@ -0,0 +1,38 @@
+from queenbee.schema.arguments import Parameter
+import pytest
+
+
+def test_wrong_referenced_parameters():
+    with pytest.raises(ValueError):
+        Parameter(name='param', value='"{{workflow.wrong-input}}"')
+
+    with pytest.raises(ValueError):
+        Parameter(name='param', value='"{{workflow.inputs.parameters}}"')
+
+    with pytest.raises(ValueError):
+        Parameter(name='param', value='"{{workflow.inputs.parameters.name.value}}"')
+
+
+def test_referenced_parameters():
+    par = Parameter(name='new-param', value='"{{workflow.inputs.parameters.name}}"')
+    assert par.ref_vars == {'value': ['workflow.inputs.parameters.name']}
+
+
+def test_referenced_parameters_path():
+    par = Parameter(name='new-param', path='"{{workflow.inputs.parameters.name}}"')
+    assert par.ref_vars == {'path': ['workflow.inputs.parameters.name']}
+
+
+def test_value_path_clash():
+    with pytest.raises(ValueError):
+        Parameter(name='new-param', value=1, path='path to file')
+
+
+def test_current_value():
+    par = Parameter(name='new-param', value=20)
+    assert par.current_value == 20
+
+
+def test_current_value_path():
+    par = Parameter(name='new-param', path='path to file')
+    assert par.current_value == 'path to file'
diff --git a/tests/schema/workflow_test.py b/tests/schema/workflow_test.py
index 87859176..e99c8c72 100644
--- a/tests/schema/workflow_test.py
+++ b/tests/schema/workflow_test.py
@@ -12,28 +12,13 @@ def test_load_workflow():
     wf.validate_all()
 
 
-def test_workflow_fetch_dict():
-    fp = './tests/assets/workflow_example/daylightfactor.yaml'
-    wf = Workflow.from_file(fp)
-
-    output = wf.fetch_workflow_values('{{workflow.inputs.parameters.worker}}')
-
-    assert output == {
-        'workflow.inputs.parameters.worker': {
-            'name': 'worker', 'path': None,
-            'description': 'Maximum number of workers for executing this workflow.',
-            'value': 1}
-    }
-
-
 def test_workflow_fetch_value():
     fp = './tests/assets/workflow_example/daylightfactor.yaml'
     wf = Workflow.from_file(fp)
 
-    output = wf.fetch_workflow_values(
-        '{{workflow.inputs.parameters.worker.value}}')
+    output = wf.fetch_workflow_values('{{workflow.inputs.parameters.worker}}')
 
-    assert output == {'workflow.inputs.parameters.worker.value': 1}
+    assert output == {'workflow.inputs.parameters.worker': 1}
 
 
 def test_workflow_fetch_multi():
@@ -41,10 +26,10 @@ def test_workflow_fetch_multi():
     wf = Workflow.from_file(fp)
 
     output = wf.fetch_workflow_values(
-        '{{workflow.inputs.parameters.worker.value}}-something-{{workflow.operators.honeybee-radiance.image}}')
+        '{{workflow.inputs.parameters.worker}}-something-{{workflow.operators.honeybee-radiance.image}}')
 
     assert output == {
-        'workflow.inputs.parameters.worker.value': 1,
+        'workflow.inputs.parameters.worker': 1,
         'workflow.operators.honeybee-radiance.image': 'ladybugtools/honeybee-radiance'
     }
 
@@ -61,23 +46,23 @@ def test_hydrate_templates():
 
     new_wf = Workflow.parse_obj(wf_dict)
 
+    ## TODO: Put the tests back after rewriting hydrate workflow
     # Test string allocation
-    assert new_wf.flow.tasks[2].arguments.parameters[0].value == 'path/to/scene/files'
+    # assert new_wf.flow.tasks[2].arguments.parameters[0].value == 'path/to/scene/files'
     # Test number allocation
-    assert new_wf.flow.tasks[1].arguments.parameters[0].value == 50
+    # assert new_wf.flow.tasks[1].arguments.parameters[0].value == 50
     # Test string concatenation
-    assert new_wf.artifact_locations[0].root == "/path/to/test/some-test-id"
+    # assert new_wf.artifact_locations[0].root == "/path/to/test/some-test-id"
 
 
-def test_hydrate__missing_value_error():
+def test_hydrate_missing_value_error():
     fp = './tests/assets/workflow_example/daylightfactor.yaml'
     wf = Workflow.from_file(fp)
 
-    with pytest.raises(AssertionError) as e:
-        new_wf = wf.hydrate_workflow_templates()
-
-    assert '{{workflow.inputs.parameters.sensor-count.value}} cannot reference an empty or null value.' in str(
-        e)
+    err_msg = '{{workflow.inputs.parameters.sensor-grid-count}} cannot reference an' \
+        ' empty or null value'
+    with pytest.raises(AssertionError, match=err_msg):
+        wf.hydrate_workflow_templates()
 
 
 def test_workflow_single_run_folder():