diff --git a/.appveyor.yml b/.appveyor.yml
index c915811e415..65feb8c7ef9 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -32,8 +32,7 @@ install:
   - pip install --user -U pip
   - pip --version
   # certifi upgrade is needed by pytest-profiling (it does not set the dependencies right)
-  # numpy 1.16 gets pulled by leabra below and pnl downgrades it to <1.16 later
-  - pip install --user -U certifi "numpy<1.16"
+  - pip install --user -U certifi
   - pip install --user git+https://github.com/benureau/leabra.git@master
 
   # pytorch does not distribute windows packages over pypi.
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index f0a9b16e94a..76e9ec15d5f 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -14,9 +14,10 @@
     <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ignoredPackages">
         <value>
-          <list size="2">
+          <list size="3">
             <item index="0" class="java.lang.String" itemvalue="typecheck-decorator" />
             <item index="1" class="java.lang.String" itemvalue="toposort" />
+            <item index="2" class="java.lang.String" itemvalue="dill" />
           </list>
         </value>
       </option>
diff --git a/.idea/runConfigurations/Scratch_Pad.xml b/.idea/runConfigurations/Scratch_Pad.xml
index ce6c0e1c996..ccb8a6ec5d9 100644
--- a/.idea/runConfigurations/Scratch_Pad.xml
+++ b/.idea/runConfigurations/Scratch_Pad.xml
@@ -1,12 +1,12 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" factoryName="Python" name="Scratch Pad" type="PythonConfigurationType">
-    <module name="" />
+  <configuration default="false" name="Scratch Pad" type="PythonConfigurationType" factoryName="Python">
+    <module name="PsyNeuLink (Dropbox)" />
     <option name="INTERPRETER_OPTIONS" value="" />
     <option name="PARENT_ENVS" value="true" />
     <envs>
       <env name="PYTHONUNBUFFERED" value="1" />
     </envs>
-    <option name="SDK_HOME" value="" />
+    <option name="SDK_HOME" value="$USER_HOME$/anaconda/envs/python37/bin/python" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/Scripts" />
     <option name="IS_MODULE_SDK" value="false" />
     <option name="ADD_CONTENT_ROOTS" value="true" />
diff --git a/.travis.yml b/.travis.yml
index 138410501b4..06c85f80a5c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -77,17 +77,9 @@ before_install:
     fi
   - python --version
   - pip --version
-  - |
-    if [ "x$COVERALLS_REPO_TOKEN" != "x" ]; then
-          export PYTEST_COV="--cov=psyneulink"
-    else
-          export PYTEST_COV=""
-    fi
 
 install:
-  # Downgrade numpy early if needed.
-  - pip install -U 'numpy<1.16'
-  - if [ "x$COVERALLS_REPO_TOKEN" != "x" ]; then pip install coveralls; fi
+  - pip install coveralls
   - pip install git+https://github.com/benureau/leabra.git@master
   # Travis bundles pytest 4.3.1 in Linux Xenial, new pytest-xdist
   # requires pytest>=4.4.0, and the dependencies are broken
@@ -96,7 +88,10 @@ install:
 
 
 script:
-  - pytest -n auto --strict-markers -p no:logging $PYTEST_COV
+  - pytest -n auto --strict-markers -p no:logging --cov=psyneulink
 
 after_script:
-  - if [ "x$COVERALLS_REPO_TOKEN" != "x" ]; then coveralls; fi
+  - COVERALLS_PARALLEL=true coveralls
+
+notifications:
+  webhooks: https://coveralls.io/webhook
diff --git a/docs/source/BasicsAndSampler.rst b/docs/source/BasicsAndSampler.rst
index 2e99ef419b8..9f4045d8c1d 100644
--- a/docs/source/BasicsAndSampler.rst
+++ b/docs/source/BasicsAndSampler.rst
@@ -124,7 +124,7 @@ As the name of the ``show_graph()`` method suggests, Compositions are represente
 standard dependency dictionary format, so that they can also be submitted to other graph theoretic packages for
 display and/or analysis (such as `NetworkX <https://networkx.github.io>`_ and `igraph <http://igraph.org/redirect
 .html>`_).  They can also be exported as a JSON file, in a format that is currently being developed for the exchange
-of computational models in neuroscience and psychology (see `BIDS <XXX>`)
+of computational models in neuroscience and psychology (see `json`)
 
 .. XXX USE show_graph(show_node_structure=True) HERE OR ABOVE::
 
diff --git a/docs/source/_static/stroop_conflict_monitoring.json b/docs/source/_static/stroop_conflict_monitoring.json
new file mode 100644
index 00000000000..154f472f710
--- /dev/null
+++ b/docs/source/_static/stroop_conflict_monitoring.json
@@ -0,0 +1,5640 @@
+{
+    "graphs": [
+        {
+            "controller": "CONTROL",
+            "edges": {
+                "ControlProjection for TASK[gain]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.5
+                                    ]
+                                },
+                                "bounds": null,
+                                "intercept": {
+                                    "source": "ControlProjection for TASK[gain].input_ports.intercept",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "slope": {
+                                    "source": "ControlProjection for TASK[gain].input_ports.slope",
+                                    "type": "float",
+                                    "value": 1.0
+                                }
+                            },
+                            "name": "Linear Function-79",
+                            "type": {
+                                "generic": "Linear"
+                            }
+                        }
+                    ],
+                    "name": "ControlProjection for TASK[gain]",
+                    "parameters": {
+                        "PNL": {
+                            "control_signal": null,
+                            "control_signal_params": null,
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.5
+                            ]
+                        },
+                        "exponent": null,
+                        "weight": null
+                    },
+                    "receiver": "TASK",
+                    "receiver_port": "gain",
+                    "sender": "CONTROL",
+                    "sender_port": "TASK[gain] ControlSignal",
+                    "type": {
+                        "PNL": "ControlProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from Conflict Monitor[OUTCOME] to CONTROL[OUTCOME]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from Conflict Monitor[OUTCOME] to CONTROL[OUTCOME].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            1.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-2",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from Conflict Monitor[OUTCOME] to CONTROL[OUTCOME]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.0
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                1.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "CONTROL",
+                    "receiver_port": "OUTCOME",
+                    "sender": "Conflict Monitor",
+                    "sender_port": "OUTCOME",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from OUTPUT[OutputState-0] to Conflict Monitor[InputState-0]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.5,
+                                        0.5
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from OUTPUT[OutputState-0] to Conflict Monitor[InputState-0].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            1.0,
+                                            0.0
+                                        ],
+                                        [
+                                            0.0,
+                                            1.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-1",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from OUTPUT[OutputState-0] to Conflict Monitor[InputState-0]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.5,
+                                0.5
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                1.0,
+                                0.0
+                            ],
+                            [
+                                0.0,
+                                1.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "Conflict Monitor",
+                    "receiver_port": "Value of OUTPUT [OutputState-0]",
+                    "sender": "OUTPUT",
+                    "sender_port": "OutputState-0",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from OUTPUT[OutputState-0] to DECISION[ARRAY]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.5,
+                                        0.5
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from OUTPUT[OutputState-0] to DECISION[ARRAY].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            1.0,
+                                            0.0
+                                        ],
+                                        [
+                                            0.0,
+                                            1.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-10",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from OUTPUT[OutputState-0] to DECISION[ARRAY]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.5,
+                                0.5
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                1.0,
+                                0.0
+                            ],
+                            [
+                                0.0,
+                                1.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "DECISION",
+                    "receiver_port": "ARRAY",
+                    "sender": "OUTPUT",
+                    "sender_port": "OutputState-0",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from TASK[RESULT] to color_hidden[InputState-0]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.6283161882953663,
+                                        0.6283161882953663
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from TASK[RESULT] to color_hidden[InputState-0].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            4.0,
+                                            4.0
+                                        ],
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-8",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from TASK[RESULT] to color_hidden[InputState-0]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.6283161882953663,
+                                0.6283161882953663
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                4.0,
+                                4.0
+                            ],
+                            [
+                                0.0,
+                                0.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "color_hidden",
+                    "receiver_port": "InputState-0",
+                    "sender": "TASK",
+                    "sender_port": "RESULT",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from TASK[RESULT] to word_hidden[InputState-0]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.6283161882953663,
+                                        0.6283161882953663
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from TASK[RESULT] to word_hidden[InputState-0].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ],
+                                        [
+                                            4.0,
+                                            4.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-9",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from TASK[RESULT] to word_hidden[InputState-0]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.6283161882953663,
+                                0.6283161882953663
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                0.0,
+                                0.0
+                            ],
+                            [
+                                4.0,
+                                4.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "word_hidden",
+                    "receiver_port": "InputState-0",
+                    "sender": "TASK",
+                    "sender_port": "RESULT",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from color_hidden[OutputState-0] to OUTPUT[InputState-0]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.017986209962091562,
+                                        0.017986209962091562
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from color_hidden[OutputState-0] to OUTPUT[InputState-0].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            2.0,
+                                            -2.0
+                                        ],
+                                        [
+                                            -2.0,
+                                            2.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-4",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from color_hidden[OutputState-0] to OUTPUT[InputState-0]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.017986209962091562,
+                                0.017986209962091562
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                2.0,
+                                -2.0
+                            ],
+                            [
+                                -2.0,
+                                2.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "OUTPUT",
+                    "receiver_port": "InputState-0",
+                    "sender": "color_hidden",
+                    "sender_port": "OutputState-0",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from color_input[OutputState-0] to color_hidden[InputState-0]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.0,
+                                        0.0
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from color_input[OutputState-0] to color_hidden[InputState-0].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            2.0,
+                                            -2.0
+                                        ],
+                                        [
+                                            -2.0,
+                                            2.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-3",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from color_input[OutputState-0] to color_hidden[InputState-0]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.0,
+                                0.0
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                2.0,
+                                -2.0
+                            ],
+                            [
+                                -2.0,
+                                2.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "color_hidden",
+                    "receiver_port": "InputState-0",
+                    "sender": "color_input",
+                    "sender_port": "OutputState-0",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from task_input[OutputState-0] to TASK[InputState-0]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.0,
+                                        0.0
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from task_input[OutputState-0] to TASK[InputState-0].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            1.0,
+                                            0.0
+                                        ],
+                                        [
+                                            0.0,
+                                            1.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-7",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from task_input[OutputState-0] to TASK[InputState-0]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.0,
+                                0.0
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                1.0,
+                                0.0
+                            ],
+                            [
+                                0.0,
+                                1.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "TASK",
+                    "receiver_port": "InputState-0",
+                    "sender": "task_input",
+                    "sender_port": "OutputState-0",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from word_hidden[OutputState-0] to OUTPUT[InputState-0]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.017986209962091562,
+                                        0.017986209962091562
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from word_hidden[OutputState-0] to OUTPUT[InputState-0].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            3.0,
+                                            -3.0
+                                        ],
+                                        [
+                                            -3.0,
+                                            3.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-6",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from word_hidden[OutputState-0] to OUTPUT[InputState-0]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.017986209962091562,
+                                0.017986209962091562
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                3.0,
+                                -3.0
+                            ],
+                            [
+                                -3.0,
+                                3.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "OUTPUT",
+                    "receiver_port": "InputState-0",
+                    "sender": "word_hidden",
+                    "sender_port": "OutputState-0",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "MappingProjection from word_input[OutputState-0] to word_hidden[InputState-0]": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.0,
+                                        0.0
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "MappingProjection from word_input[OutputState-0] to word_hidden[InputState-0].input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            3.0,
+                                            -3.0
+                                        ],
+                                        [
+                                            -3.0,
+                                            3.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-5",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "MappingProjection from word_input[OutputState-0] to word_hidden[InputState-0]",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.0,
+                                0.0
+                            ]
+                        },
+                        "exponent": null,
+                        "matrix": [
+                            [
+                                3.0,
+                                -3.0
+                            ],
+                            [
+                                -3.0,
+                                3.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "word_hidden",
+                    "receiver_port": "InputState-0",
+                    "sender": "word_input",
+                    "sender_port": "OutputState-0",
+                    "type": {
+                        "PNL": "MappingProjection",
+                        "generic": null
+                    }
+                },
+                "TASK recurrent projection": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        0.6283161882953663,
+                                        0.6283161882953663
+                                    ]
+                                },
+                                "bounds": null,
+                                "matrix": {
+                                    "source": "TASK recurrent projection.input_ports.matrix",
+                                    "type": "numpy.array",
+                                    "value": [
+                                        [
+                                            0.0,
+                                            1.0
+                                        ],
+                                        [
+                                            1.0,
+                                            0.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "name": "LinearMatrix Function-0",
+                            "type": {
+                                "PNL": "LinearMatrix",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "TASK recurrent projection",
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "variable": [
+                                0.6283161882953663,
+                                0.6283161882953663
+                            ]
+                        },
+                        "auto": 1,
+                        "exponent": null,
+                        "hetero": 0,
+                        "matrix": [
+                            [
+                                0.0,
+                                1.0
+                            ],
+                            [
+                                1.0,
+                                0.0
+                            ]
+                        ],
+                        "weight": null
+                    },
+                    "receiver": "TASK",
+                    "receiver_port": "InputState-0",
+                    "sender": "TASK",
+                    "sender_port": "RESULT",
+                    "type": {
+                        "PNL": "AutoAssociativeProjection",
+                        "generic": null
+                    }
+                }
+            },
+            "name": "Stroop_model",
+            "nodes": {
+                "CONTROL": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            1.0
+                                        ]
+                                    ]
+                                },
+                                "num_control_signals": 1
+                            },
+                            "name": "Default Control Function-1",
+                            "type": {
+                                "PNL": "DefaultAllocationFunction",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "LinearCombination Function-27",
+                                    "type": {
+                                        "PNL": "LinearCombination",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "OUTCOME",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "CONTROL",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "LinearCombination": "psyneulink.core.components.functions.combinationfunctions.LinearCombination",
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false
+                                        },
+                                        "SimpleIntegrator": "psyneulink.core.components.functions.statefulfunctions.integratorfunctions.SimpleIntegrator",
+                                        "adjustment_cost": null,
+                                        "adjustment_cost_fct": "psyneulink.core.components.functions.transferfunctions.Linear",
+                                        "adjustment_cost_fct_add_param": 0.0,
+                                        "adjustment_cost_fct_mult_param": 1.0,
+                                        "bounds": null,
+                                        "combine_costs_fct": {
+                                            "args": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "variable": [
+                                                        0
+                                                    ]
+                                                },
+                                                "exponents": null,
+                                                "offset": 0.0,
+                                                "operation": "sum",
+                                                "scale": 1.0,
+                                                "weights": null
+                                            },
+                                            "name": "Reduce Function-1",
+                                            "type": {
+                                                "PNL": "Reduce",
+                                                "generic": null
+                                            }
+                                        },
+                                        "combine_costs_fct_add_param": 0.0,
+                                        "combine_costs_fct_mult_param": 1.0,
+                                        "combined_costs": null,
+                                        "duration_cost": null,
+                                        "duration_cost_fct": "psyneulink.core.components.functions.statefulfunctions.integratorfunctions.SimpleIntegrator",
+                                        "duration_cost_fct_add_param": null,
+                                        "duration_cost_fct_mult_param": null,
+                                        "enabled_cost_functions": 2,
+                                        "intensity": [
+                                            0
+                                        ],
+                                        "intensity_cost": null,
+                                        "intensity_cost_fct": "psyneulink.core.components.functions.transferfunctions.Exponential",
+                                        "intensity_cost_fct_add_param": 0.0,
+                                        "intensity_cost_fct_mult_param": 1.0,
+                                        "transfer_fct": {
+                                            "args": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "variable": [
+                                                        0
+                                                    ]
+                                                },
+                                                "bounds": null,
+                                                "intercept": 0.0,
+                                                "slope": 1.0
+                                            },
+                                            "name": "Linear Function-0",
+                                            "type": {
+                                                "generic": "Linear"
+                                            }
+                                        },
+                                        "transfer_fct_add_param": null,
+                                        "transfer_fct_mult_param": null,
+                                        "variable": [
+                                            0.5
+                                        ]
+                                    },
+                                    "name": "TransferWithCosts Function-0",
+                                    "type": {
+                                        "PNL": "TransferWithCosts",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "TASK[gain] ControlSignal",
+                            "parameters": {
+                                "PNL": {
+                                    "allocation": [
+                                        0.5
+                                    ],
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "intensity": [
+                                        0.5
+                                    ],
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.5
+                                    ]
+                                },
+                                "adjustment_cost": 0,
+                                "adjustment_cost_function": "psyneulink.core.components.functions.transferfunctions.Linear",
+                                "allocation_samples": null,
+                                "combine_costs_function": {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "Reduce Function-1",
+                                    "type": {
+                                        "PNL": "Reduce",
+                                        "generic": null
+                                    }
+                                },
+                                "cost": null,
+                                "cost_options": 2,
+                                "duration_cost": 0,
+                                "duration_cost_function": "psyneulink.core.components.functions.statefulfunctions.integratorfunctions.SimpleIntegrator",
+                                "intensity_cost": null,
+                                "intensity_cost_function": "psyneulink.core.components.functions.transferfunctions.Exponential",
+                                "modulation": "multiplicative_param"
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ControlSignal",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "control_allocation": [
+                                [
+                                    1.0
+                                ]
+                            ],
+                            "control_signal_costs": null,
+                            "control_spec": [
+                                {
+                                    "MECHANISM": {
+                                        "functions": [
+                                            {
+                                                "args": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "variable": [
+                                                            [
+                                                                0.0,
+                                                                0.0
+                                                            ]
+                                                        ]
+                                                    },
+                                                    "bias": {
+                                                        "source": "TASK.input_ports.bias",
+                                                        "type": "float",
+                                                        "value": 0.0
+                                                    },
+                                                    "bounds": null,
+                                                    "gain": {
+                                                        "source": "TASK.input_ports.gain",
+                                                        "type": "float",
+                                                        "value": 1.0
+                                                    },
+                                                    "offset": {
+                                                        "source": "TASK.input_ports.offset",
+                                                        "type": "float",
+                                                        "value": 0.0
+                                                    },
+                                                    "scale": {
+                                                        "source": "TASK.input_ports.scale",
+                                                        "type": "float",
+                                                        "value": 1.0
+                                                    },
+                                                    "x_0": {
+                                                        "source": "TASK.input_ports.x_0",
+                                                        "type": "float",
+                                                        "value": 0.0
+                                                    }
+                                                },
+                                                "name": "Logistic Function-6",
+                                                "type": {
+                                                    "generic": "Logistic"
+                                                }
+                                            }
+                                        ],
+                                        "input_ports": [
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    [
+                                                                        0.0,
+                                                                        0.0
+                                                                    ],
+                                                                    [
+                                                                        0.0,
+                                                                        0.0
+                                                                    ]
+                                                                ]
+                                                            },
+                                                            "exponents": null,
+                                                            "offset": 0.0,
+                                                            "operation": "sum",
+                                                            "scale": 1.0,
+                                                            "weights": null
+                                                        },
+                                                        "name": "LinearCombination Function-22",
+                                                        "type": {
+                                                            "PNL": "LinearCombination",
+                                                            "generic": null
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "InputState-0",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "internal_only": false,
+                                                        "require_projection_in_composition": true,
+                                                        "shadow_inputs": null,
+                                                        "variable": [
+                                                            [
+                                                                0.0,
+                                                                0.0
+                                                            ],
+                                                            [
+                                                                0.0,
+                                                                0.0
+                                                            ]
+                                                        ]
+                                                    },
+                                                    "combine": null,
+                                                    "exponent": null,
+                                                    "weight": null
+                                                },
+                                                "shape": "(2, 2)",
+                                                "type": {
+                                                    "PNL": "InputState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    0.01
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-44",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "convergence_criterion",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            0.01
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    0.0
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-45",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "bias",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            0.0
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    1.0
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-46",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "gain",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            1.0
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    0.0
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-47",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "offset",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            0.0
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    1.0
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-48",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "scale",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            1.0
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    0.0
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-49",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "x_0",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            0.0
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    0.5
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-50",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "integration_rate",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            0.5
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    0.5
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-51",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "leak",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            0.5
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    0.0
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-52",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "noise",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            0.0
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            },
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    0.1
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-53",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "time_step_size",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            0.1
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(1,)",
+                                                "type": {
+                                                    "PNL": "ParameterState",
+                                                    "generic": null
+                                                }
+                                            }
+                                        ],
+                                        "name": "TASK",
+                                        "output_ports": [
+                                            {
+                                                "dtype": "float64",
+                                                "functions": [
+                                                    {
+                                                        "args": {
+                                                            "PNL": {
+                                                                "execution_count": 0,
+                                                                "has_initializers": false,
+                                                                "variable": [
+                                                                    0.6283161882953663,
+                                                                    0.6283161882953663
+                                                                ]
+                                                            },
+                                                            "bounds": null,
+                                                            "intercept": 0.0,
+                                                            "slope": 1.0
+                                                        },
+                                                        "name": "Linear Function-56",
+                                                        "type": {
+                                                            "generic": "Linear"
+                                                        }
+                                                    }
+                                                ],
+                                                "name": "RESULT",
+                                                "parameters": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "require_projection_in_composition": true,
+                                                        "variable": [
+                                                            0.6283161882953663,
+                                                            0.6283161882953663
+                                                        ]
+                                                    }
+                                                },
+                                                "shape": "(2,)",
+                                                "type": {
+                                                    "PNL": "OutputState",
+                                                    "generic": null
+                                                }
+                                            }
+                                        ],
+                                        "parameters": {
+                                            "PNL": {
+                                                "execution_count": 0,
+                                                "has_initializers": false,
+                                                "input_state_variables": null,
+                                                "input_states_spec": null,
+                                                "output_states_spec": [
+                                                    "RESULT"
+                                                ],
+                                                "previous_value": null,
+                                                "variable": [
+                                                    [
+                                                        0.0,
+                                                        0.0
+                                                    ]
+                                                ]
+                                            },
+                                            "auto": 0.0,
+                                            "clip": null,
+                                            "combination_function": "psyneulink.core.components.functions.combinationfunctions.LinearCombination",
+                                            "competition": 1.0,
+                                            "convergence_criterion": 0.01,
+                                            "convergence_function": {
+                                                "args": {
+                                                    "PNL": {
+                                                        "execution_count": 0,
+                                                        "has_initializers": false,
+                                                        "variable": [
+                                                            [
+                                                                0
+                                                            ],
+                                                            [
+                                                                0
+                                                            ]
+                                                        ]
+                                                    },
+                                                    "metric": "max_abs_diff",
+                                                    "normalize": false
+                                                },
+                                                "name": "Distance Function-2",
+                                                "type": {
+                                                    "PNL": "Distance",
+                                                    "generic": null
+                                                }
+                                            },
+                                            "enable_learning": false,
+                                            "has_integrated": false,
+                                            "hetero": -1.0,
+                                            "initial_value": [
+                                                [
+                                                    0.5,
+                                                    0.5
+                                                ]
+                                            ],
+                                            "integration_rate": 0.5,
+                                            "integrator_function": "psyneulink.core.components.functions.statefulfunctions.integratorfunctions.AdaptiveIntegrator",
+                                            "integrator_function_value": [
+                                                [
+                                                    0
+                                                ]
+                                            ],
+                                            "integrator_mode": true,
+                                            "leak": 0.5,
+                                            "learning_condition": null,
+                                            "learning_function": "psyneulink.core.components.functions.learningfunctions.Hebbian",
+                                            "learning_rate": null,
+                                            "matrix": "HollowMatrix",
+                                            "max_passes": 1000,
+                                            "noise": 0.0,
+                                            "on_resume_integrator_mode": "instantaneous_mode_value",
+                                            "self_excitation": 0.0,
+                                            "smoothing_factor": 0.5,
+                                            "time_step_size": 0.1
+                                        },
+                                        "type": {
+                                            "PNL": "LCAMechanism",
+                                            "generic": null
+                                        }
+                                    },
+                                    "name": "gain"
+                                }
+                            ],
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": null,
+                            "modulation": "multiplicative_param",
+                            "net_outcome": null,
+                            "outcome": null,
+                            "output_states_spec": null,
+                            "previous_value": null,
+                            "simulation_ids": [],
+                            "variable": [
+                                [
+                                    1.0
+                                ]
+                            ]
+                        },
+                        "combine_costs": "gANjbnVtcHkuY29yZS5mcm9tbnVtZXJpYwpzdW0KcQAu\n",
+                        "compute_net_outcome": "gANjZGlsbC5fZGlsbApfY3JlYXRlX2Z1bmN0aW9uCnEAKGNkaWxsLl9kaWxsCl9sb2FkX3R5cGUK\ncQFYCAAAAENvZGVUeXBlcQKFcQNScQQoSwJLAEsCSwJLQ0MIfAB8ARgAUwBxBU6FcQYpWAcAAABv\ndXRjb21lcQdYBAAAAGNvc3RxCIZxCVhsAAAAL2hvbWUva2F0aGVyaW5lL2NvZGUvUHN5TmV1TGlu\nay9wc3luZXVsaW5rL2NvcmUvY29tcG9uZW50cy9tZWNoYW5pc21zL21vZHVsYXRvcnkvY29udHJv\nbC9jb250cm9sbWVjaGFuaXNtLnB5cQpYCAAAADxsYW1iZGE+cQtNLgRDAHEMKSl0cQ1ScQ5jcHN5\nbmV1bGluay5jb3JlLmNvbXBvbmVudHMubWVjaGFuaXNtcy5tb2R1bGF0b3J5LmNvbnRyb2wuY29u\ndHJvbG1lY2hhbmlzbQpfX2RpY3RfXwpoC05OfXEPTnRxEFJxES4=\n",
+                        "compute_reconfiguration_cost": null,
+                        "costs": null,
+                        "default_allocation": [
+                            0.5
+                        ],
+                        "objective_mechanism": {
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ]
+                                            ]
+                                        },
+                                        "matrix": [
+                                            [
+                                                0.0,
+                                                -2.5
+                                            ],
+                                            [
+                                                -2.5,
+                                                0.0
+                                            ]
+                                        ],
+                                        "metric": "energy",
+                                        "metric_fct": null,
+                                        "normalize": false,
+                                        "transfer_fct": null
+                                    },
+                                    "name": "Stability Function-0",
+                                    "type": {
+                                        "PNL": "Energy",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "input_ports": [
+                                {
+                                    "dtype": "float64",
+                                    "functions": [
+                                        {
+                                            "args": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "variable": [
+                                                        [
+                                                            0.0,
+                                                            0.0
+                                                        ]
+                                                    ]
+                                                },
+                                                "exponents": null,
+                                                "offset": 0.0,
+                                                "operation": "sum",
+                                                "scale": 1.0,
+                                                "weights": null
+                                            },
+                                            "name": "LinearCombination Function-25",
+                                            "type": {
+                                                "PNL": "LinearCombination",
+                                                "generic": null
+                                            }
+                                        }
+                                    ],
+                                    "name": "Value of OUTPUT [OutputState-0]",
+                                    "parameters": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "internal_only": false,
+                                            "require_projection_in_composition": true,
+                                            "shadow_inputs": null,
+                                            "variable": [
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ]
+                                            ]
+                                        },
+                                        "combine": null,
+                                        "exponent": null,
+                                        "weight": null
+                                    },
+                                    "shape": "(1, 2)",
+                                    "type": {
+                                        "PNL": "InputState",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "Conflict Monitor",
+                            "output_ports": [
+                                {
+                                    "dtype": "float64",
+                                    "functions": [
+                                        {
+                                            "args": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "variable": [
+                                                        -0.0
+                                                    ]
+                                                },
+                                                "bounds": null,
+                                                "intercept": 0.0,
+                                                "slope": 1.0
+                                            },
+                                            "name": "Linear Function-72",
+                                            "type": {
+                                                "generic": "Linear"
+                                            }
+                                        }
+                                    ],
+                                    "name": "OUTCOME",
+                                    "parameters": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "require_projection_in_composition": true,
+                                            "variable": [
+                                                -0.0
+                                            ]
+                                        }
+                                    },
+                                    "shape": "(1,)",
+                                    "type": {
+                                        "PNL": "OutputState",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "input_state_variables": null,
+                                    "input_states_spec": [
+                                        {
+                                            "functions": [
+                                                {
+                                                    "args": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "variable": [
+                                                                [
+                                                                    0.0,
+                                                                    0.0
+                                                                ]
+                                                            ]
+                                                        },
+                                                        "bias": {
+                                                            "source": "OUTPUT.input_ports.bias",
+                                                            "type": "float",
+                                                            "value": 0.0
+                                                        },
+                                                        "bounds": null,
+                                                        "gain": {
+                                                            "source": "OUTPUT.input_ports.gain",
+                                                            "type": "float",
+                                                            "value": 1.0
+                                                        },
+                                                        "offset": {
+                                                            "source": "OUTPUT.input_ports.offset",
+                                                            "type": "float",
+                                                            "value": 0.0
+                                                        },
+                                                        "scale": {
+                                                            "source": "OUTPUT.input_ports.scale",
+                                                            "type": "float",
+                                                            "value": 1.0
+                                                        },
+                                                        "x_0": {
+                                                            "source": "OUTPUT.input_ports.x_0",
+                                                            "type": "float",
+                                                            "value": 0.0
+                                                        }
+                                                    },
+                                                    "name": "Logistic Function-3",
+                                                    "type": {
+                                                        "generic": "Logistic"
+                                                    }
+                                                }
+                                            ],
+                                            "input_ports": [
+                                                {
+                                                    "dtype": "float64",
+                                                    "functions": [
+                                                        {
+                                                            "args": {
+                                                                "PNL": {
+                                                                    "execution_count": 0,
+                                                                    "has_initializers": false,
+                                                                    "variable": [
+                                                                        [
+                                                                            0.0,
+                                                                            0.0
+                                                                        ],
+                                                                        [
+                                                                            0.0,
+                                                                            0.0
+                                                                        ]
+                                                                    ]
+                                                                },
+                                                                "exponents": null,
+                                                                "offset": 0.0,
+                                                                "operation": "sum",
+                                                                "scale": 1.0,
+                                                                "weights": null
+                                                            },
+                                                            "name": "LinearCombination Function-14",
+                                                            "type": {
+                                                                "PNL": "LinearCombination",
+                                                                "generic": null
+                                                            }
+                                                        }
+                                                    ],
+                                                    "name": "InputState-0",
+                                                    "parameters": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "internal_only": false,
+                                                            "require_projection_in_composition": true,
+                                                            "shadow_inputs": null,
+                                                            "variable": [
+                                                                [
+                                                                    0.0,
+                                                                    0.0
+                                                                ],
+                                                                [
+                                                                    0.0,
+                                                                    0.0
+                                                                ]
+                                                            ]
+                                                        },
+                                                        "combine": null,
+                                                        "exponent": null,
+                                                        "weight": null
+                                                    },
+                                                    "shape": "(2, 2)",
+                                                    "type": {
+                                                        "PNL": "InputState",
+                                                        "generic": null
+                                                    }
+                                                },
+                                                {
+                                                    "dtype": "float64",
+                                                    "functions": [
+                                                        {
+                                                            "args": {
+                                                                "PNL": {
+                                                                    "execution_count": 0,
+                                                                    "has_initializers": false,
+                                                                    "variable": [
+                                                                        0.0
+                                                                    ]
+                                                                },
+                                                                "bounds": null,
+                                                                "intercept": 0.0,
+                                                                "slope": 1.0
+                                                            },
+                                                            "name": "Linear Function-18",
+                                                            "type": {
+                                                                "generic": "Linear"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "name": "bias",
+                                                    "parameters": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "require_projection_in_composition": true,
+                                                            "variable": [
+                                                                0.0
+                                                            ]
+                                                        }
+                                                    },
+                                                    "shape": "(1,)",
+                                                    "type": {
+                                                        "PNL": "ParameterState",
+                                                        "generic": null
+                                                    }
+                                                },
+                                                {
+                                                    "dtype": "float64",
+                                                    "functions": [
+                                                        {
+                                                            "args": {
+                                                                "PNL": {
+                                                                    "execution_count": 0,
+                                                                    "has_initializers": false,
+                                                                    "variable": [
+                                                                        1.0
+                                                                    ]
+                                                                },
+                                                                "bounds": null,
+                                                                "intercept": 0.0,
+                                                                "slope": 1.0
+                                                            },
+                                                            "name": "Linear Function-19",
+                                                            "type": {
+                                                                "generic": "Linear"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "name": "gain",
+                                                    "parameters": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "require_projection_in_composition": true,
+                                                            "variable": [
+                                                                1.0
+                                                            ]
+                                                        }
+                                                    },
+                                                    "shape": "(1,)",
+                                                    "type": {
+                                                        "PNL": "ParameterState",
+                                                        "generic": null
+                                                    }
+                                                },
+                                                {
+                                                    "dtype": "float64",
+                                                    "functions": [
+                                                        {
+                                                            "args": {
+                                                                "PNL": {
+                                                                    "execution_count": 0,
+                                                                    "has_initializers": false,
+                                                                    "variable": [
+                                                                        0.0
+                                                                    ]
+                                                                },
+                                                                "bounds": null,
+                                                                "intercept": 0.0,
+                                                                "slope": 1.0
+                                                            },
+                                                            "name": "Linear Function-20",
+                                                            "type": {
+                                                                "generic": "Linear"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "name": "offset",
+                                                    "parameters": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "require_projection_in_composition": true,
+                                                            "variable": [
+                                                                0.0
+                                                            ]
+                                                        }
+                                                    },
+                                                    "shape": "(1,)",
+                                                    "type": {
+                                                        "PNL": "ParameterState",
+                                                        "generic": null
+                                                    }
+                                                },
+                                                {
+                                                    "dtype": "float64",
+                                                    "functions": [
+                                                        {
+                                                            "args": {
+                                                                "PNL": {
+                                                                    "execution_count": 0,
+                                                                    "has_initializers": false,
+                                                                    "variable": [
+                                                                        1.0
+                                                                    ]
+                                                                },
+                                                                "bounds": null,
+                                                                "intercept": 0.0,
+                                                                "slope": 1.0
+                                                            },
+                                                            "name": "Linear Function-21",
+                                                            "type": {
+                                                                "generic": "Linear"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "name": "scale",
+                                                    "parameters": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "require_projection_in_composition": true,
+                                                            "variable": [
+                                                                1.0
+                                                            ]
+                                                        }
+                                                    },
+                                                    "shape": "(1,)",
+                                                    "type": {
+                                                        "PNL": "ParameterState",
+                                                        "generic": null
+                                                    }
+                                                },
+                                                {
+                                                    "dtype": "float64",
+                                                    "functions": [
+                                                        {
+                                                            "args": {
+                                                                "PNL": {
+                                                                    "execution_count": 0,
+                                                                    "has_initializers": false,
+                                                                    "variable": [
+                                                                        0.0
+                                                                    ]
+                                                                },
+                                                                "bounds": null,
+                                                                "intercept": 0.0,
+                                                                "slope": 1.0
+                                                            },
+                                                            "name": "Linear Function-22",
+                                                            "type": {
+                                                                "generic": "Linear"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "name": "x_0",
+                                                    "parameters": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "require_projection_in_composition": true,
+                                                            "variable": [
+                                                                0.0
+                                                            ]
+                                                        }
+                                                    },
+                                                    "shape": "(1,)",
+                                                    "type": {
+                                                        "PNL": "ParameterState",
+                                                        "generic": null
+                                                    }
+                                                }
+                                            ],
+                                            "name": "OUTPUT",
+                                            "output_ports": [
+                                                {
+                                                    "dtype": "float64",
+                                                    "functions": [
+                                                        {
+                                                            "args": {
+                                                                "PNL": {
+                                                                    "execution_count": 0,
+                                                                    "has_initializers": false,
+                                                                    "variable": [
+                                                                        0.5,
+                                                                        0.5
+                                                                    ]
+                                                                },
+                                                                "bounds": null,
+                                                                "intercept": 0.0,
+                                                                "slope": 1.0
+                                                            },
+                                                            "name": "Linear Function-24",
+                                                            "type": {
+                                                                "generic": "Linear"
+                                                            }
+                                                        }
+                                                    ],
+                                                    "name": "OutputState-0",
+                                                    "parameters": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "require_projection_in_composition": true,
+                                                            "variable": [
+                                                                0.5,
+                                                                0.5
+                                                            ]
+                                                        }
+                                                    },
+                                                    "shape": "(2,)",
+                                                    "type": {
+                                                        "PNL": "OutputState",
+                                                        "generic": null
+                                                    }
+                                                }
+                                            ],
+                                            "parameters": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "input_state_variables": null,
+                                                    "input_states_spec": null,
+                                                    "output_states_spec": null,
+                                                    "previous_value": null,
+                                                    "variable": [
+                                                        [
+                                                            0.0,
+                                                            0.0
+                                                        ]
+                                                    ]
+                                                }
+                                            },
+                                            "type": {
+                                                "PNL": "ProcessingMechanism",
+                                                "generic": null
+                                            }
+                                        }
+                                    ],
+                                    "output_states_spec": [
+                                        "OUTCOME"
+                                    ],
+                                    "previous_value": null,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                }
+                            },
+                            "type": {
+                                "PNL": "ObjectiveMechanism",
+                                "generic": null
+                            }
+                        },
+                        "reconfiguration_cost": null
+                    },
+                    "type": {
+                        "PNL": "ControlMechanism",
+                        "generic": null
+                    }
+                },
+                "Conflict Monitor": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "matrix": [
+                                    [
+                                        0.0,
+                                        -2.5
+                                    ],
+                                    [
+                                        -2.5,
+                                        0.0
+                                    ]
+                                ],
+                                "metric": "energy",
+                                "metric_fct": null,
+                                "normalize": false,
+                                "transfer_fct": null
+                            },
+                            "name": "Stability Function-0",
+                            "type": {
+                                "PNL": "Energy",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ]
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "LinearCombination Function-25",
+                                    "type": {
+                                        "PNL": "LinearCombination",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "Value of OUTPUT [OutputState-0]",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(1, 2)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "Conflict Monitor",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                -0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-72",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "OUTCOME",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        -0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": [
+                                {
+                                    "functions": [
+                                        {
+                                            "args": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "variable": [
+                                                        [
+                                                            0.0,
+                                                            0.0
+                                                        ]
+                                                    ]
+                                                },
+                                                "bias": {
+                                                    "source": "OUTPUT.input_ports.bias",
+                                                    "type": "float",
+                                                    "value": 0.0
+                                                },
+                                                "bounds": null,
+                                                "gain": {
+                                                    "source": "OUTPUT.input_ports.gain",
+                                                    "type": "float",
+                                                    "value": 1.0
+                                                },
+                                                "offset": {
+                                                    "source": "OUTPUT.input_ports.offset",
+                                                    "type": "float",
+                                                    "value": 0.0
+                                                },
+                                                "scale": {
+                                                    "source": "OUTPUT.input_ports.scale",
+                                                    "type": "float",
+                                                    "value": 1.0
+                                                },
+                                                "x_0": {
+                                                    "source": "OUTPUT.input_ports.x_0",
+                                                    "type": "float",
+                                                    "value": 0.0
+                                                }
+                                            },
+                                            "name": "Logistic Function-3",
+                                            "type": {
+                                                "generic": "Logistic"
+                                            }
+                                        }
+                                    ],
+                                    "input_ports": [
+                                        {
+                                            "dtype": "float64",
+                                            "functions": [
+                                                {
+                                                    "args": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "variable": [
+                                                                [
+                                                                    0.0,
+                                                                    0.0
+                                                                ],
+                                                                [
+                                                                    0.0,
+                                                                    0.0
+                                                                ]
+                                                            ]
+                                                        },
+                                                        "exponents": null,
+                                                        "offset": 0.0,
+                                                        "operation": "sum",
+                                                        "scale": 1.0,
+                                                        "weights": null
+                                                    },
+                                                    "name": "LinearCombination Function-14",
+                                                    "type": {
+                                                        "PNL": "LinearCombination",
+                                                        "generic": null
+                                                    }
+                                                }
+                                            ],
+                                            "name": "InputState-0",
+                                            "parameters": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "internal_only": false,
+                                                    "require_projection_in_composition": true,
+                                                    "shadow_inputs": null,
+                                                    "variable": [
+                                                        [
+                                                            0.0,
+                                                            0.0
+                                                        ],
+                                                        [
+                                                            0.0,
+                                                            0.0
+                                                        ]
+                                                    ]
+                                                },
+                                                "combine": null,
+                                                "exponent": null,
+                                                "weight": null
+                                            },
+                                            "shape": "(2, 2)",
+                                            "type": {
+                                                "PNL": "InputState",
+                                                "generic": null
+                                            }
+                                        },
+                                        {
+                                            "dtype": "float64",
+                                            "functions": [
+                                                {
+                                                    "args": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "variable": [
+                                                                0.0
+                                                            ]
+                                                        },
+                                                        "bounds": null,
+                                                        "intercept": 0.0,
+                                                        "slope": 1.0
+                                                    },
+                                                    "name": "Linear Function-18",
+                                                    "type": {
+                                                        "generic": "Linear"
+                                                    }
+                                                }
+                                            ],
+                                            "name": "bias",
+                                            "parameters": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "require_projection_in_composition": true,
+                                                    "variable": [
+                                                        0.0
+                                                    ]
+                                                }
+                                            },
+                                            "shape": "(1,)",
+                                            "type": {
+                                                "PNL": "ParameterState",
+                                                "generic": null
+                                            }
+                                        },
+                                        {
+                                            "dtype": "float64",
+                                            "functions": [
+                                                {
+                                                    "args": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "variable": [
+                                                                1.0
+                                                            ]
+                                                        },
+                                                        "bounds": null,
+                                                        "intercept": 0.0,
+                                                        "slope": 1.0
+                                                    },
+                                                    "name": "Linear Function-19",
+                                                    "type": {
+                                                        "generic": "Linear"
+                                                    }
+                                                }
+                                            ],
+                                            "name": "gain",
+                                            "parameters": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "require_projection_in_composition": true,
+                                                    "variable": [
+                                                        1.0
+                                                    ]
+                                                }
+                                            },
+                                            "shape": "(1,)",
+                                            "type": {
+                                                "PNL": "ParameterState",
+                                                "generic": null
+                                            }
+                                        },
+                                        {
+                                            "dtype": "float64",
+                                            "functions": [
+                                                {
+                                                    "args": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "variable": [
+                                                                0.0
+                                                            ]
+                                                        },
+                                                        "bounds": null,
+                                                        "intercept": 0.0,
+                                                        "slope": 1.0
+                                                    },
+                                                    "name": "Linear Function-20",
+                                                    "type": {
+                                                        "generic": "Linear"
+                                                    }
+                                                }
+                                            ],
+                                            "name": "offset",
+                                            "parameters": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "require_projection_in_composition": true,
+                                                    "variable": [
+                                                        0.0
+                                                    ]
+                                                }
+                                            },
+                                            "shape": "(1,)",
+                                            "type": {
+                                                "PNL": "ParameterState",
+                                                "generic": null
+                                            }
+                                        },
+                                        {
+                                            "dtype": "float64",
+                                            "functions": [
+                                                {
+                                                    "args": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "variable": [
+                                                                1.0
+                                                            ]
+                                                        },
+                                                        "bounds": null,
+                                                        "intercept": 0.0,
+                                                        "slope": 1.0
+                                                    },
+                                                    "name": "Linear Function-21",
+                                                    "type": {
+                                                        "generic": "Linear"
+                                                    }
+                                                }
+                                            ],
+                                            "name": "scale",
+                                            "parameters": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "require_projection_in_composition": true,
+                                                    "variable": [
+                                                        1.0
+                                                    ]
+                                                }
+                                            },
+                                            "shape": "(1,)",
+                                            "type": {
+                                                "PNL": "ParameterState",
+                                                "generic": null
+                                            }
+                                        },
+                                        {
+                                            "dtype": "float64",
+                                            "functions": [
+                                                {
+                                                    "args": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "variable": [
+                                                                0.0
+                                                            ]
+                                                        },
+                                                        "bounds": null,
+                                                        "intercept": 0.0,
+                                                        "slope": 1.0
+                                                    },
+                                                    "name": "Linear Function-22",
+                                                    "type": {
+                                                        "generic": "Linear"
+                                                    }
+                                                }
+                                            ],
+                                            "name": "x_0",
+                                            "parameters": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "require_projection_in_composition": true,
+                                                    "variable": [
+                                                        0.0
+                                                    ]
+                                                }
+                                            },
+                                            "shape": "(1,)",
+                                            "type": {
+                                                "PNL": "ParameterState",
+                                                "generic": null
+                                            }
+                                        }
+                                    ],
+                                    "name": "OUTPUT",
+                                    "output_ports": [
+                                        {
+                                            "dtype": "float64",
+                                            "functions": [
+                                                {
+                                                    "args": {
+                                                        "PNL": {
+                                                            "execution_count": 0,
+                                                            "has_initializers": false,
+                                                            "variable": [
+                                                                0.5,
+                                                                0.5
+                                                            ]
+                                                        },
+                                                        "bounds": null,
+                                                        "intercept": 0.0,
+                                                        "slope": 1.0
+                                                    },
+                                                    "name": "Linear Function-24",
+                                                    "type": {
+                                                        "generic": "Linear"
+                                                    }
+                                                }
+                                            ],
+                                            "name": "OutputState-0",
+                                            "parameters": {
+                                                "PNL": {
+                                                    "execution_count": 0,
+                                                    "has_initializers": false,
+                                                    "require_projection_in_composition": true,
+                                                    "variable": [
+                                                        0.5,
+                                                        0.5
+                                                    ]
+                                                }
+                                            },
+                                            "shape": "(2,)",
+                                            "type": {
+                                                "PNL": "OutputState",
+                                                "generic": null
+                                            }
+                                        }
+                                    ],
+                                    "parameters": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "input_state_variables": null,
+                                            "input_states_spec": null,
+                                            "output_states_spec": null,
+                                            "previous_value": null,
+                                            "variable": [
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ]
+                                            ]
+                                        }
+                                    },
+                                    "type": {
+                                        "PNL": "ProcessingMechanism",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "output_states_spec": [
+                                "OUTCOME"
+                            ],
+                            "previous_value": null,
+                            "variable": [
+                                [
+                                    0.0,
+                                    0.0
+                                ]
+                            ]
+                        }
+                    },
+                    "type": {
+                        "PNL": "ObjectiveMechanism",
+                        "generic": null
+                    }
+                },
+                "DECISION": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "bias": 0.5,
+                                "drift_rate": {
+                                    "source": "DECISION.input_ports.drift_rate",
+                                    "type": "float",
+                                    "value": 1.0
+                                },
+                                "noise": {
+                                    "source": "DECISION.input_ports.noise",
+                                    "type": "float",
+                                    "value": 0.5
+                                },
+                                "starting_point": {
+                                    "source": "DECISION.input_ports.starting_point",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "t0": 0.2,
+                                "threshold": {
+                                    "source": "DECISION.input_ports.threshold",
+                                    "type": "float",
+                                    "value": 1.0
+                                }
+                            },
+                            "name": "Drift Diffusion Analytical Function-4",
+                            "type": {
+                                "PNL": "DriftDiffusionAnalytical",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ]
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": [
+                                            1,
+                                            -1
+                                        ]
+                                    },
+                                    "name": "Reduce Function-2",
+                                    "type": {
+                                        "PNL": "Reduce",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "ARRAY",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(1, 2)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-58",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "drift_rate",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.5
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-59",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "noise",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.5
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-60",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "starting_point",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-61",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "threshold",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "DECISION",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-65",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "DECISION_VARIABLE",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                4.2
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-67",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "RESPONSE_TIME",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        4.2
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": [
+                                {
+                                    "function": {
+                                        "args": {
+                                            "PNL": {
+                                                "execution_count": 0,
+                                                "has_initializers": false,
+                                                "variable": [
+                                                    [
+                                                        0.0,
+                                                        0.0
+                                                    ]
+                                                ]
+                                            },
+                                            "exponents": null,
+                                            "offset": 0.0,
+                                            "operation": "sum",
+                                            "scale": 1.0,
+                                            "weights": [
+                                                1,
+                                                -1
+                                            ]
+                                        },
+                                        "name": "Reduce Function-2",
+                                        "type": {
+                                            "PNL": "Reduce",
+                                            "generic": null
+                                        }
+                                    },
+                                    "name": "ARRAY",
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                }
+                            ],
+                            "output_states_spec": [
+                                "DECISION_VARIABLE",
+                                "RESPONSE_TIME"
+                            ],
+                            "previous_value": null,
+                            "variable": [
+                                [
+                                    0.0
+                                ]
+                            ]
+                        },
+                        "initializer": [
+                            [
+                                0
+                            ]
+                        ],
+                        "input_format": "SCALAR"
+                    },
+                    "type": {
+                        "PNL": "DDM",
+                        "generic": null
+                    }
+                },
+                "OUTPUT": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "bias": {
+                                    "source": "OUTPUT.input_ports.bias",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "bounds": null,
+                                "gain": {
+                                    "source": "OUTPUT.input_ports.gain",
+                                    "type": "float",
+                                    "value": 1.0
+                                },
+                                "offset": {
+                                    "source": "OUTPUT.input_ports.offset",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "scale": {
+                                    "source": "OUTPUT.input_ports.scale",
+                                    "type": "float",
+                                    "value": 1.0
+                                },
+                                "x_0": {
+                                    "source": "OUTPUT.input_ports.x_0",
+                                    "type": "float",
+                                    "value": 0.0
+                                }
+                            },
+                            "name": "Logistic Function-3",
+                            "type": {
+                                "generic": "Logistic"
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ],
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ]
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "LinearCombination Function-14",
+                                    "type": {
+                                        "PNL": "LinearCombination",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "InputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ],
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(2, 2)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-18",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "bias",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-19",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "gain",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-20",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "offset",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-21",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "scale",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-22",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "x_0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "OUTPUT",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.5,
+                                                0.5
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-24",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "OutputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.5,
+                                        0.5
+                                    ]
+                                }
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": null,
+                            "output_states_spec": null,
+                            "previous_value": null,
+                            "variable": [
+                                [
+                                    0.0,
+                                    0.0
+                                ]
+                            ]
+                        }
+                    },
+                    "type": {
+                        "PNL": "ProcessingMechanism",
+                        "generic": null
+                    }
+                },
+                "TASK": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "bias": {
+                                    "source": "TASK.input_ports.bias",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "bounds": null,
+                                "gain": {
+                                    "source": "TASK.input_ports.gain",
+                                    "type": "float",
+                                    "value": 1.0
+                                },
+                                "offset": {
+                                    "source": "TASK.input_ports.offset",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "scale": {
+                                    "source": "TASK.input_ports.scale",
+                                    "type": "float",
+                                    "value": 1.0
+                                },
+                                "x_0": {
+                                    "source": "TASK.input_ports.x_0",
+                                    "type": "float",
+                                    "value": 0.0
+                                }
+                            },
+                            "name": "Logistic Function-6",
+                            "type": {
+                                "generic": "Logistic"
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ],
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ]
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "LinearCombination Function-22",
+                                    "type": {
+                                        "PNL": "LinearCombination",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "InputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ],
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(2, 2)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.01
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-44",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "convergence_criterion",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.01
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-45",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "bias",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-46",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "gain",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-47",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "offset",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-48",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "scale",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-49",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "x_0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.5
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-50",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "integration_rate",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.5
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.5
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-51",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "leak",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.5
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-52",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "noise",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.1
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-53",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "time_step_size",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.1
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "TASK",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.6283161882953663,
+                                                0.6283161882953663
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-56",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "RESULT",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.6283161882953663,
+                                        0.6283161882953663
+                                    ]
+                                }
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": null,
+                            "output_states_spec": [
+                                "RESULT"
+                            ],
+                            "previous_value": null,
+                            "variable": [
+                                [
+                                    0.0,
+                                    0.0
+                                ]
+                            ]
+                        },
+                        "auto": 0.0,
+                        "clip": null,
+                        "combination_function": "psyneulink.core.components.functions.combinationfunctions.LinearCombination",
+                        "competition": 1.0,
+                        "convergence_criterion": 0.01,
+                        "convergence_function": {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0
+                                        ],
+                                        [
+                                            0
+                                        ]
+                                    ]
+                                },
+                                "metric": "max_abs_diff",
+                                "normalize": false
+                            },
+                            "name": "Distance Function-2",
+                            "type": {
+                                "PNL": "Distance",
+                                "generic": null
+                            }
+                        },
+                        "enable_learning": false,
+                        "has_integrated": false,
+                        "hetero": -1.0,
+                        "initial_value": [
+                            [
+                                0.5,
+                                0.5
+                            ]
+                        ],
+                        "integration_rate": 0.5,
+                        "integrator_function": "psyneulink.core.components.functions.statefulfunctions.integratorfunctions.AdaptiveIntegrator",
+                        "integrator_function_value": [
+                            [
+                                0
+                            ]
+                        ],
+                        "integrator_mode": true,
+                        "leak": 0.5,
+                        "learning_condition": null,
+                        "learning_function": "psyneulink.core.components.functions.learningfunctions.Hebbian",
+                        "learning_rate": null,
+                        "matrix": "HollowMatrix",
+                        "max_passes": 1000,
+                        "noise": 0.0,
+                        "on_resume_integrator_mode": "instantaneous_mode_value",
+                        "self_excitation": 0.0,
+                        "smoothing_factor": 0.5,
+                        "time_step_size": 0.1
+                    },
+                    "type": {
+                        "PNL": "LCAMechanism",
+                        "generic": null
+                    }
+                },
+                "color_hidden": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "bias": {
+                                    "source": "color_hidden.input_ports.bias",
+                                    "type": "int",
+                                    "value": -4
+                                },
+                                "bounds": null,
+                                "gain": {
+                                    "source": "color_hidden.input_ports.gain",
+                                    "type": "float",
+                                    "value": 1.0
+                                },
+                                "offset": {
+                                    "source": "color_hidden.input_ports.offset",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "scale": {
+                                    "source": "color_hidden.input_ports.scale",
+                                    "type": "float",
+                                    "value": 1.0
+                                },
+                                "x_0": {
+                                    "source": "color_hidden.input_ports.x_0",
+                                    "type": "float",
+                                    "value": 0.0
+                                }
+                            },
+                            "name": "Logistic Function-1",
+                            "type": {
+                                "generic": "Logistic"
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ],
+                                                [
+                                                    2.513264753181465,
+                                                    2.513264753181465
+                                                ]
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "LinearCombination Function-12",
+                                    "type": {
+                                        "PNL": "LinearCombination",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "InputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ],
+                                        [
+                                            2.513264753181465,
+                                            2.513264753181465
+                                        ]
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(2, 2)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "int64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                -4
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-11",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "bias",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        -4
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-12",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "gain",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-13",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "offset",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-14",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "scale",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-15",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "x_0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "color_hidden",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.017986209962091562,
+                                                0.017986209962091562
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-17",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "OutputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.017986209962091562,
+                                        0.017986209962091562
+                                    ]
+                                }
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": null,
+                            "output_states_spec": null,
+                            "previous_value": null,
+                            "variable": [
+                                [
+                                    0.0,
+                                    0.0
+                                ]
+                            ]
+                        }
+                    },
+                    "type": {
+                        "PNL": "ProcessingMechanism",
+                        "generic": null
+                    }
+                },
+                "color_input": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "bounds": null,
+                                "intercept": {
+                                    "source": "color_input.input_ports.intercept",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "slope": {
+                                    "source": "color_input.input_ports.slope",
+                                    "type": "float",
+                                    "value": 1.0
+                                }
+                            },
+                            "name": "Linear Function-8",
+                            "type": {
+                                "generic": "Linear"
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0,
+                                                0.0
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "LinearCombination Function-10",
+                                    "type": {
+                                        "PNL": "LinearCombination",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "InputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        0.0,
+                                        0.0
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-6",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "intercept",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-7",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "slope",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "color_input",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0,
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-10",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "OutputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0,
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": null,
+                            "output_states_spec": null,
+                            "previous_value": null,
+                            "variable": [
+                                [
+                                    0.0,
+                                    0.0
+                                ]
+                            ]
+                        }
+                    },
+                    "type": {
+                        "PNL": "ProcessingMechanism",
+                        "generic": null
+                    }
+                },
+                "task_input": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "bounds": null,
+                                "intercept": {
+                                    "source": "task_input.input_ports.intercept",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "slope": {
+                                    "source": "task_input.input_ports.slope",
+                                    "type": "float",
+                                    "value": 1.0
+                                }
+                            },
+                            "name": "Linear Function-41",
+                            "type": {
+                                "generic": "Linear"
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0,
+                                                0.0
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "LinearCombination Function-20",
+                                    "type": {
+                                        "PNL": "LinearCombination",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "InputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        0.0,
+                                        0.0
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-39",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "intercept",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-40",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "slope",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "task_input",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0,
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-43",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "OutputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0,
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": null,
+                            "output_states_spec": null,
+                            "previous_value": null,
+                            "variable": [
+                                [
+                                    0.0,
+                                    0.0
+                                ]
+                            ]
+                        }
+                    },
+                    "type": {
+                        "PNL": "ProcessingMechanism",
+                        "generic": null
+                    }
+                },
+                "word_hidden": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "bias": {
+                                    "source": "word_hidden.input_ports.bias",
+                                    "type": "int",
+                                    "value": -4
+                                },
+                                "bounds": null,
+                                "gain": {
+                                    "source": "word_hidden.input_ports.gain",
+                                    "type": "float",
+                                    "value": 1.0
+                                },
+                                "offset": {
+                                    "source": "word_hidden.input_ports.offset",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "scale": {
+                                    "source": "word_hidden.input_ports.scale",
+                                    "type": "float",
+                                    "value": 1.0
+                                },
+                                "x_0": {
+                                    "source": "word_hidden.input_ports.x_0",
+                                    "type": "float",
+                                    "value": 0.0
+                                }
+                            },
+                            "name": "Logistic Function-4",
+                            "type": {
+                                "generic": "Logistic"
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                [
+                                                    0.0,
+                                                    0.0
+                                                ],
+                                                [
+                                                    2.513264753181465,
+                                                    2.513264753181465
+                                                ]
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "LinearCombination Function-18",
+                                    "type": {
+                                        "PNL": "LinearCombination",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "InputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ],
+                                        [
+                                            2.513264753181465,
+                                            2.513264753181465
+                                        ]
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(2, 2)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "int64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                -4
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-31",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "bias",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        -4
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-32",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "gain",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-33",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "offset",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-34",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "scale",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-35",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "x_0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "word_hidden",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.017986209962091562,
+                                                0.017986209962091562
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-37",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "OutputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.017986209962091562,
+                                        0.017986209962091562
+                                    ]
+                                }
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": null,
+                            "output_states_spec": null,
+                            "previous_value": null,
+                            "variable": [
+                                [
+                                    0.0,
+                                    0.0
+                                ]
+                            ]
+                        }
+                    },
+                    "type": {
+                        "PNL": "ProcessingMechanism",
+                        "generic": null
+                    }
+                },
+                "word_input": {
+                    "functions": [
+                        {
+                            "args": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "variable": [
+                                        [
+                                            0.0,
+                                            0.0
+                                        ]
+                                    ]
+                                },
+                                "bounds": null,
+                                "intercept": {
+                                    "source": "word_input.input_ports.intercept",
+                                    "type": "float",
+                                    "value": 0.0
+                                },
+                                "slope": {
+                                    "source": "word_input.input_ports.slope",
+                                    "type": "float",
+                                    "value": 1.0
+                                }
+                            },
+                            "name": "Linear Function-28",
+                            "type": {
+                                "generic": "Linear"
+                            }
+                        }
+                    ],
+                    "input_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0,
+                                                0.0
+                                            ]
+                                        },
+                                        "exponents": null,
+                                        "offset": 0.0,
+                                        "operation": "sum",
+                                        "scale": 1.0,
+                                        "weights": null
+                                    },
+                                    "name": "LinearCombination Function-16",
+                                    "type": {
+                                        "PNL": "LinearCombination",
+                                        "generic": null
+                                    }
+                                }
+                            ],
+                            "name": "InputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "internal_only": false,
+                                    "require_projection_in_composition": true,
+                                    "shadow_inputs": null,
+                                    "variable": [
+                                        0.0,
+                                        0.0
+                                    ]
+                                },
+                                "combine": null,
+                                "exponent": null,
+                                "weight": null
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "InputState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-26",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "intercept",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        },
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                1.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-27",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "slope",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        1.0
+                                    ]
+                                }
+                            },
+                            "shape": "(1,)",
+                            "type": {
+                                "PNL": "ParameterState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "name": "word_input",
+                    "output_ports": [
+                        {
+                            "dtype": "float64",
+                            "functions": [
+                                {
+                                    "args": {
+                                        "PNL": {
+                                            "execution_count": 0,
+                                            "has_initializers": false,
+                                            "variable": [
+                                                0.0,
+                                                0.0
+                                            ]
+                                        },
+                                        "bounds": null,
+                                        "intercept": 0.0,
+                                        "slope": 1.0
+                                    },
+                                    "name": "Linear Function-30",
+                                    "type": {
+                                        "generic": "Linear"
+                                    }
+                                }
+                            ],
+                            "name": "OutputState-0",
+                            "parameters": {
+                                "PNL": {
+                                    "execution_count": 0,
+                                    "has_initializers": false,
+                                    "require_projection_in_composition": true,
+                                    "variable": [
+                                        0.0,
+                                        0.0
+                                    ]
+                                }
+                            },
+                            "shape": "(2,)",
+                            "type": {
+                                "PNL": "OutputState",
+                                "generic": null
+                            }
+                        }
+                    ],
+                    "parameters": {
+                        "PNL": {
+                            "execution_count": 0,
+                            "has_initializers": false,
+                            "input_state_variables": null,
+                            "input_states_spec": null,
+                            "output_states_spec": null,
+                            "previous_value": null,
+                            "variable": [
+                                [
+                                    0.0,
+                                    0.0
+                                ]
+                            ]
+                        }
+                    },
+                    "type": {
+                        "PNL": "ProcessingMechanism",
+                        "generic": null
+                    }
+                }
+            },
+            "parameters": {
+                "PNL": {
+                    "execution_count": 0,
+                    "has_initializers": false,
+                    "node_ordering": [
+                        "color_input",
+                        "color_hidden",
+                        "OUTPUT",
+                        "word_input",
+                        "word_hidden",
+                        "task_input",
+                        "TASK",
+                        "DECISION",
+                        "CONTROL",
+                        "Conflict Monitor"
+                    ],
+                    "required_node_roles": [],
+                    "results": [],
+                    "schedulers": {
+                        "ContextFlags.PROCESSING": {
+                            "conditions": {
+                                "node": {
+                                    "DECISION": {
+                                        "args": [
+                                            "OUTPUT",
+                                            1
+                                        ],
+                                        "function": null,
+                                        "kwargs": {},
+                                        "type": "EveryNCalls"
+                                    },
+                                    "OUTPUT": {
+                                        "args": [
+                                            {
+                                                "args": [
+                                                    "color_hidden",
+                                                    1
+                                                ],
+                                                "function": null,
+                                                "kwargs": {},
+                                                "type": "EveryNCalls"
+                                            },
+                                            {
+                                                "args": [
+                                                    "word_hidden",
+                                                    1
+                                                ],
+                                                "function": null,
+                                                "kwargs": {},
+                                                "type": "EveryNCalls"
+                                            }
+                                        ],
+                                        "function": null,
+                                        "kwargs": {},
+                                        "type": "All"
+                                    },
+                                    "color_hidden": {
+                                        "args": [
+                                            "TASK",
+                                            10
+                                        ],
+                                        "function": null,
+                                        "kwargs": {},
+                                        "type": "EveryNCalls"
+                                    },
+                                    "word_hidden": {
+                                        "args": [
+                                            "TASK",
+                                            10
+                                        ],
+                                        "function": null,
+                                        "kwargs": {},
+                                        "type": "EveryNCalls"
+                                    }
+                                },
+                                "termination": {
+                                    "TimeScale.RUN": {
+                                        "args": [],
+                                        "function": null,
+                                        "kwargs": {},
+                                        "type": "Never"
+                                    },
+                                    "TimeScale.TRIAL": {
+                                        "args": [],
+                                        "function": null,
+                                        "kwargs": {},
+                                        "type": "AllHaveRun"
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "simulation_results": [],
+                    "variable": [
+                        0
+                    ]
+                },
+                "retain_old_simulation_data": false
+            },
+            "type": {
+                "PNL": "Composition",
+                "generic": "graph"
+            }
+        }
+    ]
+}
diff --git a/docs/source/json.rst b/docs/source/json.rst
new file mode 100644
index 00000000000..49dac12292e
--- /dev/null
+++ b/docs/source/json.rst
@@ -0,0 +1,6 @@
+JSON
+====
+
+.. automodule:: psyneulink.core.globals.json
+   :members:
+   :exclude-members: PNLJSONError
diff --git a/psyneulink/core/components/component.py b/psyneulink/core/components/component.py
index b84834aa54c..7ee53299b09 100644
--- a/psyneulink/core/components/component.py
+++ b/psyneulink/core/components/component.py
@@ -400,10 +400,13 @@ class `UserList <https://docs.python.org/3.6/library/collections.html?highlight=
 COMMENT
 
 """
+import base64
 import copy
+import dill
 import inspect
 import logging
 import numbers
+import re
 import types
 import warnings
 
@@ -417,11 +420,14 @@ class `UserList <https://docs.python.org/3.6/library/collections.html?highlight=
 
 from psyneulink.core import llvm as pnlvm
 from psyneulink.core.globals.context import Context, ContextError, ContextFlags, INITIALIZATION_STATUS_FLAGS, _get_time, handle_external_context
+from psyneulink.core.globals.json import JSONDumpable
 from psyneulink.core.globals.keywords import \
     COMPONENT_INIT, CONTEXT, CONTROL_PROJECTION, DEFERRED_INITIALIZATION, \
     FUNCTION, FUNCTION_CHECK_ARGS, FUNCTION_PARAMS, INITIALIZING, INIT_FULL_EXECUTE_METHOD, INPUT_STATES, \
     LEARNING, LEARNING_PROJECTION, LOG_ENTRIES, MATRIX, MODULATORY_SPEC_KEYWORDS, NAME, OUTPUT_STATES, \
-    PARAMS, PARAMS_CURRENT, PREFS_ARG, REINITIALIZE_WHEN, SIZE, USER_PARAMS, VALUE, VARIABLE, FUNCTION_COMPONENT_CATEGORY
+    PARAMS, PARAMS_CURRENT, PREFS_ARG, REINITIALIZE_WHEN, SIZE, USER_PARAMS, VALUE, VARIABLE, FUNCTION_COMPONENT_CATEGORY, \
+    MODEL_SPEC_ID_PSYNEULINK, MODEL_SPEC_ID_GENERIC, MODEL_SPEC_ID_TYPE, MODEL_SPEC_ID_PARAMETER_SOURCE, \
+    MODEL_SPEC_ID_PARAMETER_VALUE, MODEL_SPEC_ID_INPUT_PORTS, MODEL_SPEC_ID_OUTPUT_PORTS
 from psyneulink.core.globals.log import LogCondition
 from psyneulink.core.globals.parameters import Defaults, Parameter, ParameterAlias, ParameterError, ParametersBase
 from psyneulink.core.globals.preferences.basepreferenceset import BasePreferenceSet, VERBOSE_PREF
@@ -675,7 +681,7 @@ def class_defaults(self):
         return self.defaults
 
 
-class Component(object, metaclass=ComponentsMeta):
+class Component(JSONDumpable, metaclass=ComponentsMeta):
     """Base class for Component.
 
     .. note::
@@ -862,6 +868,22 @@ class Component(object, metaclass=ComponentsMeta):
 
     standard_constructor_args = [REINITIALIZE_WHEN]
 
+    # helper attributes for JSON model spec
+    _model_spec_id_parameters = 'parameters'
+
+    _model_spec_generic_type_name = NotImplemented
+    """
+        string describing this class's generic type in universal model
+        specification,
+        if it exists and is different than the class name
+    """
+
+    _model_spec_class_name_is_generic = False
+    """
+        True if the class name is the class's generic type in universal model specification,
+        False otherwise
+    """
+
     class Parameters(ParametersBase):
         """
             The `Parameters` that are associated with all `Components`
@@ -897,12 +919,19 @@ class Parameters(ParametersBase):
                     :read only: True
 
         """
-        variable = Parameter(np.array([0]), read_only=True)
-        value = Parameter(np.array([0]), read_only=True)
-        has_initializers = Parameter(False, setter=_has_initializers_setter)
+        variable = Parameter(np.array([0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
+        value = Parameter(np.array([0]), read_only=True, pnl_internal=True)
+        has_initializers = Parameter(False, setter=_has_initializers_setter, pnl_internal=True)
         # execution_count ios not stateful because it is a global counter;
         #    for context-specific counts should use schedulers which store this info
-        execution_count = Parameter(0, read_only=True, loggable=False, stateful=False, fallback_default=True)
+        execution_count = Parameter(
+            0,
+            read_only=True,
+            loggable=False,
+            stateful=False,
+            fallback_default=True,
+            pnl_internal=True
+        )
 
         def _parse_variable(self, variable):
             return variable
@@ -1016,25 +1045,8 @@ def __init__(self,
                                     format(self.__class__.__bases__[0].__name__))
 
         # ASSIGN PREFS
-
-        # If a PreferenceSet was provided, assign to instance
-        # If a PreferenceSet was provided, assign to instance
         _assign_prefs(self, prefs, BasePreferenceSet)
 
-        # # MODIFIED 9/30/19 OLD:
-        # if isinstance(prefs, PreferenceSet):
-        #     self.prefs = prefs
-        #     # FIX:  CHECK LEVEL HERE??  OR DOES IT NOT MATTER, AS OWNER WILL BE ASSIGNED DYNAMICALLY??
-        # # Otherwise, if prefs is a specification dict instantiate it, or if it is None assign defaults
-        # else:
-        #     self.prefs = BasePreferenceSet(owner=self, prefs=prefs, context=context)
-        # try:
-        #     # assign log conditions from preferences
-        #     self.parameters.value.log_condition = self.prefs._log_pref.setting
-        # except AttributeError:
-        #     pass
-        # MODIFIED 9/30/19 END
-
         # ASSIGN LOG
         from psyneulink.core.globals.log import Log
         self.log = Log(owner=self)
@@ -1146,14 +1158,6 @@ def __init__(self,
         self._validate(context=context)
 
         self.initialization_status = ContextFlags.INITIALIZED
-        # MODIFIED 12/4/18 NEW [JDC]:
-        from psyneulink.core.components.functions.function import Function_Base
-        if (
-            isinstance(self.function, Function_Base)
-            and self.function.initialization_status != ContextFlags.DEFERRED_INIT
-        ):
-            self.function.initialization_status = ContextFlags.INITIALIZED
-        # MODIFIED 12/4/18 END
 
         self._compilation_data = self._CompilationData(owner=self)
 
@@ -1467,8 +1471,6 @@ def _deferred_init(self, context=None):
             else:
                 self._assign_default_name()
 
-            self.initialization_status = ContextFlags.INITIALIZED
-
     def _assign_deferred_init_name(self, name, context):
 
         name = "{} [{}]".format(name,DEFERRED_INITIALIZATION) if name \
@@ -2175,12 +2177,14 @@ def _instantiate_defaults(self,
                                       context=context)
 
     def _initialize_parameters(self, context=None, **param_defaults):
+        alias_names = {p.name for p in self.class_parameters if isinstance(p, ParameterAlias)}
+
         self.parameters = self.Parameters(owner=self, parent=self.class_parameters)
 
         # assign defaults based on pass in params and class defaults
         defaults = {
             k: copy.deepcopy(v) for (k, v) in self.class_defaults.values(show_all=True).items()
-            if not isinstance(getattr(self.class_parameters, k), ParameterAlias)
+            if not k in alias_names
         }
         try:
             function_params = param_defaults[FUNCTION_PARAMS]
@@ -2195,7 +2199,10 @@ def _initialize_parameters(self, context=None, **param_defaults):
             d = {
                 k: v for (k, v) in param_defaults.items()
                 if (
-                    k not in defaults
+                    (
+                        k not in defaults
+                        and k not in alias_names
+                    )
                     or (
                         (function_params is None or k not in function_params)
                         and v is not None
@@ -2203,10 +2210,11 @@ def _initialize_parameters(self, context=None, **param_defaults):
                 )
             }
             for p in d:
-                try:
-                    getattr(self.parameters, p)._user_specified = True
-                except AttributeError:
-                    pass
+                if d[p] is not None:
+                    try:
+                        getattr(self.parameters, p)._user_specified = True
+                    except AttributeError:
+                        pass
             defaults.update(d)
 
         self.defaults = Defaults(owner=self, **defaults)
@@ -2875,6 +2883,7 @@ def _instantiate_function(self, function, function_params=None, context=None):
         if isinstance(function, types.FunctionType):
             self.function = UserDefinedFunction(default_variable=function_variable,
                                                 custom_function=function,
+                                                owner=self,
                                                 context=context)
             self.function_params = ReadOnlyOrderedDict(name=FUNCTION_PARAMS)
             for param_name in self.function.cust_fct_params:
@@ -2907,14 +2916,9 @@ def _instantiate_function(self, function, function_params=None, context=None):
             else:
                 self.function = copy.deepcopy(function)
 
-            # setting init status because many mechanisms change execution or validation behavior
-            # during initialization
-            self.function.initialization_status = ContextFlags.INITIALIZING
-
-            self.function.defaults.variable = function_variable
-            self.function._instantiate_value(context)
-
-            self.function.initialization_status = ContextFlags.INITIALIZED
+            # set owner first because needed for is_initializing calls
+            self.function.owner = self
+            self.function._update_default_variable(function_variable, context)
 
         # Specification is Function class
         # Note:  parameter_states for function's parameters will be created in_instantiate_attributes_after_function
@@ -2940,13 +2944,11 @@ def _instantiate_function(self, function, function_params=None, context=None):
                         pass
 
             _, kwargs = prune_unused_args(function.__init__, args=[], kwargs=kwargs_to_instantiate)
-            self.function = function(default_variable=function_variable, **kwargs)
+            self.function = function(default_variable=function_variable, owner=self, **kwargs)
 
         else:
             raise ComponentError(f'Unsupported function type: {type(function)}, function={function}.')
 
-        self.function.owner = self
-
         # KAM added 6/14/18 for functions that do not pass their has_initializers status up to their owner via property
         # FIX: need comprehensive solution for has_initializers; need to determine whether states affect mechanism's
         # has_initializers status
@@ -2989,9 +2991,28 @@ def _instantiate_value(self, context=None):
             # Immutable, so just assign value
             self.defaults.value = value
 
+    def _update_default_variable(self, new_default_variable, context=None):
+        self.defaults.variable = copy.deepcopy(new_default_variable)
+        self._instantiate_value(context)
+
+        function_variable = self._parse_function_variable(
+            new_default_variable,
+            context
+        )
+        try:
+            self.function._update_default_variable(function_variable, context)
+        except AttributeError:
+            pass
+
     def initialize(self, context=None):
         raise ComponentError("{} class does not support initialize() method".format(self.__class__.__name__))
 
+    def _check_for_composition(self, context=None):
+        """Allow Component to check whether it or its attributes are suitable for inclusion in a Composition
+        Called by Composition.add_node.
+        """
+        pass
+
     @handle_external_context(execution_id=NotImplemented)
     def reinitialize(self, *args, context=None):
         """
@@ -3234,7 +3255,8 @@ def initialization_status(self):
 
     @initialization_status.setter
     def initialization_status(self, flag):
-        """Check that a flag is one and only one status flag"""
+        """Check that a flag is one and only one status flag
+        """
         if flag in INITIALIZATION_STATUS_FLAGS:
             self._initialization_status = flag
         elif not flag:
@@ -3305,37 +3327,153 @@ def log_values(self, entries):
         """
         self.log.log_values(entries)
 
+    @property
     def _dict_summary(self):
+        from psyneulink.core.compositions.composition import Composition
+        from psyneulink.core.components.states.state import State
+        from psyneulink.core.components.states.outputstate import OutputState
+        from psyneulink.core.components.projections.pathway.mappingprojection import MappingProjection
+
+        def parse_parameter_value(value):
+            if isinstance(value, (list, tuple)):
+                new_item = []
+                for item in value:
+                    new_item.append(parse_parameter_value(item))
+                value = type(value)(new_item)
+            elif isinstance(value, dict):
+                value = {
+                    parse_parameter_value(k): parse_parameter_value(v)
+                    for k, v in value.items()
+                }
+            elif isinstance(value, Composition):
+                value = value.name
+            elif isinstance(value, State):
+                if isinstance(value, OutputState):
+                    state_port_name = MODEL_SPEC_ID_OUTPUT_PORTS
+                else:
+                    state_port_name = MODEL_SPEC_ID_INPUT_PORTS
+
+                # assume we will use the identifier on reconstitution
+                value = '{0}.{1}.{2}'.format(
+                    value.owner.name,
+                    state_port_name,
+                    value.name
+                )
+            elif isinstance(value, Component):
+                # could potentially create duplicates when it should
+                # create a reference to an already existent Component like
+                # with Compositions, but in a vacuum the full specification
+                # is necessary.
+                # in fact this would happen unless the parser specifically
+                # handles it like ours does
+                value = value._dict_summary
+            elif isinstance(value, (types.FunctionType)):
+                value = base64.encodebytes(dill.dumps(value)).decode('utf-8')
+
+            return value
+
+        # attributes (and their values) included in top-level dict
         basic_attributes = ['name']
 
-        # lifted from LLVM
-        parameter_black_list = {'function', 'variable', 'value', 'context'}
+        # attributes that aren't Parameters but are psyneulink-specific
+        # and are stored in the PNL parameters section
+        implicit_parameter_attributes = ['node_ordering', 'required_node_roles']
+
         parameters_dict = {}
+        pnl_specific_parameters = {}
+        deferred_init_values = {}
+
+        if self.initialization_status is ContextFlags.DEFERRED_INIT:
+            deferred_init_values = copy.copy(self.init_args)
+            try:
+                deferred_init_values.update(deferred_init_values['params'])
+            except KeyError:
+                pass
+
+            # .parameters still refers to class parameters during deferred init
+            assert not _parameters_belongs_to_obj(self)
 
         for p in self.parameters:
-            if p.user and p.name not in parameter_black_list:
-                val = p._get(self.most_recent_context)
+            if p.name not in self._model_spec_parameter_blacklist:
+                if self.initialization_status is ContextFlags.DEFERRED_INIT:
+                    try:
+                        val = deferred_init_values[p.name]
+                    except KeyError:
+                        # class default
+                        val = p.default_value
+                else:
+                    # special handling because MappingProjection matrix just
+                    # refers to its function's matrix but its default values are
+                    # PNL-specific
+                    if (
+                        isinstance(self, MappingProjection)
+                        and p.name == 'matrix'
+                    ):
+                        val = self.function.defaults.matrix
+                    else:
+                        val = p.default_value
+
+                val = parse_parameter_value(val)
+
+                try:
+                    matching_parameter_state = self.owner.parameter_states[p.name]
+
+                    if matching_parameter_state.source is self:
+                        val = {
+                            MODEL_SPEC_ID_PARAMETER_SOURCE: '{0}.{1}.{2}'.format(
+                                self.owner.name,
+                                MODEL_SPEC_ID_INPUT_PORTS,
+                                p.name
+                            ),
+                            MODEL_SPEC_ID_PARAMETER_VALUE: val,
+                            MODEL_SPEC_ID_TYPE: type(val)
+                        }
+                # ContentAddressableList uses TypeError when key not found
+                except (AttributeError, TypeError):
+                    pass
 
-                if isinstance(val, np.ndarray):
-                    val = f'numpy.array({val})'
-                elif not isinstance(val, numbers.Number) and val is not None:
-                    val = str(val)
+                # split parameters designated as PsyNeuLink-specific and
+                # parameters that are universal
+                if p.pnl_internal:
+                    pnl_specific_parameters[p.name] = val
+                else:
+                    parameters_dict[p.name] = val
+
+        for attr in implicit_parameter_attributes:
+            try:
+                pnl_specific_parameters[attr] = getattr(self, attr)
+            except AttributeError:
+                pass
+
+        if len(pnl_specific_parameters) > 0:
+            parameters_dict[MODEL_SPEC_ID_PSYNEULINK] = pnl_specific_parameters
+
+        function_dict = {}
+        try:
+            if isinstance(self.function, Component):
+                function_dict['functions'] = [self.function._dict_summary]
+        except AttributeError:
+            pass
 
-                parameters_dict[p.name] = val
+        type_dict = {}
 
-        function_dict = {'function': self.function._dict_summary()} if (hasattr(self, 'function') and isinstance(self.function, Component)) else {}
+        if self._model_spec_class_name_is_generic:
+            type_dict[MODEL_SPEC_ID_GENERIC] = self.__class__.__name__
+        else:
+            if self._model_spec_generic_type_name is not NotImplemented:
+                type_dict[MODEL_SPEC_ID_GENERIC] = self._model_spec_generic_type_name
+            else:
+                type_dict[MODEL_SPEC_ID_GENERIC] = None
+
+            type_dict[MODEL_SPEC_ID_PSYNEULINK] = self.__class__.__name__
 
         return {
             **{attr: getattr(self, attr) for attr in basic_attributes},
-            **{'parameters': parameters_dict},
+            **{self._model_spec_id_parameters: parameters_dict},
             **function_dict,
-            **{'type': self.__class__.__name__}
+            **{MODEL_SPEC_ID_TYPE: type_dict}
         }
 
-    def json_summary(self):
-        import json
-        return json.dumps(self._dict_summary(), sort_keys=True, indent=4, separators=(',', ': '))
-
     @property
     def logged_items(self):
         """Dictionary of all items that have entries in the log, and their currently assigned `ContextFlags`\\s
@@ -3498,6 +3636,14 @@ def most_recent_context(self):
     def most_recent_context(self, value):
         self._most_recent_context = value
 
+    @property
+    def _model_spec_parameter_blacklist(self):
+        """
+            A set of Parameter names that should not be added to the generated
+            constructor string
+        """
+        return {'function', 'value'}
+
 
 COMPONENT_BASE_CLASS = Component
 
diff --git a/psyneulink/core/components/functions/combinationfunctions.py b/psyneulink/core/components/functions/combinationfunctions.py
index 2244ef5a3ab..67c547671e8 100644
--- a/psyneulink/core/components/functions/combinationfunctions.py
+++ b/psyneulink/core/components/functions/combinationfunctions.py
@@ -77,7 +77,7 @@ class Parameters(Function_Base.Parameters):
 
         """
         # variable = np.array([0, 0])
-        variable = Parameter(np.array([0]), read_only=True)
+        variable = Parameter(np.array([0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
 
     # IMPLEMENTATION NOTE: THESE SHOULD SHOULD BE REPLACED WITH ABC WHEN IMPLEMENTED
     def __init__(self, default_variable,
@@ -1974,7 +1974,7 @@ class Parameters(CombinationFunction.Parameters):
                     :type: float
 
         """
-        variable = np.array([[1], [1]])
+        variable = Parameter(np.array([[1], [1]]), pnl_internal=True, constructor_argument='default_variable')
         gamma = Parameter(1.0, modulable=True)
 
     paramClassDefaults = Function_Base.paramClassDefaults.copy()
diff --git a/psyneulink/core/components/functions/distributionfunctions.py b/psyneulink/core/components/functions/distributionfunctions.py
index c8e950e7e4e..bfd849ff109 100644
--- a/psyneulink/core/components/functions/distributionfunctions.py
+++ b/psyneulink/core/components/functions/distributionfunctions.py
@@ -291,7 +291,7 @@ class Parameters(DistributionFunction.Parameters):
                     :type: float
 
         """
-        variable = Parameter(np.array([0]), read_only=True)
+        variable = Parameter(np.array([0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         mean = Parameter(0.0, modulable=True, aliases=[ADDITIVE_PARAM])
         standard_deviation = Parameter(1.0, modulable=True, aliases=[MULTIPLICATIVE_PARAM])
 
diff --git a/psyneulink/core/components/functions/function.py b/psyneulink/core/components/functions/function.py
index dcf72eb0d25..1dd09bde594 100644
--- a/psyneulink/core/components/functions/function.py
+++ b/psyneulink/core/components/functions/function.py
@@ -442,6 +442,8 @@ class Function_Base(Function):
 
     classPreferenceLevel = PreferenceLevel.CATEGORY
 
+    _model_spec_id_parameters = 'args'
+
     class Parameters(Function.Parameters):
         """
             Attributes
@@ -455,7 +457,7 @@ class Parameters(Function.Parameters):
                     :read only: True
 
         """
-        variable = Parameter(np.array([0]), read_only=True)
+        variable = Parameter(np.array([0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
 
     # Note: the following enforce encoding as 1D np.ndarrays (one array per variable)
     variableEncodingDim = 1
@@ -509,7 +511,7 @@ def __init__(self,
                          function=function,
                          param_defaults=params,
                          name=name,
-                         prefs=prefs)
+                            prefs=prefs)
 
     def __call__(self, *args, **kwargs):
         return self.function(*args, **kwargs)
@@ -702,6 +704,12 @@ def _is_identity(self, context=None):
         # Used to bypass execute when unnecessary
         return False
 
+    @property
+    def _model_spec_parameter_blacklist(self):
+        return super()._model_spec_parameter_blacklist.union({
+            'multiplicative_param', 'additive_param',
+        })
+
 # *****************************************   EXAMPLE FUNCTION   *******************************************************
 
 PROPENSITY = "PROPENSITY"
@@ -954,7 +962,7 @@ class Parameters(Function_Base.Parameters):
                     :read only: True
 
         """
-        variable = None
+        variable = Parameter(None, pnl_internal=True, constructor_argument='default_variable')
 
     classPreferences = {
         PREFERENCE_SET_NAME: 'ValueFunctionCustomClassPreferences',
diff --git a/psyneulink/core/components/functions/learningfunctions.py b/psyneulink/core/components/functions/learningfunctions.py
index 40de9c18c89..0cd9b9bef4e 100644
--- a/psyneulink/core/components/functions/learningfunctions.py
+++ b/psyneulink/core/components/functions/learningfunctions.py
@@ -134,7 +134,7 @@ class Parameters(Function_Base.Parameters):
                     :type: float
 
         """
-        variable = Parameter(np.array([0, 0, 0]), read_only=True)
+        variable = Parameter(np.array([0, 0, 0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         learning_rate = Parameter(0.05, modulable=True)
 
     def _validate_learning_rate(self, learning_rate, type=None):
@@ -405,8 +405,8 @@ class Parameters(LearningFunction.Parameters):
                     :type: int
 
         """
-        variable = Parameter([np.array([0, 0, 0]), np.array([0])], read_only=True)
-        value = Parameter(np.array([0]), read_only=True, aliases=['sample_weights'])
+        variable = Parameter([np.array([0, 0, 0]), np.array([0])], read_only=True, pnl_internal=True, constructor_argument='default_variable')
+        value = Parameter(np.array([0]), read_only=True, aliases=['sample_weights'], pnl_internal=True)
 
         Lambda_0 = 0
         Lambda_prior = 0
@@ -732,7 +732,7 @@ class Parameters(LearningFunction.Parameters):
                     :type: str
 
         """
-        variable = Parameter([[0, 0], [0, 0], [[0, 0], [0, 0]]], read_only=True)
+        variable = Parameter([[0, 0], [0, 0], np.array([[0, 0], [0, 0]])], read_only=True, pnl_internal=True, constructor_argument='default_variable')
         distance_function = Parameter(GAUSSIAN, stateful=False)
 
         def _validate_distance_function(self, distance_function):
@@ -1012,7 +1012,7 @@ class Parameters(LearningFunction.Parameters):
                     :type: float
 
         """
-        variable = Parameter(np.array([0, 0]), read_only=True)
+        variable = Parameter(np.array([0, 0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         learning_rate = Parameter(0.05, modulable=True)
     default_learning_rate = 0.05
     paramClassDefaults = Function_Base.paramClassDefaults.copy()
@@ -1244,7 +1244,7 @@ class Parameters(LearningFunction.Parameters):
                     :read only: True
 
         """
-        variable = Parameter(np.array([0, 0]), read_only=True)
+        variable = Parameter(np.array([0, 0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
 
     default_learning_rate = 0.05
 
@@ -1532,7 +1532,7 @@ class Parameters(LearningFunction.Parameters):
                     :read only: True
 
         """
-        variable = Parameter(np.array([[0], [0], [0]]), read_only=True)
+        variable = Parameter(np.array([[0], [0], [0]]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         activation_input = Parameter([0], read_only=True, getter=_activation_input_getter)
         activation_output = Parameter([0], read_only=True, getter=_activation_output_getter)
         error_signal = Parameter([0], read_only=True, getter=_error_signal_getter)
@@ -1874,7 +1874,7 @@ class Parameters(LearningFunction.Parameters):
                     :type: float
 
         """
-        variable = Parameter(np.array([[0], [0], [0]]), read_only=True)
+        variable = Parameter(np.array([[0], [0], [0]]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         learning_rate = Parameter(1.0, modulable=True)
 
         activation_input = Parameter([0], read_only=True, getter=_activation_input_getter)
diff --git a/psyneulink/core/components/functions/objectivefunctions.py b/psyneulink/core/components/functions/objectivefunctions.py
index 15923fbd70a..bb77b7865f7 100644
--- a/psyneulink/core/components/functions/objectivefunctions.py
+++ b/psyneulink/core/components/functions/objectivefunctions.py
@@ -37,7 +37,7 @@
     NORMED_L0_SIMILARITY, OBJECTIVE_FUNCTION_TYPE, SIZE, STABILITY_FUNCTION
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.globals.preferences.basepreferenceset import is_pref_set
-from psyneulink.core.globals.utilities import is_distance_metric
+from psyneulink.core.globals.utilities import is_distance_metric, safe_len
 from psyneulink.core.globals.utilities import is_iterable
 
 
@@ -334,12 +334,17 @@ def _instantiate_attributes_before_function(self, function=None, context=None):
         :param function:
 
         """
-
-        size = len(self.defaults.variable)
-
         from psyneulink.core.components.projections.pathway.mappingprojection import MappingProjection
         from psyneulink.core.components.states.parameterstate import ParameterState
 
+        # this mirrors the transformation in _function
+        # it is a hack, and a general solution should be found
+        squeezed = np.array(self.defaults.variable)
+        if squeezed.ndim > 1:
+            squeezed = np.squeeze(squeezed)
+
+        size = safe_len(squeezed)
+
         matrix = self.parameters.matrix._get(context)
 
         if isinstance(matrix, MappingProjection):
@@ -365,6 +370,32 @@ def _instantiate_attributes_before_function(self, function=None, context=None):
         #FIXME: This is a hack to make sure metric-fct param is set
         self.parameters.metric_fct.set(self.metric_fct)
 
+    def _update_default_variable(self, new_default_variable, context):
+        from psyneulink.core.components.projections.pathway.mappingprojection import MappingProjection
+        from psyneulink.core.components.states.parameterstate import ParameterState
+
+        # this mirrors the transformation in _function
+        # it is a hack, and a general solution should be found
+        squeezed = np.array(new_default_variable)
+        if squeezed.ndim > 1:
+            squeezed = np.squeeze(squeezed)
+
+        size = safe_len(squeezed)
+        matrix = self.parameters.matrix._get(context)
+
+        if isinstance(matrix, MappingProjection):
+            matrix = matrix._parameter_states[MATRIX]
+        elif isinstance(matrix, ParameterState):
+            pass
+        else:
+            matrix = get_matrix(self.defaults.matrix, size, size)
+
+        self.parameters.matrix._set(matrix, context)
+
+        self._hollow_matrix = get_matrix(HOLLOW_MATRIX, size, size)
+
+        super()._update_default_variable(new_default_variable, context)
+
     def _gen_llvm_function_body(self, ctx, builder, params, state, arg_in, arg_out):
         # Dot product
         dot_out = builder.alloca(arg_in.type.pointee)
@@ -744,7 +775,7 @@ class Parameters(ObjectiveFunction.Parameters):
                     :type: str
 
         """
-        variable = Parameter(np.array([[0], [0]]), read_only=True)
+        variable = Parameter(np.array([[0], [0]]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         metric = Parameter(DIFFERENCE, stateful=False)
 
     paramClassDefaults = Function_Base.paramClassDefaults.copy()
diff --git a/psyneulink/core/components/functions/optimizationfunctions.py b/psyneulink/core/components/functions/optimizationfunctions.py
index 47ebb878d72..5c528315a2d 100644
--- a/psyneulink/core/components/functions/optimizationfunctions.py
+++ b/psyneulink/core/components/functions/optimizationfunctions.py
@@ -23,6 +23,8 @@
 """
 
 import warnings
+import random
+import sys
 # from fractions import Fraction
 import itertools
 import numpy as np
@@ -45,6 +47,7 @@
 import contextlib
 
 __all__ = ['OptimizationFunction', 'GradientOptimization', 'GridSearch', 'GaussianProcess',
+           'ParamEstimationFunction',
            'OBJECTIVE_FUNCTION', 'SEARCH_FUNCTION', 'SEARCH_SPACE', 'SEARCH_TERMINATION_FUNCTION',
            'DIRECTION', 'ASCENT', 'DESCENT', 'MAXIMIZE', 'MINIMIZE']
 
@@ -319,21 +322,21 @@ class Parameters(Function_Base.Parameters):
                     :type: <class 'function'>
 
         """
-        variable = Parameter(np.array([0, 0, 0]), read_only=True)
+        variable = Parameter(np.array([0, 0, 0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
 
         objective_function = Parameter(lambda x: 0, stateful=False, loggable=False)
         search_function = Parameter(lambda x: x, stateful=False, loggable=False)
         search_termination_function = Parameter(lambda x, y, z: True, stateful=False, loggable=False)
         search_space = Parameter([SampleIterator([0])], stateful=False, loggable=False)
 
-        save_samples = False
-        save_values = False
+        save_samples = Parameter(False, pnl_internal=True)
+        save_values = Parameter(False, pnl_internal=True)
 
         # these are created as parameter states, but should they be?
         max_iterations = Parameter(None, modulable=True)
 
-        saved_samples = Parameter([], read_only=True)
-        saved_values = Parameter([], read_only=True)
+        saved_samples = Parameter([], read_only=True, pnl_internal=True)
+        saved_values = Parameter([], read_only=True, pnl_internal=True)
 
     @tc.typecheck
     def __init__(self,
@@ -830,11 +833,11 @@ class Parameters(OptimizationFunction.Parameters):
                     :type: float
 
         """
-        variable = Parameter([[0], [0]], read_only=True)
+        variable = Parameter([[0], [0]], read_only=True, pnl_internal=True, constructor_argument='default_variable')
 
         # these should be removed and use switched to .get_previous()
-        previous_variable = Parameter([[0], [0]], read_only=True)
-        previous_value = Parameter([[0], [0]], read_only=True)
+        previous_variable = Parameter([[0], [0]], read_only=True, pnl_internal=True, constructor_argument='default_variable')
+        previous_value = Parameter([[0], [0]], read_only=True, pnl_internal=True)
 
         gradient_function = Parameter(None, stateful=False, loggable=False)
         step_size = Parameter(1.0, modulable=True)
@@ -843,7 +846,7 @@ class Parameters(OptimizationFunction.Parameters):
         max_iterations = Parameter(1000, modulable=True)
 
         direction = ASCENT
-        convergence_criterion = VALUE
+        convergence_criterion = Parameter(VALUE, pnl_internal=True)
 
     paramClassDefaults = Function_Base.paramClassDefaults.copy()
 
@@ -1243,9 +1246,9 @@ class Parameters(OptimizationFunction.Parameters):
 
         """
         grid = Parameter(None)
-        save_samples = True
-        save_values = True
-        random_state = Parameter(None, modulable=False, stateful=True)
+        save_samples = Parameter(True, pnl_internal=True)
+        save_values = Parameter(True, pnl_internal=True)
+        random_state = Parameter(None, modulable=False, stateful=True, pnl_internal=True)
 
         direction = MAXIMIZE
 
@@ -1282,7 +1285,7 @@ def __init__(self,
 
         if seed is None:
             seed = get_global_seed()
-        random_state = np.random.RandomState(np.asarray([seed]))
+        random_state = np.random.RandomState([seed])
 
         # Assign args to params and functionParams dicts
         params = self._assign_args_to_param_dicts(params=params,
@@ -1742,8 +1745,7 @@ def _traverse_grid(self, variable, sample_num, context=None):
         """Get next sample from grid.
         This is assigned as the `search_function <OptimizationFunction.search_function>` of the `OptimizationFunction`.
         """
-        initialization_status = self.initialization_status
-        if initialization_status == ContextFlags.INITIALIZING:
+        if self.is_initializing:
             return [signal.start for signal in self.search_space]
         try:
             sample = next(self.grid)
@@ -1909,7 +1911,7 @@ class Parameters(OptimizationFunction.Parameters):
                     :type: bool
 
         """
-        variable = Parameter([[0], [0]], read_only=True)
+        variable = Parameter([[0], [0]], read_only=True, pnl_internal=True, constructor_argument='default_variable')
 
         save_samples = True
         save_values = True
@@ -2055,3 +2057,394 @@ def _gaussian_process_satisfied(self, variable, value, iteration, context=None):
         # FRED: YOUR CODE HERE;    THIS IS THE search_termination_function METHOD OF OptimizationControlMechanism (
         # i.e., PARENT)
         return iteration==2# [BOOLEAN, SPECIFIYING WHETHER TO END THE SEARCH/SAMPLING PROCESS]
+
+
+class ParamEstimationFunction(OptimizationFunction):
+    """
+    ParamEstimationFunction(                 \
+        default_variable=None,       \
+        objective_function=None,     \
+        direction=MAXIMIZE,          \
+        max_iterations=1000,         \
+        save_samples=False,          \
+        save_values=False,           \
+        params=None,                 \
+        owner=None,                  \
+        prefs=None                   \
+        )
+
+    Use likelihood free inference to estimate values of parameters for a composition
+    so that it best matches some provided ground truth data.
+
+    Arguments
+    ---------
+
+    default_variable : list or ndarray : default None
+        specifies a template for (i.e., an example of the shape of) the samples used to evaluate the
+        `objective_function <ParamEstimationFunction.objective_function>`.
+
+    objective_function : function or method
+        specifies function used to evaluate sample in each iteration of the `optimization process
+        <ParamEstimationFunction_Procedure>`; it must be specified and must return a scalar value.
+
+    search_space : list or array
+        specifies bounds of the samples used to evaluate `objective_function <ParamEstimationFunction.objective_function>`
+        along each dimension of `variable <ParamEstimationFunction.variable>`;  each item must be a tuple the first element
+        of which specifies the lower bound and the second of which specifies the upper bound.
+
+    direction : MAXIMIZE or MINIMIZE : default MAXIMIZE
+        specifies the direction of optimization:  if *MAXIMIZE*, the highest value of `objective_function
+        <ParamEstimationFunction.objective_function>` is sought;  if *MINIMIZE*, the lowest value is sought.
+
+    max_iterations : int : default 1000
+        specifies the maximum number of times the `optimization process<ParamEstimationFunction_Procedure>` is allowed to
+        iterate; if exceeded, a warning is issued and the function returns the optimal sample of those evaluated.
+
+    save_samples : bool
+        specifies whether or not to return all of the samples used to evaluate `objective_function
+        <ParamEstimationFunction.objective_function>` in the `optimization process <ParamEstimationFunction_Procedure>`
+        (i.e., a copy of the `search_space <ParamEstimationFunction.search_space>`.
+
+    save_values : bool
+        specifies whether or not to save and return the values of `objective_function <ParamEstimationFunction.objective_function>`
+        for all samples evaluated in the `optimization process <ParamEstimationFunction_Procedure>`.
+
+    Attributes
+    ----------
+
+    variable : ndarray
+        template for sample evaluated by `objective_function <ParamEstimationFunction.objective_function>`.
+
+    objective_function : function or method
+        function used to evaluate sample in each iteration of the `optimization process <ParamEstimationFunction_Procedure>`.
+
+    search_space : list or array
+        contains tuples specifying bounds within which each dimension of `variable <ParamEstimationFunction.variable>` is
+        sampled, and used to evaluate `objective_function <ParamEstimationFunction.objective_function>` in iterations of the
+        `optimization process <ParamEstimationFunction_Procedure>`.
+
+    direction : MAXIMIZE or MINIMIZE : default MAXIMIZE
+        determines the direction of optimization:  if *MAXIMIZE*, the greatest value of `objective_function
+        <ParamEstimationFunction.objective_function>` is sought;  if *MINIMIZE*, the least value is sought.
+
+    iteration : int
+        the currention iteration of the `optimization process <ParamEstimationFunction_Procedure>`.
+
+    max_iterations : int
+        determines the maximum number of times the `optimization process<ParamEstimationFunction_Procedure>` is allowed to iterate;
+        if exceeded, a warning is issued and the function returns the optimal sample of those evaluated.
+
+    save_samples : True
+        determines whether or not to save and return all samples evaluated by the `objective_function
+        <ParamEstimationFunction.objective_function>` in the `optimization process <ParamEstimationFunction_Procedure>` (if the process
+        completes, this should be identical to `search_space <ParamEstimationFunction.search_space>`.
+
+    save_values : bool
+        determines whether or not to save and return the value of `objective_function
+        <ParamEstimationFunction.objective_function>` for all samples evaluated in the `optimization process <ParamEstimationFunction_Procedure>`.
+    """
+
+    componentName = "ParamEstimationFunction"
+
+    class Parameters(OptimizationFunction.Parameters):
+        """
+            Attributes
+            ----------
+
+                variable
+                    see `variable <ParamEstimationFunction.variable>`
+
+                    :default value: [[0], [0]]
+                    :type: list
+                    :read only: True
+
+                direction
+                    see `direction <ParamEstimationFunction.direction>`
+
+                    :default value: `MAXIMIZE`
+                    :type: str
+
+                save_samples
+                    see `save_samples <ParamEstimationFunction.save_samples>`
+
+                    :default value: True
+                    :type: bool
+
+                save_values
+                    see `save_values <ParamEstimationFunction.save_values>`
+
+                    :default value: True
+                    :type: bool
+
+        """
+        variable = Parameter([[0], [0]], read_only=True)
+        save_samples = True
+        save_values = True
+
+    paramClassDefaults = Function_Base.paramClassDefaults.copy()
+
+    @tc.typecheck
+    def __init__(self,
+                 priors,
+                 observed,
+                 summary,
+                 discrepancy,
+                 n_samples,
+                 threshold=None,
+                 quantile=None,
+                 n_sim=None,
+                 seed=None,
+                 default_variable=None,
+                 objective_function:tc.optional(is_function_type)=None,
+                 search_space=None,
+                 params=None,
+                 owner=None,
+                 prefs=None,
+                 **kwargs):
+
+        # Setup all the arguments we will need to feed to
+        # ELFI later.
+        self._priors = priors
+        self._observed = observed
+        self._summary = summary
+        self._discrepancy = discrepancy
+        self._n_samples = n_samples
+        self._threshold = threshold
+        self._n_sim = n_sim
+        self._quantile = quantile
+        self._sampler_args = {'n_samples': self._n_samples,
+                              'threshold': self._threshold,
+                              'quantile': self._quantile,
+                              'n_sim': self._n_sim,
+                              'bar': False}
+
+        # If no seed is specified, generate a different random one for
+        # each instance
+        if seed is None:
+            self._seed = random.randrange(sys.maxsize)
+        else:
+            self._seed = seed
+
+        # Setup a RNG for our stuff, we will also pass the seed to ELFI for
+        # its crap.
+        self._rng = np.random.RandomState(seed=seed)
+
+        # Has the ELFI model been setup yet. Nope!
+        self._is_model_initialized = False
+
+        # The simulator function we will pass to ELFI, this is really the objective_function
+        # with some stuff wrapped around it to massage its return values and arguments.
+        self._sim_func = None
+
+        # Assign args to params and functionParams dicts
+        params = self._assign_args_to_param_dicts(params=params)
+
+        super().__init__(default_variable=default_variable,
+                         objective_function=objective_function,
+                         search_function=None,
+                         search_space=search_space,
+                         search_termination_function=None,
+                         save_samples=True,
+                         save_values=True,
+                         params=params,
+                         owner=owner,
+                         prefs=prefs,
+                         context=ContextFlags.CONSTRUCTOR)
+
+    @staticmethod
+    def _import_elfi():
+        """Import any need libraries needed for this classes opertation. Mainly ELFI"""
+
+        # ELFI imports matplotlib at the top level for some dumb reason. Matplotlib
+        # doesn't always play nice MacOS X backend. See example:
+        # https://github.com/scikit-optimize/scikit-optimize/issues/637
+        # Lets import and set the backend to PS to be safe. We aren't plotting anyway
+        # I guess. Only do this on Mac OS X
+        from sys import platform
+        if platform == "darwin":
+            import matplotlib
+            matplotlib.use('PS')
+
+        import elfi
+
+        return elfi
+
+    def _validate_params(self, request_set, target_set=None, context=None):
+        super()._validate_params(request_set=request_set, target_set=target_set,context=context)
+
+    def _make_simulator_function(self, context):
+
+        # If the objective function hasn't been setup yet, we can simulate anything.
+        if self.objective_function is None:
+            return None
+
+        # FIXME: All of the checks below are for initializing state, must be a better way
+        # Just because the objective_function is setup doesn't mean things are
+        # ready to go yet, we could be in initialization or something. Try to
+        # invoke it, if we get a TypeError, that means it is not the right
+        # function yet.
+        try:
+            # Call the objective_function and check its return type
+            zero_input = np.zeros(len(self.search_space))
+            ret = self.objective_function(zero_input,
+                                          context=context,
+                                          return_results=True)
+        except TypeError as ex:
+            return None
+
+        # This check is because the default return value for the default objective function
+        # is an int.
+        if type(ret) is int:
+            return None
+
+        # Things are ready, create a function for the simulator that invokes
+        # the objective function.
+        def simulator(*args, **kwargs):
+
+            # If kwargs None then the simulator has been called without keyword argumets.
+            # This means something has gone wrong because our arguments are the parameters
+            # (or control signals in PsyNeuLink lingo) we are trying to estimate.
+            if kwargs is None:
+                raise ValueError("No arguments passed to simulator!")
+
+            # Get the batch size and random state. ELFI passes these arguments around
+            # for controlling the number of simulation samples to generate (batch_size)
+            # and the numpy random state (random_state) to use during generation.
+            batch_size = kwargs.pop('batch_size', 1)
+            random_state = kwargs.pop('batch_size', None)
+
+            # Make sure we still have some arguments after popping ELFI's crap (batch_size, randon_state)
+            if not kwargs:
+                raise ValueError("No arguments passed to simulator!")
+
+            # The control signals (parameter values) of the composition are passed
+            # in as arguments. We must set these parameter values before running the
+            # simulation\composition. The order of the arguments is the same as the
+            # order for the control signals. So the simulator function will have the
+            # same argument order as the control signals as well. Note: this will not
+            # work in Python 3.5 because dict's have pseudo-random order.
+            control_allocation = args
+
+            # FIXME: This doesn't work at the moment. Need to use for loop below.
+            # The batch_size is the number of estimates/simulations, set it on the
+            # optimization control mechanism.
+            # self.owner.parameters.num_estimates.set(batch_size, execution_id)
+
+            # Run batch_size simulations of the PsyNeuLink composition
+            results = []
+            for i in range(batch_size):
+                net_outcome, result = self.objective_function(control_allocation,
+                                                           context=context,
+                                                           return_results=True)
+                results.append(result[0])
+
+            # Turn the list of simulation results into a 2D array of (batch_size, N)
+            results = np.stack(results, axis=0)
+
+            return results
+
+        return simulator
+
+    def _initialize_model(self, context):
+        """
+        Setup the ELFI model for sampling.
+
+        :param context: The current context, we need to pass this to
+        the objective function so it must be passed to our simulator function
+        implicitly.
+        :return: None
+        """
+
+        # If the model has not been initialized, try to do it.
+        if not self._is_model_initialized:
+
+            elfi = ParamEstimationFunction._import_elfi()
+
+            # Try to make the simulator function we will pass to ELFI, this will fail
+            # when we are in psyneulink intializaztion phases.
+            self._sim_func = self._make_simulator_function(context=context)
+
+            # If it did fail, we return early without initializing, hopefully next time.
+            if self._sim_func is None:
+                return
+
+            # FIXME: A lot of checking needs to happen, here. Correct order, valid elfi prior, etc.
+            # Construct the ELFI priors from the list of prior specifcations
+            elfi_priors = [elfi.Prior(*args, name=param_name) for param_name, args in self._priors.items()]
+
+            # Create the simulator, specifying the priors in proper order as arguments
+            Y = elfi.Simulator(self._sim_func, *elfi_priors, observed=self._observed)
+
+            agent_rep_node = elfi.Constant(self.owner.agent_rep)
+
+            # FIXME: This is a hack, we need to figure out a way to elegantly pass these
+            # Create the summary nodes
+            summary_nodes = [elfi.Summary(args[0], agent_rep_node, Y, *args[1:])
+                             for args in self._summary]
+
+            # Create the discrepancy node.
+            d = elfi.Distance('euclidean', *summary_nodes)
+
+            self._sampler = elfi.Rejection(d, batch_size=1, seed=self._seed)
+
+            # Mark that we are initialized
+            self._is_model_initialized = True
+
+    def function(self,
+                 variable=None,
+                 params=None,
+                 context=None,
+                 **kwargs):
+        """Return the sample that yields the optimal value of `objective_function <ParamEstimationFunction.objective_function>`,
+        and possibly all samples evaluated and their corresponding values.
+
+        Optimal value is defined by `direction <ParamEstimationFunction.direction>`:
+        - if *MAXIMIZE*, returns greatest value
+        - if *MINIMIZE*, returns least value
+
+        Returns
+        -------
+
+        optimal sample, optimal value, saved_samples, saved_values : ndarray, list, list
+            first array contains sample that yields the highest or lowest value of `objective_function
+            <ParamEstimationFunction.objective_function>`, depending on `direction <ParamEstimationFunction.direction>`, and the
+            second array contains the value of the function for that sample. If `save_samples
+            <ParamEstimationFunction.save_samples>` is `True`, first list contains all the values sampled in the order they were
+            evaluated; otherwise it is empty.  If `save_values <ParamEstimationFunction.save_values>` is `True`, second list
+            contains the values returned by `objective_function <ParamEstimationFunction.objective_function>` for all the
+            samples in the order they were evaluated; otherwise it is empty.
+        """
+
+        # Initialize the list of all samples and values
+        return_all_samples = return_all_values = []
+
+        # Intialize the optimial control allocation sample and value to zero.
+        return_optimal_sample = np.zeros(len(self.search_space))
+        return_optimal_value= 0.0
+
+        # Try to initialize the model if it hasn't been.
+        if not self._is_model_initialized:
+            self._initialize_model(context)
+
+        # Intialization can fail for reasons silenty, mainly that PsyNeuLink needs to
+        # invoke these functions multiple times during initialization. We only want
+        # to proceed if this is the real deal.
+        if not self._is_model_initialized:
+            return return_optimal_sample, return_optimal_value, return_all_samples, return_all_values
+
+        # Run the sampler
+        result = self._sampler.sample(**self._sampler_args)
+
+        # We now have a set of N samples, where N should be n_samples. This
+        # is the N samples that represent the self._quantile from the total
+        # number of simulations. N is not the total number of simulation
+        # samples. We will return a random sample from this set for the
+        # "optimal" control allocation.
+        sample_idx = self._rng.randint(low=0, high=result.n_samples)
+        return_optimal_sample = np.array(result.samples_array[sample_idx])
+        return_optimal_value = result.discrepancies[sample_idx]
+        return_all_samples = np.array(result.samples_array)
+        return_all_values = np.array(result.discrepancies)
+
+        print(result)
+        return return_optimal_sample, return_optimal_value, return_all_samples, return_all_values
diff --git a/psyneulink/core/components/functions/selectionfunctions.py b/psyneulink/core/components/functions/selectionfunctions.py
index 40cbbaa8faa..126f66c7f60 100644
--- a/psyneulink/core/components/functions/selectionfunctions.py
+++ b/psyneulink/core/components/functions/selectionfunctions.py
@@ -217,7 +217,7 @@ class Parameters(SelectionFunction.Parameters):
 
         """
         mode = Parameter(MAX_VAL, stateful=False)
-        random_state = Parameter(None, stateful=True)
+        random_state = Parameter(None, stateful=True, pnl_internal=True)
 
         def _validate_mode(self, mode):
             options = {MAX_VAL, MAX_ABS_VAL, MAX_INDICATOR, MAX_ABS_INDICATOR,
@@ -244,7 +244,7 @@ def __init__(self,
         if seed is None:
             seed = get_global_seed()
 
-        random_state = np.random.RandomState(np.asarray([seed]))
+        random_state = np.random.RandomState([seed])
         if not hasattr(self, "stateful_attributes"):
             self.stateful_attributes = ["random_state"]
 
diff --git a/psyneulink/core/components/functions/statefulfunctions/integratorfunctions.py b/psyneulink/core/components/functions/statefulfunctions/integratorfunctions.py
index 806edf2c52c..24aef2a23ca 100644
--- a/psyneulink/core/components/functions/statefulfunctions/integratorfunctions.py
+++ b/psyneulink/core/components/functions/statefulfunctions/integratorfunctions.py
@@ -208,8 +208,8 @@ class Parameters(StatefulFunction.Parameters):
         """
         rate = Parameter(1.0, modulable=True, function_arg=True)
         noise = Parameter(0.0, modulable=True, function_arg=True)
-        previous_value = np.array([0])
-        initializer = np.array([0])
+        previous_value = Parameter(np.array([0]), pnl_internal=True)
+        initializer = Parameter(np.array([0]), pnl_internal=True)
 
     paramClassDefaults = StatefulFunction.paramClassDefaults.copy()
 
@@ -1543,8 +1543,8 @@ class Parameters(IntegratorFunction.Parameters):
         long_term_rate = Parameter(0.1, modulable=True, function_arg=True)
         operation = PRODUCT
         offset = Parameter(0.0, modulable=True, aliases=[ADDITIVE_PARAM], function_arg=True)
-        previous_short_term_avg = None
-        previous_long_term_avg = None
+        previous_short_term_avg = Parameter(None, pnl_internal=True)
+        previous_long_term_avg = Parameter(None, pnl_internal=True)
         short_term_logistic = None
         long_term_logistic = None
 
@@ -2405,7 +2405,7 @@ class Parameters(IntegratorFunction.Parameters):
         starting_point = 0.0
         threshold = Parameter(100.0, modulable=True)
         time_step_size = Parameter(1.0, modulable=True)
-        previous_time = None
+        previous_time = Parameter(None, pnl_internal=True)
 
     paramClassDefaults = Function_Base.paramClassDefaults.copy()
     paramClassDefaults.update({
@@ -2753,7 +2753,7 @@ class Parameters(IntegratorFunction.Parameters):
         offset = Parameter(0.0, modulable=True, aliases=[ADDITIVE_PARAM])
         time_step_size = Parameter(1.0, modulable=True)
         starting_point = 0.0
-        previous_time = 0.0
+        previous_time = Parameter(0.0, pnl_internal=True)
 
     paramClassDefaults = Function_Base.paramClassDefaults.copy()
     paramClassDefaults.update({
@@ -3640,7 +3640,7 @@ class Parameters(IntegratorFunction.Parameters):
                     :type: float
 
         """
-        variable = Parameter(np.array([1.0]), read_only=True)
+        variable = Parameter(np.array([1.0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         time_step_size = Parameter(0.05, modulable=True)
         a_v = Parameter(1.0 / 3, modulable=True)
         b_v = Parameter(0.0, modulable=True)
@@ -3663,9 +3663,9 @@ class Parameters(IntegratorFunction.Parameters):
         initial_w = np.array([1.0])
         initial_v = np.array([1.0])
         t_0 = 0.0
-        previous_w = np.array([1.0])
-        previous_v = np.array([1.0])
-        previous_time = 0.0
+        previous_w = Parameter(np.array([1.0]), pnl_internal=True)
+        previous_v = Parameter(np.array([1.0]), pnl_internal=True)
+        previous_time = Parameter(0.0, pnl_internal=True)
 
     paramClassDefaults = Function_Base.paramClassDefaults.copy()
     paramClassDefaults.update({
diff --git a/psyneulink/core/components/functions/statefulfunctions/memoryfunctions.py b/psyneulink/core/components/functions/statefulfunctions/memoryfunctions.py
index b6f7136dc57..4cd15029393 100644
--- a/psyneulink/core/components/functions/statefulfunctions/memoryfunctions.py
+++ b/psyneulink/core/components/functions/statefulfunctions/memoryfunctions.py
@@ -328,7 +328,7 @@ def _function(self,
         if self.is_initializing:
             return variable
 
-        previous_value = np.array(self.get_previous_value(context))
+        previous_value = self.get_previous_value(context)
 
         # Apply rate and/or noise, if they are specified, to all stored items
         if len(previous_value):
@@ -670,7 +670,7 @@ class Parameters(StatefulFunction.Parameters):
                     :type: int
 
         """
-        variable = Parameter([[0],[0]])
+        variable = Parameter([[0],[0]], pnl_internal=True, constructor_argument='default_variable')
         retrieval_prob = Parameter(1.0, modulable=True)
         storage_prob = Parameter(1.0, modulable=True, aliases=[MULTIPLICATIVE_PARAM])
         key_size = Parameter(1, stateful=True)
@@ -680,7 +680,7 @@ class Parameters(StatefulFunction.Parameters):
         rate = Parameter(1.0, modulable=True)
         noise = Parameter(0.0, modulable=True, aliases=[ADDITIVE_PARAM])
         max_entries = Parameter(1000)
-        random_state = Parameter(None, modulable=False, stateful=True)
+        random_state = Parameter(None, modulable=False, stateful=True, pnl_internal=True)
 
         distance_function = Parameter(Distance(metric=COSINE), stateful=False, loggable=False)
         selection_function = Parameter(OneHot(mode=MIN_INDICATOR), stateful=False, loggable=False)
@@ -717,7 +717,7 @@ def __init__(self,
 
         if seed is None:
             seed = get_global_seed()
-        random_state = np.random.RandomState(np.asarray([seed]))
+        random_state = np.random.RandomState([seed])
 
         self._memory = []
 
diff --git a/psyneulink/core/components/functions/statefulfunctions/statefulfunction.py b/psyneulink/core/components/functions/statefulfunctions/statefulfunction.py
index b41b679d535..372e7b12f12 100644
--- a/psyneulink/core/components/functions/statefulfunctions/statefulfunction.py
+++ b/psyneulink/core/components/functions/statefulfunctions/statefulfunction.py
@@ -193,8 +193,8 @@ class Parameters(Function_Base.Parameters):
         """
         noise = Parameter(0.0, modulable=True)
         rate = Parameter(1.0, modulable=True)
-        previous_value = np.array([0])
-        initializer = np.array([0])
+        previous_value = Parameter(np.array([0]), pnl_internal=True)
+        initializer = Parameter(np.array([0]), pnl_internal=True)
 
     paramClassDefaults = Function_Base.paramClassDefaults.copy()
     paramClassDefaults.update({
diff --git a/psyneulink/core/components/functions/transferfunctions.py b/psyneulink/core/components/functions/transferfunctions.py
index 7ebeb325561..6bd0897ad90 100644
--- a/psyneulink/core/components/functions/transferfunctions.py
+++ b/psyneulink/core/components/functions/transferfunctions.py
@@ -397,6 +397,8 @@ class Linear(TransferFunction):  # ---------------------------------------------
         REPORT_OUTPUT_PREF: PreferenceEntry(False, PreferenceLevel.INSTANCE),
     }
 
+    _model_spec_class_name_is_generic = True
+
     class Parameters(TransferFunction.Parameters):
         """
             Attributes
@@ -907,6 +909,8 @@ class Logistic(TransferFunction):  # -------------------------------------------
 
     paramClassDefaults = Function_Base.paramClassDefaults.copy()
 
+    _model_spec_class_name_is_generic = True
+
     class Parameters(TransferFunction.Parameters):
         """
             Attributes
@@ -2003,7 +2007,7 @@ class Parameters(TransferFunction.Parameters):
         bias = Parameter(0.0, modulable=True, aliases=[ADDITIVE_PARAM])
         scale = Parameter(0.0, modulable=True)
         offset = Parameter(0.0, modulable=True)
-        random_state = Parameter(None, modulable=False)
+        random_state = Parameter(None, modulable=False, pnl_internal=True)
 
     @tc.typecheck
     def __init__(self,
@@ -2020,7 +2024,7 @@ def __init__(self,
         if seed is None:
             seed = get_global_seed()
 
-        random_state = np.random.RandomState(np.asarray([seed]))
+        random_state = np.random.RandomState([seed])
         if not hasattr(self, "stateful_attributes"):
             self.stateful_attributes = ["random_state"]
 
@@ -2283,11 +2287,11 @@ class Parameters(TransferFunction.Parameters):
                     :type: bool
 
         """
-        variable = Parameter(np.array(0.0), read_only=True)
+        variable = Parameter(np.array(0.0), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         gain = Parameter(1.0, modulable=True, aliases=[MULTIPLICATIVE_PARAM])
         bounds = (0, 1)
         output = ALL
-        per_item = True
+        per_item = Parameter(True, pnl_internal=True)
 
         def _validate_output(self, output):
             options = {ALL, MAX_VAL, MAX_INDICATOR, PROB}
@@ -2750,8 +2754,7 @@ def _validate_params(self, request_set, target_set=None, context=None):
         # proxy for checking whether the owner is a projection
         if hasattr(self.owner, "receiver"):
             sender = self.defaults.variable
-            # Note: this assumes variable is a 1D array, as enforced by _validate_variable
-            sender_len = sender.size
+            sender_len = np.size(np.atleast_2d(self.defaults.variable), 1)
 
             # FIX: RELABEL sender -> input AND receiver -> output
             # FIX: THIS NEEDS TO BE CLEANED UP:
@@ -3780,7 +3783,7 @@ class Parameters(TransferFunction.Parameters):
         _validate_cost_functions = get_validator_by_type_only([CostFunctions, list])
 
         # Create versions of cost functions' modulation params for TransferWithCosts
-        
+
         intensity_cost = None
         intensity_cost_fct = Parameter(Exponential, stateful=False)
         _validate_intensity_cost_fct = get_validator_by_function(is_function_type)
diff --git a/psyneulink/core/components/mechanisms/mechanism.py b/psyneulink/core/components/mechanisms/mechanism.py
index f612b4837da..0b4e4f38370 100644
--- a/psyneulink/core/components/mechanisms/mechanism.py
+++ b/psyneulink/core/components/mechanisms/mechanism.py
@@ -952,7 +952,7 @@ class `UserList <https://docs.python.org/3.6/library/collections.html?highlight=
 from psyneulink.core.components.states.modulatorysignals.modulatorysignal import _is_modulatory_spec
 from psyneulink.core.components.states.outputstate import OutputState
 from psyneulink.core.components.states.parameterstate import ParameterState
-from psyneulink.core.components.states.state import REMOVE_STATES, _parse_state_spec
+from psyneulink.core.components.states.state import REMOVE_STATES, STATE_SPEC, _parse_state_spec
 from psyneulink.core.globals.context import Context, ContextFlags, handle_external_context
 from psyneulink.core.globals.keywords import \
     ADDITIVE_PARAM, EXECUTION_PHASE, FUNCTION, FUNCTION_PARAMS, \
@@ -961,13 +961,14 @@ class `UserList <https://docs.python.org/3.6/library/collections.html?highlight=
     MONITOR_FOR_CONTROL, MONITOR_FOR_LEARNING, MULTIPLICATIVE_PARAM, \
     OUTPUT_LABELS_DICT, OUTPUT_STATE, OUTPUT_STATES, OWNER_EXECUTION_COUNT, OWNER_EXECUTION_TIME, OWNER_VALUE, \
     PARAMETER_STATE, PARAMETER_STATES, PREVIOUS_VALUE, PROJECTIONS, REFERENCE_VALUE, \
-    TARGET_LABELS_DICT, VALUE, VARIABLE, MECHANISM_COMPONENT_CATEGORY
+    TARGET_LABELS_DICT, VALUE, VARIABLE, MECHANISM_COMPONENT_CATEGORY, \
+    MODEL_SPEC_ID_INPUT_PORTS, MODEL_SPEC_ID_OUTPUT_PORTS, MECHANISM, WEIGHT, \
+    EXPONENT, NAME
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.scheduling.condition import Condition
 from psyneulink.core.globals.preferences.preferenceset import PreferenceLevel
 from psyneulink.core.globals.registry import register_category, remove_instance_from_registry
-from psyneulink.core.globals.utilities import ContentAddressableList, ReadOnlyOrderedDict, append_type_to_name, \
-    convert_to_np_array, iscompatible, kwCompatibilityNumeric
+from psyneulink.core.globals.utilities import ContentAddressableList, ReadOnlyOrderedDict, append_type_to_name, convert_to_np_array, copy_iterable_with_shared, iscompatible, kwCompatibilityNumeric
 
 __all__ = [
     'Mechanism_Base', 'MechanismError', 'MechanismRegistry'
@@ -1399,12 +1400,76 @@ class Parameters(Mechanism.Parameters):
                     :read only: True
 
         """
-        variable = Parameter(np.array([[0]]), read_only=True)
-        value = Parameter(np.array([[0]]), read_only=True)
-        previous_value = Parameter(None, read_only=True)
+        variable = Parameter(np.array([[0]]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
+        value = Parameter(np.array([[0]]), read_only=True, pnl_internal=True)
+        previous_value = Parameter(None, read_only=True, pnl_internal=True)
         function = Linear
 
-        input_state_variables = Parameter(None, read_only=True, user=False, getter=_input_state_variables_getter)
+        input_state_variables = Parameter(None, read_only=True, user=False, getter=_input_state_variables_getter, pnl_internal=True)
+
+        input_states_spec = Parameter(
+            None,
+            stateful=False,
+            loggable=False,
+            read_only=True,
+            user=False,
+            pnl_internal=True,
+            constructor_argument='input_states'
+        )
+
+        output_states_spec = Parameter(
+            None,
+            stateful=False,
+            loggable=False,
+            read_only=True,
+            user=False,
+            pnl_internal=True,
+            constructor_argument='output_states'
+        )
+
+        def _parse_input_states_spec(self, input_states_spec):
+            if input_states_spec is None:
+                return input_states_spec
+            elif not isinstance(input_states_spec, list):
+                input_states_spec = [input_states_spec]
+
+            spec_list = []
+
+            for state in input_states_spec:
+                # handle tuple specification only because it cannot
+                # be translated to and from JSON (converts to list, which is
+                # not accepted as a valid specification)
+                if isinstance(state, tuple):
+                    if len(state) == 2:
+                        spec = {
+                            NAME: state[0],
+                            MECHANISM: state[1]
+                        }
+                    elif len(state) > 2:
+                        try:
+                            # if state is assigned to an object,
+                            # use a reference instead of name/value
+                            state[0].owner
+                            spec = {STATE_SPEC: state[0]}
+                        except AttributeError:
+                            spec = {
+                                NAME: state[0].name,
+                                VALUE: state[0].defaults.value,
+                            }
+
+                        spec[WEIGHT] = state[1]
+                        spec[EXPONENT] = state[2]
+
+                        try:
+                            spec[PROJECTIONS] = [state[3]]
+                        except IndexError:
+                            pass
+
+                    spec_list.append(spec)
+                else:
+                    spec_list.append(state)
+
+            return spec_list
 
     # def __new__(cls, *args, **kwargs):
     # def __new__(cls, name=NotImplemented, params=NotImplemented, context=None):
@@ -1476,6 +1541,30 @@ def __init__(self,
 
         default_variable = self._handle_default_variable(default_variable, size, input_states, function, params)
 
+        try:
+            input_states_spec = (
+                copy_iterable_with_shared(input_states, shared_types=Component)
+                if input_states is not None
+                else None
+            )
+        except TypeError:
+            input_states_spec = input_states
+
+        try:
+            output_states_spec = (
+                copy_iterable_with_shared(output_states, shared_types=Component)
+                if output_states is not None
+                else None
+            )
+        except TypeError:
+            output_states_spec = output_states
+
+        params = self._assign_args_to_param_dicts(
+            params=params,
+            input_states_spec=input_states_spec,
+            output_states_spec=output_states_spec,
+        )
+
         super(Mechanism_Base, self).__init__(default_variable=default_variable,
                                              size=size,
                                              function=function,
@@ -1997,9 +2086,7 @@ def _instantiate_function(self, function, function_params=None, context=None):
             self.function.output_type = FunctionOutputType.NP_2D_ARRAY
             self.function.enable_output_type_conversion = True
 
-        self.function.initialization_status = ContextFlags.INITIALIZING
         self.function._instantiate_value(context)
-        self.function.initialization_status = ContextFlags.INITIALIZED
 
     def _instantiate_attributes_after_function(self, context=None):
         from psyneulink.core.components.states.parameterstate import _instantiate_parameter_state
@@ -3640,6 +3727,29 @@ def _dependent_components(self):
             self.parameter_states,
         ))
 
+    @property
+    def _dict_summary(self):
+        inputs_dict = {
+            MODEL_SPEC_ID_INPUT_PORTS: [
+                s._dict_summary for s in self.input_states
+            ]
+        }
+        inputs_dict[MODEL_SPEC_ID_INPUT_PORTS].extend(
+            [s._dict_summary for s in self.parameter_states]
+        )
+
+        outputs_dict = {
+            MODEL_SPEC_ID_OUTPUT_PORTS: [
+                s._dict_summary for s in self.output_states
+            ]
+        }
+
+        return {
+            **super()._dict_summary,
+            **inputs_dict,
+            **outputs_dict
+        }
+
 
 def _is_mechanism_spec(spec):
     """Evaluate whether spec is a valid Mechanism specification
diff --git a/psyneulink/core/components/mechanisms/modulatory/control/controlmechanism.py b/psyneulink/core/components/mechanisms/modulatory/control/controlmechanism.py
index bbf1e44d3b5..31c0f02fbde 100644
--- a/psyneulink/core/components/mechanisms/modulatory/control/controlmechanism.py
+++ b/psyneulink/core/components/mechanisms/modulatory/control/controlmechanism.py
@@ -563,6 +563,7 @@
 import typecheck as tc
 import warnings
 
+from psyneulink.core.components.component import Component
 from psyneulink.core import llvm as pnlvm
 from psyneulink.core.components.functions.function import Function_Base, is_function_type
 from psyneulink.core.components.functions.combinationfunctions import LinearCombination
@@ -580,14 +581,16 @@
     AUTO_ASSIGN_MATRIX, CONTROL, CONTROL_PROJECTION, CONTROL_PROJECTIONS, CONTROL_SIGNAL, CONTROL_SIGNALS, \
     EID_SIMULATION, GATING_SIGNAL, INIT_EXECUTE_METHOD_ONLY, \
     MODULATORY_SIGNALS, MONITOR_FOR_CONTROL, MONITOR_FOR_MODULATION, MULTIPLICATIVE, \
-    OBJECTIVE_MECHANISM, OUTCOME, OWNER_VALUE, PRODUCT, PROJECTION_TYPE, PROJECTIONS, STATE_TYPE, SYSTEM
+    OBJECTIVE_MECHANISM, OUTCOME, OWNER_VALUE, PRODUCT, PROJECTION_TYPE, PROJECTIONS, STATE_TYPE, SYSTEM, \
+    MECHANISM, MULTIPLICATIVE, NAME
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.globals.preferences.basepreferenceset import is_pref_set
 from psyneulink.core.globals.preferences.preferenceset import PreferenceLevel
-from psyneulink.core.globals.utilities import ContentAddressableList, is_iterable, convert_to_list
+from psyneulink.core.globals.utilities import ContentAddressableList, convert_to_list, copy_iterable_with_shared, is_iterable
 
 __all__ = [
-    'CONTROL_ALLOCATION', 'GATING_ALLOCATION', 'ControlMechanism', 'ControlMechanismError', 'ControlMechanismRegistry'
+    'CONTROL_ALLOCATION', 'GATING_ALLOCATION', 'ControlMechanism', 'ControlMechanismError', 'ControlMechanismRegistry',
+    'DefaultAllocationFunction'
 ]
 
 CONTROL_ALLOCATION = 'control_allocation'
@@ -1054,29 +1057,73 @@ class Parameters(ModulatoryMechanism_Base.Parameters):
 
         """
         # This must be a list, as there may be more than one (e.g., one per control_signal)
-        variable = np.array([[defaultControlAllocation]])
-        value = Parameter(np.array([[defaultControlAllocation]]), aliases='control_allocation')
+        variable = Parameter(np.array([[defaultControlAllocation]]), pnl_internal=True, constructor_argument='default_variable')
+        value = Parameter(np.array([defaultControlAllocation]), aliases='control_allocation', pnl_internal=True)
         default_allocation = None,
 
         combine_costs = Parameter(np.sum, stateful=False, loggable=False)
         costs = Parameter(None, read_only=True, getter=_control_mechanism_costs_getter)
-        control_signal_costs = Parameter(None, read_only=True)
+        control_signal_costs = Parameter(None, read_only=True, pnl_internal=True)
         compute_reconfiguration_cost = Parameter(None, stateful=False, loggable=False)
         reconfiguration_cost = Parameter(None, read_only=True)
-        outcome = Parameter(None, read_only=True, getter=_outcome_getter)
+        outcome = Parameter(None, read_only=True, getter=_outcome_getter, pnl_internal=True)
         compute_net_outcome = Parameter(lambda outcome, cost: outcome - cost, stateful=False, loggable=False)
-        net_outcome = Parameter(None, read_only=True,
-                                getter=_net_outcome_getter)
-        simulation_ids = Parameter([], user=False)
-        modulation = MULTIPLICATIVE
+        net_outcome = Parameter(
+            None,
+            read_only=True,
+            getter=_net_outcome_getter,
+            pnl_internal=True
+        )
+        simulation_ids = Parameter([], user=False, pnl_internal=True)
+        modulation = Parameter(MULTIPLICATIVE, pnl_internal=True)
 
         objective_mechanism = Parameter(None, stateful=False, loggable=False)
 
+        control_spec = Parameter(
+            None,
+            stateful=False,
+            loggable=False,
+            read_only=True,
+            user=False,
+            pnl_internal=True,
+            constructor_argument='control'
+        )
+
+        def _parse_control_spec(self, control_spec):
+            def is_2tuple(o):
+                return isinstance(o, tuple) and len(o) == 2
+
+            if not isinstance(control_spec, list):
+                control_spec = [control_spec]
+
+            for i in range(len(control_spec)):
+                # handle 2-item tuple
+                if is_2tuple(control_spec[i]):
+                    control_spec[i] = {
+                        NAME: control_spec[i][0],
+                        MECHANISM: control_spec[i][1]
+                    }
+                # handle dict of form {PROJECTIONS: <2 item tuple>, <param1>: <value1>, ...}
+                elif (
+                    isinstance(control_spec[i], dict)
+                    and PROJECTIONS in control_spec[i]
+                    and is_2tuple(control_spec[i][PROJECTIONS])
+                ):
+                    full_spec_dict = {
+                        NAME: control_spec[i][PROJECTIONS][0],
+                        MECHANISM: control_spec[i][PROJECTIONS][1],
+                        **{k: v for k, v in control_spec[i].items() if k != PROJECTIONS}
+                    }
+                    control_spec[i] = full_spec_dict
+
+            return control_spec
+
     paramClassDefaults = Mechanism_Base.paramClassDefaults.copy()
     paramClassDefaults.update({
         OBJECTIVE_MECHANISM: None,
         CONTROL_PROJECTIONS: None})
 
+
     @tc.typecheck
     def __init__(self,
                  default_variable=None,
@@ -1124,6 +1171,15 @@ def __init__(self,
         self.compute_net_outcome = compute_net_outcome
         self.compute_reconfiguration_cost = compute_reconfiguration_cost
 
+        try:
+            control_spec = (
+                copy_iterable_with_shared(control, shared_types=Component)
+                if control is not None
+                else None
+            )
+        except TypeError:
+            control_spec = control
+
         # Assign args to params and functionParams dicts
         params = self._assign_args_to_param_dicts(system=system,
                                                   monitor_for_control=monitor_for_control,
@@ -1132,6 +1188,7 @@ def __init__(self,
                                                   default_allocation=default_allocation,
                                                   control=control,
                                                   modulation=modulation,
+                                                  control_spec=control_spec,
                                                   params=params)
         self._sim_counts = {}
 
@@ -1466,7 +1523,7 @@ def _instantiate_control_signals(self, context):
                             f"of {self.name} ({control_signal.owner_value_index})is not an int."
 
     def _instantiate_control_signal(self,  control_signal, context=None):
-        """Parse and instantiate ControlSignal (or subclass relveant to ControlMechanism subclass)
+        """Parse and instantiate ControlSignal (or subclass relevant to ControlMechanism subclass)
 
         Temporarily assign variable to default allocation value to avoid chicken-and-egg problem:
            value, output_states and control_signals haven't been expanded yet to accomodate the new
@@ -1511,6 +1568,7 @@ def _instantiate_control_signal_type(self, control_signal_spec, context):
         from psyneulink.core.components.projections.projection import ProjectionError
 
         allocation_parameter_default = self.parameters.control_allocation.default_value
+
         control_signal = _instantiate_state(state_type=ControlSignal,
                                                owner=self,
                                                variable=self.default_allocation           # User specified value
diff --git a/psyneulink/core/components/mechanisms/modulatory/control/gating/gatingmechanism.py b/psyneulink/core/components/mechanisms/modulatory/control/gating/gatingmechanism.py
index e17e87f82c5..7c9f76f6d89 100644
--- a/psyneulink/core/components/mechanisms/modulatory/control/gating/gatingmechanism.py
+++ b/psyneulink/core/components/mechanisms/modulatory/control/gating/gatingmechanism.py
@@ -448,12 +448,14 @@ class Parameters(ControlMechanism.Parameters):
 
         """
         # This must be a list, as there may be more than one (e.g., one per control_signal)
-        value = Parameter(np.array([defaultGatingAllocation]), aliases='control_allocation')
-        gating_allocation = Parameter(np.array([defaultGatingAllocation]),
-                                      # aliases='control_allocation',  # Overrides ControlMechanism's Parameter
-                                      getter=_gating_allocation_getter,
-                                      setter=_gating_allocation_setter,
-                                      read_only=True)
+        value = Parameter(np.array([defaultGatingAllocation]), aliases='control_allocation', pnl_internal=True)
+        gating_allocation = Parameter(
+            np.array([defaultGatingAllocation]),
+            getter=_gating_allocation_getter,
+            setter=_gating_allocation_setter,
+            read_only=True,
+            pnl_internal=True
+        )
 
     @tc.typecheck
     def __init__(self,
diff --git a/psyneulink/core/components/mechanisms/modulatory/control/optimizationcontrolmechanism.py b/psyneulink/core/components/mechanisms/modulatory/control/optimizationcontrolmechanism.py
index 3e58bc3a619..f580a82d8e0 100644
--- a/psyneulink/core/components/mechanisms/modulatory/control/optimizationcontrolmechanism.py
+++ b/psyneulink/core/components/mechanisms/modulatory/control/optimizationcontrolmechanism.py
@@ -392,6 +392,7 @@
 
 from collections.abc import Iterable
 
+from psyneulink.core.components.component import DefaultsFlexibility
 from psyneulink.core.components.functions.function import is_function_type
 from psyneulink.core.components.functions.optimizationfunctions import \
     OBJECTIVE_FUNCTION, SEARCH_SPACE, OptimizationFunction
@@ -694,14 +695,14 @@ class Parameters(ControlMechanism.Parameters):
         feature_function = Parameter(None, stateful=False, loggable=False)
         search_function = Parameter(None, stateful=False, loggable=False)
         search_termination_function = Parameter(None, stateful=False, loggable=False)
-        comp_execution_mode = Parameter('Python', stateful=False, loggable=False)
+        comp_execution_mode = Parameter('Python', stateful=False, loggable=False, pnl_internal=True)
         search_statefulness = Parameter(True, stateful=False, loggable=False)
 
-        agent_rep = Parameter(None, stateful=False, loggable=False)
+        agent_rep = Parameter(None, stateful=False, loggable=False, pnl_internal=True)
 
-        feature_values = Parameter(_parse_feature_values_from_variable([defaultControlAllocation]), user=False)
+        feature_values = Parameter(_parse_feature_values_from_variable([defaultControlAllocation]), user=False, pnl_internal=True)
 
-        features = None
+        features = Parameter(None, pnl_internal=True)
         num_estimates = 1
         # search_space = None
         control_allocation_search_space = None
@@ -820,6 +821,18 @@ def _instantiate_control_signals(self, context):
         self.defaults.value = np.tile(control_signal.parameters.variable.default_value, (i+1, 1))
         self.parameters.control_allocation._set(copy.deepcopy(self.defaults.value), context)
 
+    def _instantiate_function(self, function, function_params=None, context=None):
+        # this indicates a significant peculiarity of OCM, in that its function
+        # corresponds to its value (control_allocation) rather than anything to
+        # do with its variable. see _instantiate_attributes_after_function
+
+        # Workaround this issue here, and explicitly allow the function's
+        # default variable to be modified
+        if isinstance(function, Function):
+            function._default_variable_flexibility = DefaultsFlexibility.FLEXIBLE
+
+        super()._instantiate_function(function, function_params, context)
+
     def _instantiate_attributes_after_function(self, context=None):
         """Instantiate OptimizationControlMechanism's OptimizatonFunction attributes"""
 
@@ -931,7 +944,7 @@ def _tear_down_simulation(self, sim_context=None):
         if not self.agent_rep.parameters.retain_old_simulation_data._get():
             self.agent_rep._delete_contexts(sim_context, check_simulation_storage=True)
 
-    def evaluation_function(self, control_allocation, context=None):
+    def evaluation_function(self, control_allocation, context=None, return_results=False):
         """Compute `net_outcome <ControlMechanism.net_outcome>` for current set of `feature_values
         <OptimizationControlMechanism.feature_values>` and a specified `control_allocation
         <ControlMechanism.control_allocation>`.
@@ -964,12 +977,21 @@ def evaluation_function(self, control_allocation, context=None):
                                              self.parameters.num_estimates._get(context),
                                              base_context=context,
                                              context=new_context,
-                                             execution_mode=self.parameters.comp_execution_mode._get(context)
-            )
+                                             execution_mode=self.parameters.comp_execution_mode._get(context),
+                                             return_results=return_results)
             context.composition = old_composition
 
             if self.defaults.search_statefulness:
                 self._tear_down_simulation(new_context)
+
+            # If results of the simulation shoudld be returned then, do so. Agent Rep Evaluate will
+            # return a tuple in this case where the first element is the outcome as usual and the
+            # results of composision run are the second element.
+            if return_results:
+                return result[0], result[1]
+            else:
+                return result
+
         # agent_rep is a CompositionFunctionApproximator (since runs_simuluations = False)
         else:
             result = self.agent_rep.evaluate(self.parameters.feature_values._get(context),
@@ -1267,6 +1289,16 @@ def control_allocation_search_space(self):
         """Return list of SampleIterators for allocation_samples of control_signals"""
         return [c.allocation_samples for c in self.control_signals]
 
+    @property
+    def _model_spec_parameter_blacklist(self):
+        # default_variable is hidden in constructor arguments,
+        # and anyway assigning it is problematic because it is modified
+        # several times when creating input states, and assigning function that
+        # fits the control allocation
+        return super()._model_spec_parameter_blacklist.union({
+            'variable',
+        })
+
     # ******************************************************************************************************************
     # FIX:  THE FOLLOWING IS SPECIFIC TO CompositionFunctionApproximator AS agent_rep
     # ******************************************************************************************************************
diff --git a/psyneulink/core/components/mechanisms/modulatory/modulatorymechanism.py b/psyneulink/core/components/mechanisms/modulatory/modulatorymechanism.py
index d50acb01fd4..3d33ac6d40d 100644
--- a/psyneulink/core/components/mechanisms/modulatory/modulatorymechanism.py
+++ b/psyneulink/core/components/mechanisms/modulatory/modulatorymechanism.py
@@ -22,26 +22,22 @@
 .. _ModulatoryMechanism_Types:
 
 
-# FIX 9/27/19
-There are three types of ModulatoryMechanism:
-
-* `ModulatoryMechanism`
-    takes an evaluative signal (generally received from an `ObjectiveMechanism`) and generates an
-    `modulatory_allocation <ModulatoryMechanism.modulatory_allocation>`, each item of which is assigned to one of its
-    `ModulatorySignals <ModulatorySignal>`;  each of those generates a `modulatory_signal
-    <ModulatorySignal.modulatory_signal>` that is used by its `ModulatoryProjection(s) <ModulatoryProjection>` to
-    modulate the parameter of a `function <State_Base.function>` (and thereby the `value <State_Base.value>`) of a
-    `State`.  A ModulatoryMechanism can be assigned any combination of `ControlSignals <ControlSignal>` and
-    `GatingSignals <GatingSignal>`.
-..
+There are two primary types of ModulatoryMechanism:
+
 * `ControlMechanism`
-    a subclsass of `ModulatoryMechanism` that adds support for `costs <ControlMechanism.costs>`;  it takes an
-    evaluative signal (generally received from an `ObjectiveMechanism`) and generates a `control_allocation
+    modulates the `value <State_Base.value>` of a `State` of a `Mechanism`.  Takes an evaluative signal (generally
+    received from an `ObjectiveMechanism`) and generates a `control_allocation
     <ControlMechanism.control_allocation>`, each item of which is assigned to one of its `ControlSignals
     <ControlSignal>`;  each of those generates a `control_signal <ControlSignal.control_signal>` that is used by its
     `ControlProjection(s) <ControlProjection>` to modulate the parameter of a `function <State_Base.function>` (and
-    thereby the `value <State_Base.value>`) of a `State`.  A ControlMechanism can be assigned only the `ControlSignal`
-    class of `ModulatorySignal`, but can be also be assigned other generic `OutputStates <OutputState>`.
+    thereby the `value <State_Base.value>`) of a `State`.  ControlSignals have `costs <ControlSignal_Costs>`,
+    and a ControlMechanism has a `costs <ControlMechanism.costs>` and a `net_outcome <ControlMechanism.net_outcome>`
+    that is computed based on the `costs <ControlSignal.costs>` of its ControlSignals. A ControlMechanism can be
+    assigned only the `ControlSignal` class of `ModulatorySignal`, but can be also be assigned other generic
+    `OutputStates <OutputState>` that appear after its ControlSignals in its `output_states
+    <ControlMechanism.output_states>` attribute.
+
+COMMENT:
 ..
 * `GatingMechanism`
     a subclsass of `ModulatoryMechanism` that is specialized for modulating the input to or ouput from a `Mechanism`;
@@ -52,26 +48,24 @@ class of `ModulatorySignal`, but can be also be assigned other generic `OutputSt
     <State_Base.function>` (and thereby the `value <State_Base.value>`) of an `InputState` or `OutputState`.
     A GatingMechanism can be assigned only the `GatingSignal` class of `ModulatorySignal`, but can be also be assigned
     other generic `OutputStates <OutputState>`.
-.
+COMMENT.
 ..
 * `LearningMechanism`
-    takes an error signal (received from an `ObjectiveMechanism` or another `LearningMechanism`) and generates a
-    `learning_signal <LearningMechanism.learning_signal>` that is provided to its `LearningSignal(s)
-    <LearningSignal>`, and used by their `LearningProjections <LearningProjection>` to modulate the `matrix
-    <MappingProjection.matrix>` parameter of a `MappingProjection`. A LearningMechanism can be assigned only
-    `LearningSignals <LearningSignal>` as its `OuputStates <OutputState>`.
+    modulates the `matrix <MappingProjection.matrix>` parameter of a `MappingProjection`.  Takes an error signal
+    (received from an `ObjectiveMechanism` or another `LearningMechanism`) and generates a `learning_signal
+    <LearningMechanism.learning_signal>` that is provided to its `LearningSignal(s) <LearningSignal>`, and used by
+    their `LearningProjections <LearningProjection>` to modulate the `matrix <MappingProjection.matrix>` parameter
+    of a `MappingProjection`. A LearningMechanism can be assigned only the `LearningSignal` class of `ModulatorySignal`
+    as its `OuputStates <OutputState>`, but can be also be assigned other generic `OutputStates <OutputState>`,
+    that appear after its LearningSignals in its `output_states <LearningMechanism.output_states>` attribute.
 
 See `ModulatorySignal <ModulatorySignal_Naming>` for conventions used for the names of Modulatory components.
 
-A single `ModulatoryMechanism` can be assigned more than one ModulatorySignal of the appropriate
-
-which, each of which can
-be assigned
-different `allocations <ModulatorySignal.allocation>` (for ControlSignals and GatingSignals) or `learning_signals
-<LearningMechanism.learning_signal>` (for LearningSignals).  A single ModulatorySignal can also be assigned multiple
-ModulatoryProjections; however, as described  under `_ModulatorySignal_Projections`, they will all be assigned the
-same `variable <ModulatoryProjection_Base.variable>`.
-
+A single `ModulatoryMechanism` can be assigned more than one ModulatorySignal of the appropriate type, each of which
+can be assigned different `control_allocations <ControlSignal.control_allocation>` (for ControlSignals) or
+`learning_signals <LearningMechanism.learning_signal>` (for LearningSignals).  A single ModulatorySignal can also be
+assigned multiple ModulatoryProjections; however, as described  in `ModulatorySignal_Projections`, they will all
+be assigned the same `variable <ModulatoryProjection_Base.variable>`.
 
 COMMENT:
 ModulatoryMechanisms are always executed after all `ProcessingMechanisms <ProcessingMechanism>` in the `Process` or
diff --git a/psyneulink/core/components/mechanisms/processing/objectivemechanism.py b/psyneulink/core/components/mechanisms/processing/objectivemechanism.py
index fb73dac334d..20270fda771 100644
--- a/psyneulink/core/components/mechanisms/processing/objectivemechanism.py
+++ b/psyneulink/core/components/mechanisms/processing/objectivemechanism.py
@@ -590,6 +590,16 @@ class Parameters(ProcessingMechanism_Base.Parameters):
         """
         function = Parameter(LinearCombination, stateful=False, loggable=False)
 
+        input_states_spec = Parameter(
+            None,
+            stateful=False,
+            loggable=False,
+            read_only=True,
+            user=False,
+            pnl_internal=True,
+            constructor_argument='monitor'
+        )
+
     # ObjectiveMechanism parameter and control signal assignments):
     paramClassDefaults = Mechanism_Base.paramClassDefaults.copy()
     paramClassDefaults.update({
diff --git a/psyneulink/core/components/mechanisms/processing/transfermechanism.py b/psyneulink/core/components/mechanisms/processing/transfermechanism.py
index 246dd47148c..c30b1abb3be 100644
--- a/psyneulink/core/components/mechanisms/processing/transfermechanism.py
+++ b/psyneulink/core/components/mechanisms/processing/transfermechanism.py
@@ -912,7 +912,7 @@ class Parameters(ProcessingMechanism_Base.Parameters):
         integrator_mode = Parameter(False, setter=_integrator_mode_setter)
         integration_rate = Parameter(0.5, modulable=True)
         initial_value = None
-        previous_value = Parameter(None, read_only=True)
+        previous_value = Parameter(None, read_only=True, pnl_internal=True)
         integrator_function = Parameter(AdaptiveIntegrator, stateful=False, loggable=False)
         integrator_function_value = Parameter([[0]], read_only=True)
         has_integrated = Parameter(False, user=False)
@@ -986,6 +986,7 @@ def __init__(self,
                 default_variable=default_variable,
                 size=size,
                 input_states=input_states,
+                output_states=output_states,
                 function=function,
                 params=params,
                 name=name,
@@ -1288,10 +1289,7 @@ def _instantiate_integrator_function(self, variable, noise, initializer,  rate,
                                     f"size ({variable.shape[-1]}) of the innermost dimension (axis 0) of its "
                                     f"{repr(VARIABLE)} (i.e., the length of its items .")
             self.integrator_function.parameters.variable.default_value = variable
-            function_context_buffer = self.integrator_function.initialization_status
-            self.integrator_function.initialization_status = ContextFlags.INITIALIZING
             self.integrator_function.parameters.value.default_value = self.integrator_function(variable, context=context)
-            self.integrator_function.initialization_status = function_context_buffer
         # MODIFIED 6/24/19 END
 
         self.has_integrated = True
diff --git a/psyneulink/core/components/process.py b/psyneulink/core/components/process.py
index 3589cbfa93a..70d82e91847 100644
--- a/psyneulink/core/components/process.py
+++ b/psyneulink/core/components/process.py
@@ -2680,8 +2680,8 @@ class Parameters(OutputState.Parameters):
 
         """
         # just grabs input from the process
-        variable = Parameter(np.array([0]), read_only=True)
-        value = Parameter(np.array([0]), read_only=True)
+        variable = Parameter(np.array([0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
+        value = Parameter(np.array([0]), read_only=True, pnl_internal=True)
 
     def __init__(self, owner=None, variable=None, name=None, prefs=None):
         """Pass variable to MappingProjection from Process to first Mechanism in Pathway
diff --git a/psyneulink/core/components/projections/modulatory/controlprojection.py b/psyneulink/core/components/projections/modulatory/controlprojection.py
index 1658cd4af4e..bb0ada78f00 100644
--- a/psyneulink/core/components/projections/modulatory/controlprojection.py
+++ b/psyneulink/core/components/projections/modulatory/controlprojection.py
@@ -309,7 +309,16 @@ class Parameters(ModulatoryProjection_Base.Parameters):
 
         """
         function = Parameter(Linear, stateful=False, loggable=False)
-        control_signal = Parameter(None, read_only=True, getter=_control_signal_getter, setter=_control_signal_setter)
+        control_signal = Parameter(None, read_only=True, getter=_control_signal_getter, setter=_control_signal_setter, pnl_internal=True)
+
+        control_signal_params = Parameter(
+            None,
+            stateful=False,
+            loggable=False,
+            read_only=True,
+            user=False,
+            pnl_internal=True
+        )
 
     paramClassDefaults = Projection_Base.paramClassDefaults.copy()
     paramClassDefaults.update({
@@ -420,6 +429,9 @@ def _instantiate_receiver(self, context=None):
         # else:
         super(ControlProjection, self)._instantiate_receiver(context=context)
 
+    # def _execute(self, variable=None, context=None, runtime_params=None):
+    #     return super()._execute(variable, context, runtime_params)
+
     @property
     def control_signal(self):
         return self.sender.value
diff --git a/psyneulink/core/components/projections/modulatory/gatingprojection.py b/psyneulink/core/components/projections/modulatory/gatingprojection.py
index 69a27dce4bb..b63cb31aea3 100644
--- a/psyneulink/core/components/projections/modulatory/gatingprojection.py
+++ b/psyneulink/core/components/projections/modulatory/gatingprojection.py
@@ -295,7 +295,7 @@ class Parameters(ModulatoryProjection_Base.Parameters):
 
         """
         function = Parameter(Linear(params={FUNCTION_OUTPUT_TYPE: FunctionOutputType.RAW_NUMBER}), stateful=False, loggable=False)
-        gating_signal = Parameter(None, read_only=True, getter=_gating_signal_getter, setter=_gating_signal_setter)
+        gating_signal = Parameter(None, read_only=True, getter=_gating_signal_getter, setter=_gating_signal_setter, pnl_internal=True)
 
     paramClassDefaults = Projection_Base.paramClassDefaults.copy()
     paramClassDefaults.update({
diff --git a/psyneulink/core/components/projections/modulatory/learningprojection.py b/psyneulink/core/components/projections/modulatory/learningprojection.py
index d54c34afbe9..85ab980d0c6 100644
--- a/psyneulink/core/components/projections/modulatory/learningprojection.py
+++ b/psyneulink/core/components/projections/modulatory/learningprojection.py
@@ -482,12 +482,12 @@ class Parameters(ModulatoryProjection_Base.Parameters):
                     :read only: True
 
         """
-        value = Parameter(np.array([0]), read_only=True, aliases=['weight_change_matrix'])
+        value = Parameter(np.array([0]), read_only=True, aliases=['weight_change_matrix'], pnl_internal=True)
         function = Parameter(Linear, stateful=False, loggable=False)
         error_function = Parameter(LinearCombination(weights=[[-1], [1]]), stateful=False, loggable=False)
         learning_function = Parameter(BackPropagation, stateful=False, loggable=False)
         learning_rate = Parameter(None, modulable=True)
-        learning_signal = Parameter(None, read_only=True, getter=_learning_signal_getter, setter=_learning_signal_setter)
+        learning_signal = Parameter(None, read_only=True, getter=_learning_signal_getter, setter=_learning_signal_setter, pnl_internal=True)
         learning_enabled = None
 
     paramClassDefaults = Projection_Base.paramClassDefaults.copy()
diff --git a/psyneulink/core/components/projections/projection.py b/psyneulink/core/components/projections/projection.py
index f4e99ee730c..a5e9d0ef929 100644
--- a/psyneulink/core/components/projections/projection.py
+++ b/psyneulink/core/components/projections/projection.py
@@ -399,7 +399,7 @@
 from psyneulink.core.components.states.modulatorysignals.modulatorysignal import _is_modulatory_spec
 from psyneulink.core.components.states.state import StateError
 from psyneulink.core.globals.context import ContextFlags
-from psyneulink.core.globals.keywords import CONTROL, CONTROL_PROJECTION, CONTROL_SIGNAL, EXPONENT, FUNCTION_PARAMS, GATING, GATING_PROJECTION, GATING_SIGNAL, INPUT_STATE, LEARNING, LEARNING_PROJECTION, LEARNING_SIGNAL, MAPPING_PROJECTION, MATRIX, MATRIX_KEYWORD_SET, MECHANISM, NAME, OUTPUT_STATE, OUTPUT_STATES, PARAMS, PATHWAY, PROJECTION, PROJECTION_PARAMS, PROJECTION_SENDER, PROJECTION_TYPE, RECEIVER, SENDER, STANDARD_ARGS, STATE, STATES, WEIGHT, ADD_INPUT_STATE, ADD_OUTPUT_STATE, PROJECTION_COMPONENT_CATEGORY
+from psyneulink.core.globals.keywords import CONTROL, CONTROL_PROJECTION, CONTROL_SIGNAL, EXPONENT, FUNCTION_PARAMS, GATING, GATING_PROJECTION, GATING_SIGNAL, INPUT_STATE, LEARNING, LEARNING_PROJECTION, LEARNING_SIGNAL, MAPPING_PROJECTION, MATRIX, MATRIX_KEYWORD_SET, MECHANISM, MODEL_SPEC_ID_RECEIVER_MECH, MODEL_SPEC_ID_RECEIVER_STATE, MODEL_SPEC_ID_SENDER_MECH, MODEL_SPEC_ID_SENDER_STATE, NAME, OUTPUT_STATE, OUTPUT_STATES, PARAMS, PATHWAY, PROJECTION, PROJECTION_PARAMS, PROJECTION_SENDER, PROJECTION_TYPE, RECEIVER, SENDER, STANDARD_ARGS, STATE, STATES, WEIGHT, ADD_INPUT_STATE, ADD_OUTPUT_STATE, PROJECTION_COMPONENT_CATEGORY
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.globals.preferences.preferenceset import PreferenceLevel
 from psyneulink.core.globals.registry import register_category
@@ -847,6 +847,8 @@ def _instantiate_sender(self, sender, context=None):
 
         # Assign projection to self.sender's efferents list attribute
         # First make sure that projection is not already in efferents
+        # IMPLEMENTATON NOTE:  Currently disallows *ANY* Projections with same sender and receiver
+        #                      (even if they are in different Compositions)
         if self not in self.sender.efferents:
             # Then make sure there is not already a projection to its receiver
             receiver = self.receiver
@@ -861,6 +863,8 @@ def _instantiate_sender(self, sender, context=None):
             # IMPLEMENTATION NOTE:  this gives precedence to a Projection to a Component specified by its sender
             #                      (e.g., controller of a Composition for a ControlProjection)
             #                       over its specification in the constructor for the receiver or its owner
+            # IMPLEMENTATION NOTE:  This should be removed if/when different Projections are permitted between
+            #                       the same sender and receiver in different Compositions
             if dup:
                 if dup.initialization_status == ContextFlags.DEFERRED_INIT:
                     del receiver.mod_afferents[receiver.mod_afferents.index(dup)]
@@ -1026,6 +1030,35 @@ def _dependent_components(self):
     def _delete_projection(projection):
         raise ProjectionError(f"{Projection.__name__} class {type(projection)} does not implement _delete method.")
 
+    @property
+    def _dict_summary(self):
+        # these may occur during deferred init
+        if not isinstance(self.sender, type):
+            sender_name = self.sender.name
+            sender_mech = self.sender.owner.name
+        else:
+            sender_name = None
+            sender_mech = None
+
+        if not isinstance(self.receiver, type):
+            receiver_name = self.receiver.name
+            receiver_mech = self.receiver.owner.name
+        else:
+            receiver_name = None
+            receiver_mech = None
+
+        socket_dict = {
+            MODEL_SPEC_ID_SENDER_STATE: sender_name,
+            MODEL_SPEC_ID_RECEIVER_STATE: receiver_name,
+            MODEL_SPEC_ID_SENDER_MECH: sender_mech,
+            MODEL_SPEC_ID_RECEIVER_MECH: receiver_mech
+        }
+
+        return {
+            **super()._dict_summary,
+            **socket_dict
+        }
+
 
 @tc.typecheck
 def _is_projection_spec(spec, proj_type:tc.optional(type)=None, include_matrix_spec=True):
@@ -1193,6 +1226,7 @@ def _parse_projection_spec(projection_spec,
     elif (isinstance(projection_spec, State)
           or (isinstance(projection_spec, type) and issubclass(projection_spec, State))):
         proj_spec_dict[PROJECTION_TYPE] = projection_spec.paramClassDefaults[PROJECTION_TYPE]
+        state_type = projection_spec.__class__
 
     # Mechanism object or class
     elif (isinstance(projection_spec, Mechanism)
@@ -1603,10 +1637,7 @@ def _parse_connection_specs(connectee_state_type,
                 # FIX: 11/28/17 HACK TO DEAL WITH GatingSignal Projection to OutputState
                 # FIX: 5/11/19: CORRECTED TO HANDLE ControlMechanism SPECIFIED FOR GATING
                 if ((_is_gating_spec(first_item) or _is_control_spec(first_item))
-                    and (isinstance(last_item, OutputState) or last_item == OutputState
-                        # # FIX: 9/27/19:  ADDED TO DEAL WITH ControlMechanism SPECIFIED FOR GATING OF INPUTSTATE
-                        #  or isinstance(last_item, InputState) or last_item == InputState
-                        )
+                    and (isinstance(last_item, OutputState) or last_item == OutputState)
                 ):
                     projection_socket = SENDER
                     state_types = [OutputState]
@@ -1661,7 +1692,6 @@ def _parse_connection_specs(connectee_state_type,
             if _is_projection_spec(projection_spec) or _is_modulatory_spec(projection_spec) or projection_spec is None:
 
                 # FIX: 11/21/17 THIS IS A HACK TO DEAL WITH GatingSignal Projection TO InputState or OutputState
-                # FIX: 9/27/19 AUGMENT TO INCLUDE ControlSignal Projection??
                 from psyneulink.core.components.states.inputstate import InputState
                 from psyneulink.core.components.states.outputstate import OutputState
                 from psyneulink.core.components.states.modulatorysignals.gatingsignal import GatingSignal
@@ -1683,14 +1713,8 @@ def _parse_connection_specs(connectee_state_type,
                 ):
                     projection_spec = state
 
-                # # MODIFIED 9/27/19 OLD:
-                # elif _is_gating_spec(first_item):
-                # # MODIFIED 9/27/19 NEW: [JDC]
-                # elif _is_gating_spec(first_item) or _is_control_spec((first_item)):
-                # MODIFIED 9/27/19 NEWER: [JDC] XYZ
                 elif (_is_gating_spec(first_item) or _is_control_spec((first_item))
                       and not isinstance(last_item, (GatingProjection, ControlProjection))):
-                # MODIFIED 9/27/19 END
                     projection_spec = first_item
                 projection_spec = _parse_projection_spec(projection_spec,
                                                          owner=owner,
diff --git a/psyneulink/core/components/states/inputstate.py b/psyneulink/core/components/states/inputstate.py
index 3d85354ba30..93e4c712936 100644
--- a/psyneulink/core/components/states/inputstate.py
+++ b/psyneulink/core/components/states/inputstate.py
@@ -772,8 +772,8 @@ class Parameters(State_Base.Parameters):
         weight = Parameter(None, modulable=True)
         exponent = Parameter(None, modulable=True)
         combine = None
-        internal_only = Parameter(False, stateful=False, loggable=False)
-        shadow_inputs = Parameter(None, stateful=False, loggable=False, read_only=True)
+        internal_only = Parameter(False, stateful=False, loggable=False, pnl_internal=True)
+        shadow_inputs = Parameter(None, stateful=False, loggable=False, read_only=True, pnl_internal=True)
 
     paramClassDefaults = State_Base.paramClassDefaults.copy()
     paramClassDefaults.update({PROJECTION_TYPE: MAPPING_PROJECTION,
diff --git a/psyneulink/core/components/states/modulatorysignals/controlsignal.py b/psyneulink/core/components/states/modulatorysignals/controlsignal.py
index 8a1cc2015b8..b7d9178427c 100644
--- a/psyneulink/core/components/states/modulatorysignals/controlsignal.py
+++ b/psyneulink/core/components/states/modulatorysignals/controlsignal.py
@@ -708,16 +708,24 @@ class Parameters(ModulatorySignal.Parameters):
         # FIX: if the specification of this getter is happening in several other classes, should consider
         #      refactoring Parameter to allow individual attributes to be inherited, othwerise, leaving this is an
         #      isolated case
-        variable = Parameter(np.array([defaultControlAllocation]),
-                             aliases='allocation',
-                             getter=_output_state_variable_getter)
+        variable = Parameter(
+            np.array([defaultControlAllocation]),
+            aliases='allocation',
+            getter=_output_state_variable_getter,
+            pnl_internal=True, constructor_argument='default_variable'
+        )
 
         # # FIX: DOESN'T WORK, SINCE DON'T HAVE ACCESS TO OTHER ARGS
         # function = Parameter(TransferWithCosts, stateful=False, loggable=False, )
         # _parse_function = _function_parser
 
-        value = Parameter(np.array([defaultControlAllocation]), read_only=True, aliases=['intensity'],
-                          history_min_length=1)
+        value = Parameter(
+            np.array([defaultControlAllocation]),
+            read_only=True,
+            aliases=['intensity'],
+            pnl_internal=True,
+            history_min_length=1
+        )
         allocation_samples = Parameter(None, modulable=True)
 
         cost_options = Parameter(CostFunctions.DEFAULTS, getter=_cost_options_getter, setter=_cost_options_setter)
diff --git a/psyneulink/core/components/states/modulatorysignals/gatingsignal.py b/psyneulink/core/components/states/modulatorysignals/gatingsignal.py
index 246f722ed59..7a7b3054e33 100644
--- a/psyneulink/core/components/states/modulatorysignals/gatingsignal.py
+++ b/psyneulink/core/components/states/modulatorysignals/gatingsignal.py
@@ -452,8 +452,10 @@ class Parameters(ControlSignal.Parameters):
         """
         variable = Parameter(np.array([defaultGatingAllocation]),
                              aliases='allocation',
-                             getter=_output_state_variable_getter)
-        value = Parameter(np.array([defaultGatingAllocation]), read_only=True, aliases=['intensity'])
+                             getter=_output_state_variable_getter,
+                             pnl_internal=True, constructor_argument='default_variable'
+        )
+        value = Parameter(np.array([defaultGatingAllocation]), read_only=True, aliases=['intensity'], pnl_internal=True)
         allocation_samples = Parameter(None, modulable=True)
         modulation = None
 
diff --git a/psyneulink/core/components/states/modulatorysignals/learningsignal.py b/psyneulink/core/components/states/modulatorysignals/learningsignal.py
index 9b2afcdaf02..7184d30d99e 100644
--- a/psyneulink/core/components/states/modulatorysignals/learningsignal.py
+++ b/psyneulink/core/components/states/modulatorysignals/learningsignal.py
@@ -374,7 +374,7 @@ class Parameters(ModulatorySignal.Parameters):
                     :type:
 
         """
-        value = Parameter(np.array([0]), read_only=True, aliases=['learning_signal'])
+        value = Parameter(np.array([0]), read_only=True, aliases=['learning_signal'], pnl_internal=True)
         learning_rate = None
 
     @tc.typecheck
diff --git a/psyneulink/core/components/states/outputstate.py b/psyneulink/core/components/states/outputstate.py
index 2e243038e27..630458efeff 100644
--- a/psyneulink/core/components/states/outputstate.py
+++ b/psyneulink/core/components/states/outputstate.py
@@ -977,7 +977,7 @@ class Parameters(State_Base.Parameters):
                     :read only: True
 
         """
-        variable = Parameter(np.array([0]), read_only=True, getter=_output_state_variable_getter)
+        variable = Parameter(np.array([0]), read_only=True, getter=_output_state_variable_getter, pnl_internal=True, constructor_argument='default_variable')
 
     paramClassDefaults = State_Base.paramClassDefaults.copy()
     paramClassDefaults.update({PROJECTION_TYPE: MAPPING_PROJECTION,
@@ -1355,6 +1355,17 @@ def get_label(self, context=None):
             label_dictionary = {}
         return self._get_value_label(label_dictionary, self.owner.output_states, context=context)
 
+    @property
+    def _dict_summary(self):
+        return {
+            **super()._dict_summary,
+            **{
+                'shape': str(self.defaults.value.shape),
+                'dtype': str(self.defaults.value.dtype)
+            }
+        }
+
+
 def _instantiate_output_states(owner, output_states=None, context=None):
     """Call State._instantiate_state_list() to instantiate ContentAddressableList of OutputState(s)
 
diff --git a/psyneulink/core/components/states/state.py b/psyneulink/core/components/states/state.py
index 138b1fd7082..19499fcd8bd 100644
--- a/psyneulink/core/components/states/state.py
+++ b/psyneulink/core/components/states/state.py
@@ -757,7 +757,7 @@ def test_multiple_modulatory_projections_with_mech_and_state_name_specs(self):
     MODULATORY_PROJECTION, MODULATORY_PROJECTIONS, MODULATORY_SIGNAL, MULTIPLICATIVE, MULTIPLICATIVE_PARAM, \
     NAME, OUTPUT_STATES, OVERRIDE, OWNER, \
     PARAMETER_STATES, PARAMS, PATHWAY_PROJECTIONS, PREFS_ARG, \
-    PROJECTION_DIRECTION, PROJECTIONS, PROJECTION_PARAMS, PROJECTION_TYPE, \
+    PROJECTION_DIRECTION, PROJECTION, PROJECTIONS, PROJECTION_PARAMS, PROJECTION_TYPE, \
     RECEIVER, REFERENCE_VALUE, REFERENCE_VALUE_NAME, SENDER, STANDARD_OUTPUT_STATES, \
     STATE, STATE_CONTEXT, STATE_NAME, STATE_PARAMS, STATE_PREFS, STATE_TYPE, STATE_VALUE, VALUE, VARIABLE, WEIGHT, \
     STATE_COMPONENT_CATEGORY
@@ -771,7 +771,7 @@ def test_multiple_modulatory_projections_with_mech_and_state_name_specs(self):
     merge_param_dicts, MODULATION_OVERRIDE, type_match
 
 __all__ = [
-    'State_Base', 'state_keywords', 'state_type_keywords', 'StateError', 'StateRegistry'
+    'State_Base', 'state_keywords', 'state_type_keywords', 'StateError', 'StateRegistry', 'STATE_SPEC'
 ]
 
 state_keywords = component_keywords.copy()
@@ -1042,7 +1042,7 @@ class Parameters(State.Parameters):
                     :read only: True
         """
         function = Parameter(Linear, stateful=False, loggable=False)
-        require_projection_in_composition = Parameter(True, stateful=False, loggable=False, read_only=True)
+        require_projection_in_composition = Parameter(True, stateful=False, loggable=False, read_only=True, pnl_internal=True)
 
     stateAttributes = {FUNCTION, FUNCTION_PARAMS, PROJECTIONS}
 
@@ -2364,6 +2364,16 @@ def _dependent_components(self):
             self.efferents,
         ))
 
+    @property
+    def _dict_summary(self):
+        return {
+            **super()._dict_summary,
+            **{
+                'shape': str(self.defaults.variable.shape),
+                'dtype': str(self.defaults.variable.dtype)
+            }
+        }
+
 
 def _instantiate_state_list(owner,
                             state_list,              # list of State specs, (state_spec, params) tuples, or None
@@ -2487,17 +2497,6 @@ def _instantiate_state_list(owner,
         for proj in state.path_afferents:
             owner.aux_components.append(proj)
 
-        # # Get name of state, and use as index to assign to states ContentAddressableList
-        # default_name = state._assign_default_state_name()
-        # if default_name:
-        #      state_name = default_name
-        # elif state.initialization_status is ContextFlags.DEFERRED_INIT
-        #     state_name = state.init_args[NAME]
-        # else:
-        #     state_name = state.name
-        #
-        # states[state_name] = state
-
         states[state.name] = state
 
     return states
@@ -2789,6 +2788,22 @@ def _parse_state_spec(state_type=None,
 
         # If it is a State specification dictionary
         if isinstance(state_spec[STATE_SPEC_ARG], dict):
+
+            # If the State specification is a Projection that has a sender already assigned,
+            #    then return that State with the Projection assigned to it
+            #    (this occurs, for example, if an instantiated ControlSignal is used to specify a parameter
+            try:
+                assert len(state_spec[STATE_SPEC_ARG][PROJECTIONS])==1
+                projection = state_spec[STATE_SPEC_ARG][PROJECTIONS][0]
+                state = projection.sender
+                if state.initialization_status == ContextFlags.DEFERRED_INIT:
+                    state.init_args[PARAMS][PROJECTIONS]=projection
+                else:
+                    state._instantiate_projections_to_state(projections=projection, context=context)
+                return state
+            except:
+                pass
+
             # Use the value of any standard args specified in the State specification dictionary
             #    to replace those explicitly specified in the call to _instantiate_state (i.e., passed in standard_args)
             #    (use copy so that items in state_spec dict are not deleted when called from _validate_params)
@@ -2799,6 +2814,18 @@ def _parse_state_spec(state_type=None,
             # Delete them from the State specification dictionary, leaving only state-specific items there
             for key in standard_args:
                 state_specific_args.pop(key, None)
+
+            try:
+                spec = state_spec[STATE_SPEC_ARG]
+                state_tuple = [spec[STATE_SPEC_ARG], spec[WEIGHT], spec[EXPONENT]]
+                try:
+                    state_tuple.append(spec[PROJECTION])
+                except KeyError:
+                    pass
+                state_specification = tuple(state_tuple)
+            except KeyError:
+                pass
+
         else:
             state_specification = state_spec[STATE_SPEC_ARG]
 
@@ -2884,43 +2911,7 @@ def _parse_state_spec(state_type=None,
                 state_specification = mech
                 projection = state_type
 
-        # # MODIFIED 9/27/19 OLD:
-        # # Specication is a State with which connectee can connect, so assume it is a Projection specification
-        # if state_specification.__class__.__name__ in state_type.connectsWith + state_type.modulators:
-        #     projection = state_type
-        #
-        # # Specification is a State that is same as connectee's type (state_type),
-        # #    so assume it is a reference to the State itself that is being (or has been) instantiated
-        # elif isinstance(state_specification, state_type):
-        #     # Make sure that the specified State belongs to the Mechanism passed in the owner arg
-        #     if state_specification.initialization_status == ContextFlags.DEFERRED_INIT:
-        #         state_owner = state_specification.init_args[OWNER]
-        #     else:
-        #         state_owner = state_specification.owner
-        #     if owner is not None and state_owner is not None and state_owner is not owner:
-        #         try:
-        #             new_state_specification = state_type._parse_self_state_type_spec(state_type,
-        #                                                                              owner,
-        #                                                                              state_specification,
-        #                                                                              context)
-        #             state_specification = _parse_state_spec(state_type=state_type,
-        #                                                     owner=owner,
-        #                                                     state_spec=new_state_specification)
-        #             assert True
-        #         except AttributeError:
-        #             raise StateError("Attempt to assign a {} ({}) to {} that belongs to another {} ({})".
-        #                              format(State.__name__, state_specification.name, owner.name,
-        #                                     Mechanism.__name__, state_owner.name))
-        #     return state_specification
-
-        # MODIFIED 9/27/19 NEW: [JDC]
-        # Specification is a State that is same as connectee's type (state_type),
-        #    so assume it is a reference to the State itself that is being (or has been) instantiated
-        # # MODIFIED 9/27/19 OLD:
-        # if isinstance(state_specification, state_type):
-        # MODIFIED 9/27/19 NEWER: [JDC]
         if state_specification.__class__ == state_type:
-        # MODIFIED 9/27/19 END
             # Make sure that the specified State belongs to the Mechanism passed in the owner arg
             if state_specification.initialization_status == ContextFlags.DEFERRED_INIT:
                 state_owner = state_specification.init_args[OWNER]
@@ -2945,7 +2936,6 @@ def _parse_state_spec(state_type=None,
         # Specication is a State with which connectee can connect, so assume it is a Projection specification
         elif state_specification.__class__.__name__ in state_type.connectsWith + state_type.modulators:
             projection = state_type
-        # MODIFIED 9/27/19 END
 
         # Re-process with Projection specified
         state_dict = _parse_state_spec(state_type=state_type,
@@ -3101,7 +3091,11 @@ def _parse_state_spec(state_type=None,
             if MECHANISM in state_specific_args:
 
                 if not PROJECTIONS in params:
-                    params[PROJECTIONS] = []
+                    if NAME in spec:
+                        # substitute into tuple spec
+                        params[PROJECTIONS] = (spec[NAME], params[MECHANISM])
+                    else:
+                        params[PROJECTIONS] = []
 
                 mech = state_specific_args[MECHANISM]
                 if not isinstance(mech, Mechanism):
diff --git a/psyneulink/core/components/system.py b/psyneulink/core/components/system.py
index 12ca5559453..b8fd1bfb3c8 100644
--- a/psyneulink/core/components/system.py
+++ b/psyneulink/core/components/system.py
@@ -870,7 +870,7 @@ class Parameters(System_Base.Parameters):
                     :type:
 
         """
-        variable = None
+        variable = Parameter(None, pnl_internal=True, constructor_argument='default_variable')
 
     paramClassDefaults = Component.paramClassDefaults.copy()
     paramClassDefaults.update({
@@ -966,7 +966,6 @@ def __init__(self,
                          prefs=prefs,
                          context=context)
 
-        self.initialization_status = ContextFlags.INITIALIZED
         self.reinitialize_mechanisms_when = reinitialize_mechanisms_when
 
         # Assign controller
@@ -5022,8 +5021,8 @@ class Parameters(OutputState.Parameters):
 
         """
         # just grabs input from the process
-        variable = Parameter(np.array([0]), read_only=True)
-        value = Parameter(np.array([0]), read_only=True)
+        variable = Parameter(np.array([0]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
+        value = Parameter(np.array([0]), read_only=True, pnl_internal=True)
 
     def __init__(self, owner=None, variable=None, name=None, prefs=None, context=None):
         """Pass variable to MappingProjection from Process to first Mechanism in Pathway
diff --git a/psyneulink/core/compositions/composition.py b/psyneulink/core/compositions/composition.py
index 898526e95b8..125d0caf36c 100644
--- a/psyneulink/core/compositions/composition.py
+++ b/psyneulink/core/compositions/composition.py
@@ -1116,13 +1116,7 @@ def input_function(env, result):
 from psyneulink.core.components.states.modulatorysignals.controlsignal import ControlSignal
 from psyneulink.core.components.mechanisms.processing.processingmechanism import ProcessingMechanism
 from psyneulink.core.globals.context import Context, ContextFlags, handle_external_context
-from psyneulink.core.globals.keywords import \
-    AFTER, ALL, BEFORE, BOLD, BOTH, \
-    COMPARATOR_MECHANISM, COMPONENT, COMPOSITION, CONTROL, CONTROL_SIGNAL, CONTROLLER, CONDITIONS, \
-    FUNCTIONS, HARD_CLAMP, IDENTITY_MATRIX, INPUT, LABELS, LEARNED_PROJECTION, LEARNING_MECHANISM, \
-    MATRIX, MATRIX_KEYWORD_VALUES, MAYBE, MECHANISM, MECHANISMS, MONITOR, MONITOR_FOR_CONTROL, NAME, NO_CLAMP, \
-    ONLINE, OUTCOME, OUTPUT, OWNER_VALUE, PATHWAY, PROJECTION, PROJECTIONS, PULSE_CLAMP, ROLES, \
-    SAMPLE, SIMULATIONS, SOFT_CLAMP, TARGET, TARGET_MECHANISM, VALUES, VARIABLE, WEIGHT
+from psyneulink.core.globals.keywords import AFTER, ALL, BEFORE, BOLD, BOTH, COMPARATOR_MECHANISM, COMPONENT, COMPOSITION, CONDITIONS, CONTROL, CONTROLLER, CONTROL_SIGNAL, FUNCTIONS, HARD_CLAMP, IDENTITY_MATRIX, INPUT, LABELS, LEARNED_PROJECTION, LEARNING_MECHANISM, MATRIX, MATRIX_KEYWORD_VALUES, MAYBE, MECHANISM, MECHANISMS, MODEL_SPEC_ID_COMPOSITION, MODEL_SPEC_ID_NODES, MODEL_SPEC_ID_PROJECTIONS, MODEL_SPEC_ID_PSYNEULINK, MODEL_SPEC_ID_RECEIVER_MECH, MODEL_SPEC_ID_SENDER_MECH, MONITOR, MONITOR_FOR_CONTROL, NAME, NO_CLAMP, ONLINE, OUTCOME, OUTPUT, OWNER_VALUE, PATHWAY, PROJECTION, PROJECTIONS, PULSE_CLAMP, ROLES, SAMPLE, SIMULATIONS, SOFT_CLAMP, TARGET, TARGET_MECHANISM, VALUES, VARIABLE, WEIGHT
 from psyneulink.core.globals.log import CompositionLog, LogCondition
 from psyneulink.core.globals.parameters import Parameter, ParametersBase
 from psyneulink.core.globals.registry import register_category
@@ -1591,6 +1585,8 @@ class Composition(Composition_Base, metaclass=ComponentsMeta):
     componentType = 'Composition'
     classPreferenceLevel = PreferenceLevel.CATEGORY
 
+    _model_spec_generic_type_name = 'graph'
+
     class Parameters(ParametersBase):
         """
             Attributes
@@ -1615,8 +1611,8 @@ class Parameters(ParametersBase):
                     :type: list
 
         """
-        results = Parameter([], loggable=False)
-        simulation_results = Parameter([], loggable=False)
+        results = Parameter([], loggable=False, pnl_internal=True)
+        simulation_results = Parameter([], loggable=False, pnl_internal=True)
         retain_old_simulation_data = Parameter(False, stateful=False, loggable=False)
 
     class _CompilationData(ParametersBase):
@@ -1651,6 +1647,7 @@ def __init__(
         self._graph_processing = None
         self.nodes = ContentAddressableList(component_type=Component)
         self.required_node_roles = []
+        self.node_ordering = []
 
         # 'env' attr required for dynamic inputs generated by gym forager env
         self.env = None
@@ -1865,7 +1862,7 @@ def _analyze_consideration_queue(self, q, objective_mechanism):
     #                                               NODES
     # ******************************************************************************************************************
 
-    def add_node(self, node, required_roles=None):
+    def add_node(self, node, required_roles=None, context=None):
         """
             Add a Composition Node (`Mechanism` or `Composition`) to the Composition, if it is not already added
 
@@ -1886,12 +1883,15 @@ def add_node(self, node, required_roles=None):
         except AttributeError:
             pass
 
+        node._check_for_composition(context=context)
+
         # Add node to Composition's graph
         if node not in [vertex.component for vertex in
                         self.graph.vertices]:  # Only add if it doesn't already exist in graph
             node.is_processing = True
             self.graph.add_component(node)  # Set incoming edge list of node to empty
             self.nodes.append(node)
+            self.node_ordering.append(node)
             self.nodes_to_roles[node] = set()
 
             self.needs_update_graph = True
@@ -2060,6 +2060,7 @@ def remove_nodes(self, nodes):
             for item in node_role_pairs:
                 self.required_node_roles.remove(item)
             del self.nodes[node]
+            self.node_ordering.remove(node)
 
     def add_required_node_role(self, node, role):
         if role not in NodeRole:
@@ -2705,7 +2706,7 @@ def add_projection(self,
         # Note:  Skip this if **projection** was specified, as it might include parameters that are different
         #        than the existing ones, in which case should use that rather than any existing ones;
         #        will handle any existing Projections that are in the current Composition below.
-        if sender and receiver and not projection:
+        if sender and receiver and projection is None:
             existing_projections = self._check_for_existing_projections(sender=sender,
                                                                receiver=receiver,
                                                                in_composition=False)
@@ -2784,8 +2785,6 @@ def add_projection(self,
         else:
             existing_projections = self._check_for_existing_projections(projection, sender=sender, receiver=receiver)
 
-        # FIX: 9/30/19 - THIS SEEMS TO BE DONE FOR ALL PROJECTIONS, NOT JUST AUTOASSOCIATIVE ONES;
-        #                FILTERS OUT AUTOASSOCIATIVE?
         # KAM HACK 2/13/19 to get hebbian learning working for PSY/NEU 330
         # Add autoassociative learning mechanism + related projections to composition as processing components
         if (sender_mechanism != self.input_CIM
@@ -2804,8 +2803,6 @@ def add_projection(self,
             except CompositionError as c:
                 raise CompositionError(f"{c.args[0]} to {self.name}.")
 
-        # FIX: 9/30/19 - THIS SEEMS TO BE NEEDED FOR ALL PROJECTIONS, NOT JUST AUTOASSOCIATIVE ONES
-        #                FILTERS OUT AUTOASSOCIATIVE?
         # KAM HACK 2/13/19 to get hebbian learning working for PSY/NEU 330
         # Add autoassociative learning mechanism + related projections to composition as processing components
         if not existing_projections:
@@ -3131,10 +3128,14 @@ def _check_for_existing_projections(self,
         return False
 
     def _check_feedback(self, scheduler, context=None):
+        # FIX: 10/2/19 - SHOULD REALLY HANDLE THIS BY DETECTING LOOPS DIRECTLY
         """Check that feedback specification is required for projections to which it has been assigned
+        Rationale:
+            if, after removing the feedback designation of a Projection, structural and functional dependencies
+            are the same, then the designation is not needed so remove it.
         Note:
-        - graph_processing and graph_processing.dependency_dict are used as indications of structural dependencies
-        - scheduler.dependency_dict is used as indication of execution dependencies
+        - graph_processing.dependency_dict is used as indication of structural dependencies
+        - scheduler.dependency_dict is used as indication of functional (execution) dependencies
         """
 
         if scheduler:
@@ -3147,16 +3148,25 @@ def _check_feedback(self, scheduler, context=None):
         else:
             scheduler = self.scheduler
 
+        already_tested = []
         for vertex in [v for v in self.graph.vertices if v.feedback==MAYBE]:
-            projection = vertex.component
+            # projection = vertex.component
             # assert isinstance(projection, Projection), \
             #     f'PROGRAM ERROR: vertex identified with feedback=True that is not a Projection'
-            vertex.feedback = False
+            if vertex in already_tested:
+                continue
+
+            v_set = [v for v in self.graph.vertices
+                     if (v.feedback==MAYBE
+                         and v.component.sender.owner is vertex.component.sender.owner)]
+
+            for v in v_set:
+                v.feedback = False
 
             # Update Composition's graph_processing
             self._update_processing_graph()
 
-            # Update scheduler's consideration_queue based on update of graph_processing
+            # Update scheduler's consideration_queue based on update of graph_processing to detect any new cycles
             try:
                 scheduler._init_consideration_queue_from_graph(self.graph_processing)
             except ValueError:
@@ -3171,15 +3181,17 @@ def _check_feedback(self, scheduler, context=None):
             else:
                 feedback = 'leave'
 
-            # Remove nodes that send and receive feedback projection from feedback_senders and feedback_receivers lists
+            # Remove nodes that send and receive feedback Projection from feedback_senders and feedback_receivers lists
             if feedback == 'remove':
-                self.feedback_senders.remove(projection.sender.owner)
-                self.feedback_receivers.remove(projection.receiver.owner)
+                self.feedback_senders.remove(v.component.sender.owner)
+                self.feedback_receivers.remove(v.component.receiver.owner)
             # Otherwise, restore feedback assignment and scheduler's consideration_queue
             else:
-                vertex.feedback = True
+                for v in v_set:
+                    v.feedback = True
                 self._update_processing_graph()
                 scheduler._init_consideration_queue_from_graph(self.graph_processing)
+            already_tested.extend(v_set)
 
 
     # ******************************************************************************************************************
@@ -3347,8 +3359,24 @@ def is_spec(entry, desired_type:tc.enum(NODE, PROJECTION)):
                         assert len(duplicate)==1, \
                             f"PROGRAM ERROR: Could not identify duplicate on DuplicateProjectionError " \
                                 f"for {Projection.__name__} between {sender.name} and {receiver.name} " \
-                                f"in call to {repr('add_linear_processing_pathway')} for {self.name}."
-                        proj = duplicate[0]
+                                f"in call to {repr('add_linear_processing_pathway')} for {self.name}."                            
+                        duplicate = duplicate[0]
+                        warning_msg = f"Projection specified between {sender.name} and {receiver.name} " \
+                                      f"in call to 'add_linear_projection' for {self.name} is a duplicate of one"
+                        # IMPLEMENTATION NOTE: Version that allows different Projections between same
+                        #                      sender and receiver in different Compositions
+                        # if duplicate in self.projections:
+                        #     warnings.warn(f"{warning_msg} already in the Composition ({duplicate.name}) "
+                        #                   f"and so will be ignored.")
+                        #     proj=duplicate
+                        # else:
+                        #     if self.prefs.verbosePref:
+                        #         warnings.warn(f" that already exists between those nodes ({duplicate.name}). The "
+                        #                       f"new one will be used; delete it if you want to use the existing one")
+                        # Version that forbids *any* duplicate Projections between same sender and receiver
+                        warnings.warn(f"{warning_msg} that already exists between those nodes ({duplicate.name}) "
+                                      f"and so will be ignored.")
+                        proj=duplicate
 
                     proj = self.add_projection(projection=proj,
                                                sender=sender,
@@ -3966,7 +3994,6 @@ def _create_backpropagation_learning_pathway(self, pathway, learning_rate=0.05,
                                                                                         learned_projection,
                                                                                         learning_rate,
                                                                                         learning_update)
-
             learning_mechanisms.append(learning_mechanism)
             learned_projections.append(learned_projection)
 
@@ -3976,9 +4003,15 @@ def _create_backpropagation_learning_pathway(self, pathway, learning_rate=0.05,
                 projections = self._add_error_projection_to_dependent_learning_mechs(lm)
                 self.add_projections(projections)
 
-        # Suppress no efferent connections warning for error_signal OutputState of last LearningMechanism in sequence
+        # Suppress "no efferent connections" warning for:
+        #    - error_signal OutputState of last LearningMechanism in sequence
+        #    - comparator
         learning_mechanisms[-1].output_states[ERROR_SIGNAL].parameters.require_projection_in_composition.set(False,
                                                                                                              override=True)
+        if comparator:
+            for s in comparator.output_states:
+                s.parameters.require_projection_in_composition.set(False,
+                                                                   override=True)
 
         learning_related_components = {LEARNING_MECHANISM: learning_mechanisms,
                                        COMPARATOR_MECHANISM: comparator,
@@ -4282,6 +4315,7 @@ def add_controller(self, controller:ControlMechanism):
 
         controller.composition = self
         self.controller = controller
+        self.node_ordering.append(controller)
 
         if self.controller.objective_mechanism:
             self.add_node(self.controller.objective_mechanism)
@@ -4442,6 +4476,7 @@ def evaluate(
             base_context=Context(execution_id=None),
             context=None,
             execution_mode=False,
+            return_results=False,
     ):
         """Runs a simulation of the `Composition`, with the specified control_allocation, excluding its
            `controller <Composition.controller>` in order to return the
@@ -4465,7 +4500,7 @@ def evaluate(
 
         context.add_flag(ContextFlags.SIMULATION)
         context.remove_flag(ContextFlags.CONTROL)
-        self.run(inputs=inputs,
+        results = self.run(inputs=inputs,
                  context=context,
                  runtime_params=runtime_params,
                  num_trials=num_simulation_trials,
@@ -4490,10 +4525,16 @@ def evaluate(
         self.controller._update_input_states(context, runtime_params)
         outcome = self.controller.input_state.parameters.value._get(context)
 
-        # Compute net outcome based on the cost of the simulated control allocation (usually, net = outcome - cost)
-        net_outcome = self.controller.compute_net_outcome(outcome, total_cost)
+        if outcome is None:
+            net_outcome = 0.0
+        else:
+            # Compute net outcome based on the cost of the simulated control allocation (usually, net = outcome - cost)
+            net_outcome = self.controller.compute_net_outcome(outcome, total_cost)
 
-        return net_outcome
+        if return_results:
+            return net_outcome, results
+        else:
+            return net_outcome
 
 
     # ******************************************************************************************************************
@@ -7534,29 +7575,86 @@ def __gen_node_wrapper(self, node, simulation=False):
 
         return llvm_func
 
+    @property
     def _dict_summary(self):
         scheduler_dict = {
-            'schedulers': {
-                str(ContextFlags.PROCESSING): self.scheduler._dict_summary()
-            }
+            str(ContextFlags.PROCESSING): self.scheduler._dict_summary
         }
 
-        nodes_dict = {
-            'nodes': {n.name: n._dict_summary() for n in self.nodes}
-        }
+        super_summary = super()._dict_summary
 
-        projections_dict = {
-            'projections': {f'{p.sender.owner.name} to {p.receiver.owner.name}': p._dict_summary() for p in self.projections}
-        }
+        try:
+            super_summary[self._model_spec_id_parameters][MODEL_SPEC_ID_PSYNEULINK]['schedulers'] = scheduler_dict
+        except KeyError:
+            super_summary[self._model_spec_id_parameters][MODEL_SPEC_ID_PSYNEULINK] = {}
+            super_summary[self._model_spec_id_parameters][MODEL_SPEC_ID_PSYNEULINK]['schedulers'] = scheduler_dict
+
+        nodes_dict = {MODEL_SPEC_ID_PSYNEULINK: {}}
+        projections_dict = {MODEL_SPEC_ID_PSYNEULINK: {}}
+
+        additional_projections = []
+        additional_nodes = (
+            [self.controller]
+            if self.controller is not None
+            else []
+        )
+
+        for n in list(self.nodes) + additional_nodes:
+            if not isinstance(n, CompositionInterfaceMechanism):
+                nodes_dict[n.name] = n._dict_summary
+
+            # consider making this more general in the future
+            try:
+                additional_projections.extend(n.control_projections)
+            except AttributeError:
+                pass
+
+        for p in list(self.projections) + additional_projections:
+            has_cim_sender = isinstance(
+                p.sender.owner,
+                CompositionInterfaceMechanism
+            )
+            has_cim_receiver = isinstance(
+                p.receiver.owner,
+                CompositionInterfaceMechanism
+            )
+
+            # filter projections to/from CIMs, unless they are to embedded
+            # compositions (any others should be automatically generated)
+            if (
+                (not has_cim_sender or p.sender.owner.composition in self.nodes)
+                and (
+                    not has_cim_receiver
+                    or p.receiver.owner.composition in self.nodes
+                )
+            ):
+                p_summary = p._dict_summary
+
+                if has_cim_sender:
+                    p_summary[MODEL_SPEC_ID_SENDER_MECH] = p.sender.owner.composition.name
+
+                if has_cim_receiver:
+                    p_summary[MODEL_SPEC_ID_RECEIVER_MECH] = p.receiver.owner.composition.name
+
+                projections_dict[p.name] = p_summary
+
+        if len(nodes_dict[MODEL_SPEC_ID_PSYNEULINK]) == 0:
+            del nodes_dict[MODEL_SPEC_ID_PSYNEULINK]
+
+        if len(projections_dict[MODEL_SPEC_ID_PSYNEULINK]) == 0:
+            del projections_dict[MODEL_SPEC_ID_PSYNEULINK]
 
         return {
-            **super()._dict_summary(),
-            **scheduler_dict,
-            **nodes_dict,
-            **projections_dict,
+            MODEL_SPEC_ID_COMPOSITION: [{
+                **super_summary,
+                **{
+                    MODEL_SPEC_ID_NODES: nodes_dict,
+                    MODEL_SPEC_ID_PROJECTIONS: projections_dict,
+                    'controller': self.controller,
+                }
+            }]
         }
 
-
     # ******************************************************************************************************************
     #                                           PROPERTIES
     # ******************************************************************************************************************
diff --git a/psyneulink/core/globals/__init__.py b/psyneulink/core/globals/__init__.py
index a8949f76977..2a2118c9d38 100644
--- a/psyneulink/core/globals/__init__.py
+++ b/psyneulink/core/globals/__init__.py
@@ -1,6 +1,7 @@
 from . import context
 from . import defaults
 from . import environment
+from . import json
 from . import keywords
 from . import kvo
 from . import log
@@ -13,6 +14,7 @@
 from .context import *
 from .defaults import *
 from .environment import *
+from .json import *
 from .keywords import *
 from .kvo import *
 from .log import *
@@ -25,6 +27,7 @@
 __all__ = list(context.__all__)
 __all__.extend(defaults.__all__)
 __all__.extend(environment.__all__)
+__all__.extend(json.__all__)
 __all__.extend(keywords.__all__)
 __all__.extend(kvo.__all__)
 __all__.extend(log.__all__)
diff --git a/psyneulink/core/globals/json.py b/psyneulink/core/globals/json.py
new file mode 100644
index 00000000000..09d8173e3df
--- /dev/null
+++ b/psyneulink/core/globals/json.py
@@ -0,0 +1,946 @@
+"""
+
+Sections
+--------
+
+  * `JSON_Overview`
+  * `JSON_Examples`
+  * `JSON_Model_Specification`
+
+.. _JSON_Overview:
+
+Overview
+--------
+
+The developers of PsyNeuLink are collaborating with the scientific
+community to create a common data format for sharing and replicating
+models. As part of this effort, PsyNeuLink includes the ability to
+export models into JSON, and generate valid Python scripts from this
+JSON.
+
+Each Component can be dumped to JSON using its `json_summary`
+method, which uses its `_dict_summary <Component._dict_summary>`.
+Passing this output into `generate_script_from_json` will produce a
+valid Python script replicating the original model.
+
+.. _JSON_Examples:
+
+Model Examples
+--------------
+
+Below is a Stroop model with conflict monitoring and its output
+in JSON. Running `generate_script_from_json` on the output will produce
+another PsyNeuLink script which will give the same results when run
+on the same input as the original.
+
+:download:`Download stroop_conflict_monitoring.py
+<../../tests/json/stroop_conflict_monitoring.py>`
+
+:download:`Download stroop_conflict_monitoring.json
+<../../docs/source/_static/stroop_conflict_monitoring.json>`
+
+.. _JSON_Model_Specification:
+
+JSON Model Specification
+------------------------
+
+.. note::
+    The JSON format is in early development, and is subject to change.
+
+
+The outermost level of a JSON model is a dictionary with entry \
+``graphs``, a list of Composition objects.
+
+Each Component's JSON object contains multiple entries. Those that are
+common to all are:
+
+* ``name`` : a label for the Component
+
+* ``parameters`` (non-`Function`\\ s) / ``args`` (`Function`\\ s) : a \
+dictionary where each entry is either a `Parameter` name and value, or \
+a subdictionary of modeling-environment specific parameters. For \
+PsyNeuLink, this is indicated by `PNL`:
+
+
+.. code-block:: javascript
+
+    "args": {
+        "PNL": {
+            "execution_count": 0,
+            "has_initializers": false,
+            "variable": [
+                0.01
+            ]
+        },
+        "bounds": null,
+        "intercept": 0.0,
+        "slope": 1.0
+    }
+
+Note that the value of a parameter may be a long-form dictionary when \
+it corresponds to a `ParameterState`. In this case, it will indicate \
+the ParameterState in a `source<>` field:
+
+.. code-block:: javascript
+
+    "intercept": {
+        "source": "A.input_ports.intercept",
+        "type": "float",
+        "value": 2.0
+    }
+
+* ``type`` : a dictionary with entries based on modeling environment \
+to describe the type of the object. The `generic` entry is \
+populated if the object has a universal name (such as a linear \
+function). Modeling-environment-specific entries are populated when \
+relevant.
+
+.. code-block:: javascript
+
+    "type": {
+        "PNL": "Composition",
+        "generic": "graph"
+    }
+
+
+**Mechanisms**, **Projections**, and **States** each have:
+
+* ``functions`` : a list of primary `Function` JSON objects. In \
+PsyNeuLink, only one primary function is allowed.
+
+.. code-block:: javascript
+
+    "functions": [
+        {
+            "args": {
+                "intercept": {
+                    "source": "A.input_ports.intercept",
+                    "type": "float",
+                    "value": 2.0
+                },
+                "slope": {
+                    "source": "A.input_ports.slope",
+                    "type": "float",
+                    "value": 5.0
+                }
+            },
+            "name": "Linear Function-1",
+            "type": {
+                "generic": "Linear"
+            }
+        }
+    ]
+
+**Mechanisms** have:
+
+* ``input_ports`` : a list of InputState and ParameterState JSON objects
+
+* ``output_ports`` : a list of OutputState JSON objects
+
+**Projections** have:
+
+* ``sender`` : the name of the Component it projects from
+
+* ``sender_port`` : the name of the port on the ``sender`` to which it \
+connects
+
+* ``receiver`` : the name of the Component it projects to
+
+* ``receiver_port`` : the name of the port on the ``receiver`` to \
+which it connects
+
+**States** have:
+
+* ``dtype`` : the type of accepted input/output for the State. This \
+corresponds to `numpy.dtype <https://docs.scipy.org/doc/numpy/ \
+reference/generated/numpy.dtype.html>`_
+
+* ``shape`` : the shape of the accepted input/output. This corresponds \
+to numpy ndarray shapes. (`numpy.zeros(<shape>)` would produce an \
+array with the correct shape)
+
+**Compositions** have:
+
+* ``nodes`` : a dictionary of Mechanisms or Compositions keyed on \
+their names that are part of the Composition
+
+* ``edges`` : a dictionary of Projections keyed on their names that \
+connect nodes of the Composition
+
+* ``controller`` : the name of the Mechanism in the Composition's \
+nodes that serves as the Composition's \
+`controller <Composition_Controller>`, if it exists
+
+
+"""
+
+import abc
+import base64
+import binascii
+import dill
+import enum
+import json
+import numpy
+import pickle
+import psyneulink
+import re
+import types
+
+from psyneulink.core.globals.keywords import MODEL_SPEC_ID_COMPOSITION, MODEL_SPEC_ID_GENERIC, MODEL_SPEC_ID_NODES, MODEL_SPEC_ID_PARAMETER_SOURCE, MODEL_SPEC_ID_PARAMETER_VALUE, MODEL_SPEC_ID_PROJECTIONS, MODEL_SPEC_ID_PSYNEULINK, MODEL_SPEC_ID_RECEIVER_MECH, MODEL_SPEC_ID_SENDER_MECH, MODEL_SPEC_ID_TYPE
+from psyneulink.core.globals.sampleiterator import SampleIterator
+from psyneulink.core.globals.utilities import get_all_explicit_arguments, parse_string_to_psyneulink_object_string, parse_valid_identifier, safe_equals
+
+__all__ = [
+    'PNLJSONError', 'JSONDumpable', 'PNLJSONEncoder',
+    'generate_script_from_json'
+]
+
+
+class PNLJSONError(Exception):
+    pass
+
+
+class JSONDumpable:
+    @property
+    @abc.abstractmethod
+    def _dict_summary(self):
+        pass
+
+    @property
+    def json_summary(self):
+        return json.dumps(
+            self._dict_summary,
+            sort_keys=True,
+            indent=4,
+            separators=(',', ': '),
+            cls=PNLJSONEncoder
+        )
+
+
+class PNLJSONEncoder(json.JSONEncoder):
+    """
+        A `JSONEncoder
+        <https://docs.python.org/3/library/json.html#json.JSONEncoder>`_
+        that parses `_dict_summary <Component._dict_summary>` output
+        into a more JSON-friendly format.
+    """
+    def default(self, o):
+        from psyneulink.core.components.component import Component, ComponentsMeta
+
+        if isinstance(o, type):
+            if o.__module__ == 'builtins':
+                # just give standard type, like float or int
+                return f'{o.__name__}'
+            elif o is numpy.ndarray:
+                return f'{o.__module__}.array'
+            else:
+                return f'{o.__module__}.{o.__name__}'
+        elif isinstance(o, (enum.Enum, types.FunctionType)):
+            return str(o)
+        elif o is NotImplemented:
+            return None
+        elif isinstance(o, Component):
+            return o.name
+        elif isinstance(o, ComponentsMeta):
+            return o.__name__
+        elif isinstance(o, SampleIterator):
+            return f'{o.__class__.__name__}({repr(o.specification)})'
+        elif isinstance(o, numpy.ndarray):
+            return list(o)
+        elif isinstance(o, numpy.random.RandomState):
+            return f'numpy.random.RandomState({o.seed})'
+        else:
+            try:
+                # convert numpy number type to python type
+                return o.item()
+            except AttributeError:
+                pass
+
+        return super().default(o)
+
+
+def _parse_component_type(component_dict):
+    try:
+        type_str = component_dict[MODEL_SPEC_ID_TYPE][MODEL_SPEC_ID_PSYNEULINK]
+    except (TypeError, KeyError):
+        try:
+            type_str = component_dict[MODEL_SPEC_ID_TYPE][MODEL_SPEC_ID_GENERIC]
+        except (TypeError, KeyError) as e:
+            raise PNLJSONError(
+                f'{component_dict} not a Component type'
+            ) from e
+
+    try:
+        # gets the actual psyneulink type (Component, etc..) from the module
+        return getattr(psyneulink, type_str)
+    except AttributeError as e:
+        raise PNLJSONError(
+            'Invalid PsyNeuLink type specified for JSON object: {0}'.format(
+                component_dict
+            )
+        ) from e
+
+
+def _parse_parameter_value(value, component_identifiers=None):
+    if component_identifiers is None:
+        component_identifiers = {}
+
+    exec('import numpy')
+
+    if isinstance(value, list):
+        value = [_parse_parameter_value(x, component_identifiers) for x in value]
+        value = f"[{', '.join([str(x) for x in value])}]"
+    elif isinstance(value, dict):
+        if (
+            MODEL_SPEC_ID_PARAMETER_SOURCE in value
+            and MODEL_SPEC_ID_PARAMETER_VALUE in value
+        ):
+            # handle ParameterState spec
+            try:
+                value_type = eval(value[MODEL_SPEC_ID_TYPE])
+            except Exception as e:
+                raise PNLJSONError(
+                    'Invalid python type specified in JSON object: {0}'.format(
+                        value[MODEL_SPEC_ID_TYPE]
+                    )
+                ) from e
+
+            value = _parse_parameter_value(
+                value[MODEL_SPEC_ID_PARAMETER_VALUE],
+                component_identifiers
+            )
+
+            # handle tuples and numpy arrays, which both are dumped
+            # as lists in JSON form
+            if value_type is tuple:
+                # convert list brackets to tuple brackets
+                assert value[0] == '[' and value[-1] == ']'
+                value = f'({value[1:-1]})'
+            elif value_type is numpy.ndarray:
+                value = f'{value[MODEL_SPEC_ID_TYPE]}({value})'
+
+        else:
+            # it is either a Component spec or just a plain dict
+            try:
+                # try handling as a Component spec
+                identifier = parse_valid_identifier(value['name'])
+                if (
+                    identifier in component_identifiers
+                    and component_identifiers[identifier]
+                ):
+                    # if this spec is already created as a node elsewhere,
+                    # then just use a reference
+                    value = identifier
+                else:
+                    value = _generate_component_string(
+                        value,
+                        component_identifiers
+                    )
+            except (PNLJSONError, KeyError):
+                # standard dict handling
+                value = '{{{0}}}'.format(
+                    ', '.join([
+                        '{0}: {1}'.format(
+                            str(_parse_parameter_value(k, component_identifiers)),
+                            str(_parse_parameter_value(v, component_identifiers))
+                        )
+                        for k, v in value.items()
+                    ])
+                )
+
+    elif isinstance(value, str):
+        obj_string = parse_string_to_psyneulink_object_string(value)
+        if obj_string is not None:
+            return f'psyneulink.{obj_string}'
+
+        # handle dill string
+        try:
+            dill_str = base64.decodebytes(bytes(value, 'utf-8'))
+            dill.loads(dill_str)
+            return f'dill.loads({dill_str})'
+        except (binascii.Error, pickle.UnpicklingError):
+            pass
+
+        # handle IO port specification
+        match = re.match(r'(.+)\.(.+)_ports\.(.+)', value)
+        if match is not None:
+            comp_name, state_type, name = match.groups()
+            comp_identifer = parse_valid_identifier(comp_name)
+
+            if comp_identifer in component_identifiers:
+                name_as_kw = parse_string_to_psyneulink_object_string(name)
+                if name_as_kw is not None:
+                    name = f'psyneulink.{name_as_kw}'
+                else:
+                    name = f"'{name}'"
+
+                return f'{comp_identifer}.{state_type}_states[{name}]'
+
+        # if value is just a non-fixed component name, use the fixed name
+        identifier = parse_valid_identifier(value)
+        if identifier in component_identifiers:
+            value = identifier
+
+        # handle generic string
+        if (
+            value not in component_identifiers
+            # assume a string that contains a dot is a command, not a raw
+            # string, this is definitely imperfect and can't handle the
+            # legitimate case, but don't know how to distinguish..
+            and '.' not in value
+        ):
+            value = f"'{value}'"
+
+    return value
+
+
+def _generate_component_string(
+    component_dict,
+    component_identifiers,
+    assignment=False,
+):
+    component_type = _parse_component_type(component_dict)
+
+    name = component_dict['name']
+    parameters = dict(component_dict[component_type._model_spec_id_parameters])
+
+    # If there is a parameter that is the psyneulink identifier string
+    # (as of this comment, 'pnl'), then expand these parameters as
+    # normal ones. We don't check and expand for other
+    # special strings here, because we assume that these are specific
+    # to other modeling platforms.
+    try:
+        parameters.update(parameters[MODEL_SPEC_ID_PSYNEULINK])
+        del parameters[MODEL_SPEC_ID_PSYNEULINK]
+    except KeyError:
+        pass
+
+    # pnl objects only have one function unless specified in another way
+    # than just "function"
+    try:
+        parameters['function'] = component_dict['functions'][0]
+    except KeyError:
+        pass
+
+    assignment_str = f'{parse_valid_identifier(name)} = ' if assignment else ''
+
+    additional_arguments = []
+    # get the nonvariable arg and keyword arguments for the component's
+    # constructor
+    constructor_arguments = get_all_explicit_arguments(
+        component_type,
+        '__init__'
+    )
+
+    # put name as first argument
+    if 'name' in constructor_arguments:
+        additional_arguments.append(f"name='{name}'")
+
+    # sort on arg name
+    for arg, val in sorted(parameters.items(), key=lambda p: p[0]):
+        try:
+            constructor_parameter_name = getattr(component_type.parameters, arg).constructor_argument
+            # Some Parameters may be stored just to be replicated here, and
+            # they may have different names than are used in the
+            # constructor of the object.
+            # Examples:
+            #   ControlMechanism.control_spec / control_signals
+            #   Mechanism.input_states_spec / input_states
+            #   Mechanism.output_states_spec / output_states
+            if constructor_parameter_name is not None:
+                constructor_arg = constructor_parameter_name
+            else:
+                constructor_arg = arg
+        except AttributeError:
+            constructor_arg = arg
+
+        if constructor_arg in constructor_arguments:
+            val = _parse_parameter_value(val, component_identifiers)
+            default_val = getattr(component_type.defaults, arg)
+
+            # val may be a string that evaluates to the default value
+            # also skip listing in constructor in this case
+            try:
+                evaled_val = eval(val)
+            except (TypeError, NameError, ValueError):
+                evaled_val = NotImplemented
+            except Exception:
+                # Assume this occurred in creation of a Component
+                # that probably needs some hidden/automatic modification.
+                # Special handling here?
+                evaled_val = NotImplemented
+
+            # skip specifying parameters that match the class defaults
+            if (
+                not safe_equals(val, default_val)
+                and (
+                    evaled_val is NotImplemented
+                    or not safe_equals(evaled_val, default_val)
+                )
+            ):
+                # test for dill use/equivalence
+                try:
+                    is_dill_str = val[:5] == 'dill.'
+                except TypeError:
+                    is_dill_str = False
+
+                if (
+                    not is_dill_str
+                    or dill.dumps(eval(val)) != dill.dumps(default_val)
+                ):
+                    additional_arguments.append(f'{constructor_arg}={val}')
+
+    output = '{0}psyneulink.{1}{2}{3}{4}'.format(
+        assignment_str,
+        component_type.__name__,
+        '(' if len(additional_arguments) > 0 else '',
+        ', '.join(additional_arguments),
+        ')' if len(additional_arguments) > 0 else '',
+    )
+
+    return output
+
+
+def _generate_scheduler_string(
+    scheduler_id,
+    scheduler_dict,
+    component_identifiers,
+    blacklist=[]
+):
+    output = []
+    for node, condition in scheduler_dict['conditions']['node'].items():
+        if node not in blacklist:
+            output.append(
+                '{0}.add_condition({1}, {2})'.format(
+                    scheduler_id,
+                    parse_valid_identifier(node),
+                    _generate_condition_string(
+                        condition,
+                        component_identifiers
+                    )
+                )
+            )
+
+    output.append('')
+
+    termination_str = []
+    for scale, cond in scheduler_dict['conditions']['termination'].items():
+        termination_str.insert(
+            1,
+            'psyneulink.{0}: {1}'.format(
+                scale,
+                _generate_condition_string(cond, component_identifiers)
+            )
+        )
+
+    output.append(
+        '{0}.termination_conds = {{{1}}}'.format(
+            scheduler_id,
+            ', '.join(termination_str)
+        )
+    )
+
+    return '\n'.join(output)
+
+
+def _generate_condition_string(condition_dict, component_identifiers):
+    def _parse_condition_arg_value(value):
+        pnl_str = parse_string_to_psyneulink_object_string(value)
+        try:
+            identifier = parse_valid_identifier(value)
+        except TypeError:
+            identifier = None
+
+        if identifier in component_identifiers:
+            return identifier
+        elif pnl_str is not None:
+            return f'psyneulink.{pnl_str}'
+        else:
+            return str(value)
+
+    args_str = ''
+
+    if len(condition_dict['args']) > 0:
+        arg_str_list = []
+        for arg in condition_dict['args']:
+            # handle nested Conditions
+            try:
+                arg = _generate_condition_string(arg, component_identifiers)
+            except TypeError:
+                pass
+
+            arg_str_list.append(_parse_condition_arg_value(arg))
+        args_str = f", {', '.join(arg_str_list)}"
+
+    kwargs_str = ''
+    if len(condition_dict['kwargs']) > 0:
+        kwarg_str_list = []
+        for key, val in condition_dict['kwargs'].items():
+            kwarg_str_list.append(f'{key}={_parse_condition_arg_value(val)}')
+        kwargs_str = f", {', '.join(kwarg_str_list)}"
+
+    arguments_str = '{0}{1}{2}'.format(
+        condition_dict['function'] if condition_dict['function'] is not None else '',
+        args_str,
+        kwargs_str
+    )
+    if len(arguments_str) > 0 and arguments_str[0] == ',':
+        arguments_str = arguments_str[2:]
+
+    return f'psyneulink.{condition_dict[MODEL_SPEC_ID_TYPE]}({arguments_str})'
+
+
+def _generate_composition_string(composition_list, component_identifiers):
+    control_mechanism_types = (psyneulink.ControlMechanism, )
+    # these are not actively added to a Composition
+    implicit_types = (
+        psyneulink.ObjectiveMechanism,
+        psyneulink.ControlProjection,
+        psyneulink.AutoAssociativeProjection
+    )
+    output = []
+
+    # may be given multiple compositions
+    for composition_dict in composition_list:
+        comp_type = _parse_component_type(composition_dict)
+        comp_name = composition_dict['name']
+        comp_identifer = parse_valid_identifier(comp_name)
+
+        # get order in which nodes were added
+        # may be node names or dictionaries
+        try:
+            node_order = composition_dict[comp_type._model_spec_id_parameters][MODEL_SPEC_ID_PSYNEULINK]['node_ordering']
+            node_order = {
+                parse_valid_identifier(node['name']) if isinstance(node, dict)
+                else parse_valid_identifier(node): node_order.index(node)
+                for node in node_order
+            }
+            assert all([
+                (parse_valid_identifier(node) in node_order)
+                for node in composition_dict[MODEL_SPEC_ID_NODES]
+            ])
+        except (KeyError, TypeError, AssertionError):
+            # if no node_ordering attribute exists, fall back to
+            # alphabetical order
+            alphabetical = enumerate(
+                sorted(composition_dict[MODEL_SPEC_ID_NODES])
+            )
+            node_order = {
+                parse_valid_identifier(item[1]): item[0]
+                for item in alphabetical
+            }
+
+        # clean up pnl-specific and other software-specific items
+        pnl_specific_items = {}
+        keys_to_delete = []
+
+        for name, node in composition_dict[MODEL_SPEC_ID_NODES].items():
+            try:
+                _parse_component_type(node)
+            except PNLJSONError:
+                # node isn't a node dictionary, but a dict of dicts,
+                # indicating a software-specific set of nodes or
+                # a composition
+                if name == MODEL_SPEC_ID_PSYNEULINK:
+                    pnl_specific_items = node
+
+                if MODEL_SPEC_ID_COMPOSITION not in node:
+                    keys_to_delete.append(name)
+
+        for nodes_dict in pnl_specific_items:
+            for name, node in nodes_dict.items():
+                composition_dict[MODEL_SPEC_ID_NODES][name] = node
+
+        for name_to_delete in keys_to_delete:
+            del composition_dict[MODEL_SPEC_ID_NODES][name_to_delete]
+
+        pnl_specific_items = {}
+        keys_to_delete = []
+        for name, edge in composition_dict[MODEL_SPEC_ID_PROJECTIONS].items():
+            try:
+                _parse_component_type(edge)
+            except PNLJSONError:
+                if name == MODEL_SPEC_ID_PSYNEULINK:
+                    pnl_specific_items = edge
+
+                keys_to_delete.append(name)
+
+        for name, edge in pnl_specific_items.items():
+            # exclude CIM projections because they are automatically
+            # generated
+            if (
+                edge[MODEL_SPEC_ID_SENDER_MECH] != comp_name
+                and edge[MODEL_SPEC_ID_RECEIVER_MECH] != comp_name
+            ):
+                composition_dict[MODEL_SPEC_ID_PROJECTIONS][name] = edge
+
+        for name_to_delete in keys_to_delete:
+            del composition_dict[MODEL_SPEC_ID_PROJECTIONS][name_to_delete]
+
+        # generate string for Composition itself
+        output.append(
+            "{0} = {1}\n".format(
+                comp_identifer,
+                _generate_component_string(
+                    composition_dict,
+                    component_identifiers
+                )
+            )
+        )
+        component_identifiers[comp_identifer] = True
+
+        mechanisms = []
+        compositions = []
+        control_mechanisms = []
+        implicit_mechanisms = []
+
+        # add nested compositions and mechanisms in order they were added
+        # to this composition
+        for name, node in sorted(
+            composition_dict[MODEL_SPEC_ID_NODES].items(),
+            key=lambda item: node_order[parse_valid_identifier(item[0])]
+        ):
+            if MODEL_SPEC_ID_COMPOSITION in node:
+                compositions.append(node[MODEL_SPEC_ID_COMPOSITION])
+            else:
+                component_type = _parse_component_type(node)
+                identifier = parse_valid_identifier(name)
+                if issubclass(component_type, control_mechanism_types):
+                    control_mechanisms.append(node)
+                    component_identifiers[identifier] = True
+                elif issubclass(component_type, implicit_types):
+                    implicit_mechanisms.append(node)
+                else:
+                    mechanisms.append(node)
+                    component_identifiers[identifier] = True
+
+        implicit_names = [
+            x['name']
+            for x in implicit_mechanisms + control_mechanisms
+        ]
+
+        for mech in mechanisms:
+            output.append(
+                _generate_component_string(
+                    mech,
+                    component_identifiers,
+                    assignment=True,
+                )
+            )
+        if len(mechanisms) > 0:
+            output.append('')
+
+        for mech in control_mechanisms:
+            output.append(
+                _generate_component_string(
+                    mech,
+                    component_identifiers,
+                    assignment=True,
+                )
+            )
+
+        if len(control_mechanisms) > 0:
+            output.append('')
+
+        # recursively generate string for inner Compositions
+        for comp in compositions:
+            output.append(
+                _generate_composition_string(
+                    comp,
+                    component_identifiers
+                )
+            )
+        if len(compositions) > 0:
+            output.append('')
+
+        # generate string to add the nodes to this Composition
+        node_roles = {
+            parse_valid_identifier(node): role for (node, role) in
+            composition_dict[comp_type._model_spec_id_parameters][MODEL_SPEC_ID_PSYNEULINK]['required_node_roles']
+        }
+
+        # do not add the controller as a normal node
+        if composition_dict['controller'] is not None:
+            try:
+                controller_name = composition_dict['controller']['name']
+            except TypeError:
+                controller_name = composition_dict['controller']
+        else:
+            controller_name = None
+
+        for name in sorted(
+            composition_dict[MODEL_SPEC_ID_NODES],
+            key=lambda item: node_order[parse_valid_identifier(item)]
+        ):
+            if (
+                name not in implicit_names
+                and name != controller_name
+            ):
+                name = parse_valid_identifier(name)
+
+                output.append(
+                    '{0}.add_node({1}{2})'.format(
+                        comp_identifer,
+                        name,
+                        ', {0}'.format(
+                            _parse_parameter_value(
+                                node_roles[name],
+                                component_identifiers
+                            )
+                        ) if name in node_roles else ''
+                    )
+                )
+        if len(composition_dict[MODEL_SPEC_ID_NODES]) > 0:
+            output.append('')
+
+        # generate string to add the projections
+        for name, projection_dict in composition_dict[MODEL_SPEC_ID_PROJECTIONS].items():
+            projection_type = _parse_component_type(projection_dict)
+
+            if (
+                not issubclass(projection_type, implicit_types)
+                and projection_dict[MODEL_SPEC_ID_SENDER_MECH] not in implicit_names
+                and projection_dict[MODEL_SPEC_ID_RECEIVER_MECH] not in implicit_names
+            ):
+                output.append(
+                    '{0}.add_projection(projection={1}, sender={2}, receiver={3})'.format(
+                        comp_identifer,
+                        _generate_component_string(
+                            projection_dict,
+                            component_identifiers
+                        ),
+                        parse_valid_identifier(
+                            projection_dict[MODEL_SPEC_ID_SENDER_MECH]
+                        ),
+                        parse_valid_identifier(
+                            projection_dict[MODEL_SPEC_ID_RECEIVER_MECH]
+                        ),
+                    )
+                )
+
+        # add controller if it exists (must happen after projections)
+        if controller_name is not None:
+            output.append(
+                '{0}.add_controller({1})'.format(
+                    comp_identifer,
+                    parse_valid_identifier(controller_name)
+                )
+            )
+
+        # add schedulers
+        try:
+            schedulers = composition_dict[comp_type._model_spec_id_parameters][MODEL_SPEC_ID_PSYNEULINK]['schedulers']
+
+            ContextFlags = psyneulink.core.globals.context.ContextFlags
+            scheduler_attr_mappings = {
+                str(ContextFlags.PROCESSING): 'scheduler',
+                str(ContextFlags.LEARNING): 'scheduler_learning',
+            }
+
+            for phase, sched_dict in schedulers.items():
+                try:
+                    sched_attr = scheduler_attr_mappings[phase]
+                except KeyError as e:
+                    raise PNLJSONError(
+                        f'Invalid scheduler phase in JSON: {phase}'
+                    ) from e
+
+                # blacklist automatically generated nodes because they will
+                # not exist in the script namespace
+                output.append('')
+                output.append(
+                    _generate_scheduler_string(
+                        f'{comp_identifer}.{sched_attr}',
+                        sched_dict,
+                        component_identifiers,
+                        blacklist=implicit_names
+                    )
+                )
+
+        except KeyError:
+            pass
+
+    return '\n'.join(output)
+
+
+def generate_script_from_json(model_input):
+    """
+        Generates a Python script from JSON **model_input** in the
+        `general JSON format <JSON_Model_Specification>`
+
+        Arguments
+        ---------
+
+            model_input : str
+                a JSON string in the proper format, or a filename
+                containing such
+    """
+
+    def get_declared_identifiers(composition_list):
+        names = set()
+
+        for composition_dict in composition_list:
+            names.add(parse_valid_identifier(composition_dict['name']))
+            for name, node in composition_dict[MODEL_SPEC_ID_NODES].items():
+                if MODEL_SPEC_ID_COMPOSITION in node:
+                    names.update(
+                        get_declared_identifiers(
+                            node[MODEL_SPEC_ID_COMPOSITION]
+                        )
+                    )
+
+                names.add(parse_valid_identifier(name))
+
+        return names
+
+    # accept either json string or filename
+    try:
+        model_input = open(model_input, 'r').read()
+    except (FileNotFoundError, OSError):
+        pass
+    model_input = json.loads(model_input)
+
+    imports_str = ''
+    if MODEL_SPEC_ID_COMPOSITION in model_input:
+        # maps declared names to whether they are accessible in the script
+        # locals. that is, each of these will be names specified in the
+        # composition and subcomposition nodes, and their value in this dict
+        # will correspond to True if they can be referenced by this name in the
+        # script
+        component_identifiers = {
+            i: False
+            for i in get_declared_identifiers(model_input[MODEL_SPEC_ID_COMPOSITION])
+        }
+
+        comp_str = _generate_composition_string(
+            model_input[MODEL_SPEC_ID_COMPOSITION],
+            component_identifiers
+        )
+    else:
+        comp_str = _generate_component_string(
+            model_input,
+            component_identifiers={},
+            assignment=True
+        )
+
+    module_friendly_name_mapping = {
+        'psyneulink': 'pnl',
+        'dill': 'dill',
+        'numpy': 'np'
+    }
+
+    for module, friendly_name in module_friendly_name_mapping.items():
+        comp_str = re.sub(f'{module}\\.', f'{friendly_name}.', comp_str)
+        if f'{friendly_name}.' in comp_str:
+            imports_str += 'import {0}{1}\n'.format(
+                module,
+                f' as {friendly_name}' if friendly_name != module else ''
+            )
+
+    model_output = '{0}{1}{2}'.format(
+        imports_str,
+        '\n' if len(imports_str) > 0 else '',
+        comp_str
+    )
+
+    return model_output
diff --git a/psyneulink/core/globals/keywords.py b/psyneulink/core/globals/keywords.py
index 28901aa1c94..5846c077c12 100644
--- a/psyneulink/core/globals/keywords.py
+++ b/psyneulink/core/globals/keywords.py
@@ -38,7 +38,7 @@
     'CONTROL_SIGNAL', 'CONTROL_SIGNAL_SPECS', 'CONTROL_SIGNALS', 'CONTROLLED_PARAMS', 'CONTROLLER', 'CORRELATION',
     'COSINE', 'COST_FUNCTION', 'COUNT', 'CROSS_ENTROPY', 'CURRENT_EXECUTION_TIME', 'CUSTOM_FUNCTION', 'CYCLE',
     'DDM_MECHANISM', 'DECAY', 'DEFAULT', 'DEFAULT_CONTROL_MECHANISM', 'DEFAULT_MATRIX',
-    'DEFAULT_PREFERENCE_SET_OWNER', 'DEFAULT_PROCESSING_MECHANISM', 'DEFAULT_SYSTEM',
+    'DEFAULT_PREFERENCE_SET_OWNER', 'DEFAULT_PROCESSING_MECHANISM', 'DEFAULT_SYSTEM', 'DEFAULT_VARIABLE',
     'DEFERRED_ASSIGNMENT', 'DEFERRED_DEFAULT_NAME', 'DEFERRED_INITIALIZATION',
     'DIFFERENCE', 'DIFFERENCE', 'DIFFUSION', 'DISABLE', 'DISABLE_PARAM', 'DIST_FUNCTION_TYPE', 'DIST_MEAN',
     'DIST_SHAPE', 'DISTANCE_FUNCTION', 'DISTANCE_METRICS', 'DISTRIBUTION_FUNCTION_TYPE', 'DIVISION',
@@ -74,6 +74,10 @@
     'MECHANISM_TYPE', 'MECHANISM_VALUE',
     'METRIC', 'MIN_VAL', 'MODE', 'MODULATES','MODULATION', 'MODULATORY_PROJECTION', 'MODULATORY_SIGNAL',
     'MODULATORY_SIGNALS', 'MONITOR', 'MONITOR_FOR_CONTROL', 'MONITOR_FOR_LEARNING', 'MONITOR_FOR_MODULATION',
+    'MODEL_SPEC_ID_GENERIC', 'MODEL_SPEC_ID_INPUT_PORTS', 'MODEL_SPEC_ID_OUTPUT_PORTS', 'MODEL_SPEC_ID_PSYNEULINK',
+    'MODEL_SPEC_ID_SENDER_MECH', 'MODEL_SPEC_ID_SENDER_STATE', 'MODEL_SPEC_ID_RECEIVER_MECH',
+    'MODEL_SPEC_ID_RECEIVER_STATE',
+    'MODEL_SPEC_ID_PARAMETER_SOURCE', 'MODEL_SPEC_ID_PARAMETER_VALUE', 'MODEL_SPEC_ID_TYPE',
     'MULTIPLICATIVE', 'MULTIPLICATIVE_PARAM', 'MUTUAL_ENTROPY',
     'NAME', 'NEWEST',  'NODE', 'NodeRoles', 'NOISE', 'NORMAL_DIST_FUNCTION', 'NORMED_L0_SIMILARITY',
     'OBJECTIVE_FUNCTION_TYPE', 'OBJECTIVE_MECHANISM', 'OBJECTIVE_MECHANISM_OBJECT', 'OFF', 'OFFSET', 'OLDEST',
@@ -985,3 +989,23 @@ def _is_metric(metric):
 
 GAMMA = 'gamma'
 #endregion
+
+# model spec keywords
+MODEL_SPEC_ID_TYPE = 'type'
+MODEL_SPEC_ID_PSYNEULINK = 'PNL'
+MODEL_SPEC_ID_GENERIC = 'generic'
+
+MODEL_SPEC_ID_INPUT_PORTS = 'input_ports'
+MODEL_SPEC_ID_OUTPUT_PORTS = 'output_ports'
+
+MODEL_SPEC_ID_SENDER_MECH = 'sender'
+MODEL_SPEC_ID_SENDER_STATE = 'sender_port'
+MODEL_SPEC_ID_RECEIVER_MECH = 'receiver'
+MODEL_SPEC_ID_RECEIVER_STATE = 'receiver_port'
+
+MODEL_SPEC_ID_PARAMETER_SOURCE = 'source'
+MODEL_SPEC_ID_PARAMETER_VALUE = 'value'
+
+MODEL_SPEC_ID_NODES = 'nodes'
+MODEL_SPEC_ID_PROJECTIONS = 'edges'
+MODEL_SPEC_ID_COMPOSITION = 'graphs'
diff --git a/psyneulink/core/globals/parameters.py b/psyneulink/core/globals/parameters.py
index 3c6f5695bdc..0791d468826 100644
--- a/psyneulink/core/globals/parameters.py
+++ b/psyneulink/core/globals/parameters.py
@@ -248,9 +248,7 @@ def _recurrent_transfer_mechanism_matrix_setter(value, owning_component=None, co
 from psyneulink.core.globals.context import Context, ContextError, ContextFlags, _get_time, handle_external_context
 from psyneulink.core.globals.context import time as time_object
 from psyneulink.core.globals.log import LogCondition, LogEntry, LogError
-from psyneulink.core.globals.utilities import \
-    call_with_pruned_args, copy_dict_or_list_with_shared, get_alias_property_getter, get_alias_property_setter, \
-    get_deepcopy_with_shared, unproxy_weakproxy
+from psyneulink.core.globals.utilities import call_with_pruned_args, copy_iterable_with_shared, get_alias_property_getter, get_alias_property_setter, get_deepcopy_with_shared, unproxy_weakproxy
 
 __all__ = [
     'Defaults', 'get_validator_by_function', 'get_validator_by_type_only', 'Parameter', 'ParameterAlias', 'ParameterError',
@@ -514,6 +512,12 @@ class Parameter(types.SimpleNamespace):
 
             :Developer Notes: Can be manually set, but will trigger a warning unless override=True
 
+        pnl_internal
+            whether the parameter is an idiosyncrasy of PsyNeuLink or it is more intrinsic to the conceptual operation
+            of the Component on which it resides
+
+            :default: False
+
         aliases
             other names by which the parameter goes (e.g. allocation is the same as variable for ControlSignal).
 
@@ -597,6 +601,16 @@ class Parameter(types.SimpleNamespace):
             inspection.
 
             :default: False
+
+        constructor_argument
+            if not None, this indicates the argument in the owning Component's
+            constructor that this Parameter corresponds to. Typically this is
+            used in Parameters that save specification types, as in
+            `input_states_spec <Mechanism.input_states_spec>` and
+            `output_states_spec <Mechanism.output_states_spec>`
+
+            :default: None
+
     """
     # The values of these attributes will never be inherited from parent Parameters
     # KDM 7/12/18: consider inheriting ONLY default_value?
@@ -604,7 +618,7 @@ class Parameter(types.SimpleNamespace):
 
     # for user convenience - these attributes will be hidden from the repr
     # display if the function is True based on the value of the attribute
-    _hidden_if_unset_attrs = {'aliases', 'getter', 'setter'}
+    _hidden_if_unset_attrs = {'aliases', 'getter', 'setter', 'constructor_argument'}
     _hidden_if_false_attrs = {'read_only', 'modulable', 'fallback_default', 'retain_old_simulation_data'}
     _hidden_when = {
         **{k: lambda self, val: val is None for k in _hidden_if_unset_attrs},
@@ -627,6 +641,7 @@ def __init__(
         modulation_combination_function=None,
         read_only=False,
         function_arg=True,
+        pnl_internal=False,
         aliases=None,
         user=True,
         values=None,
@@ -640,6 +655,7 @@ def __init__(
         history_min_length=0,
         fallback_default=False,
         retain_old_simulation_data=False,
+        constructor_argument=None,
         _owner=None,
         _inherited=False,
         _user_specified=False,
@@ -664,6 +680,7 @@ def __init__(
             modulation_combination_function=modulation_combination_function,
             read_only=read_only,
             function_arg=function_arg,
+            pnl_internal=pnl_internal,
             aliases=aliases,
             user=user,
             values=values,
@@ -677,6 +694,7 @@ def __init__(
             history_min_length=history_min_length,
             fallback_default=fallback_default,
             retain_old_simulation_data=retain_old_simulation_data,
+            constructor_argument=constructor_argument,
             _inherited=_inherited,
             _user_specified=_user_specified,
         )
@@ -1069,7 +1087,7 @@ def _initialize_from_context(self, context=None, base_context=Context(execution_
                 shared_types = (Component, types.MethodType)
 
                 if isinstance(new_val, (dict, list)):
-                    new_val = copy_dict_or_list_with_shared(new_val, shared_types)
+                    new_val = copy_iterable_with_shared(new_val, shared_types)
                 elif not isinstance(new_val, shared_types):
                     new_val = copy.deepcopy(new_val)
 
diff --git a/psyneulink/core/globals/utilities.py b/psyneulink/core/globals/utilities.py
index 5153978ad32..cb465729d35 100644
--- a/psyneulink/core/globals/utilities.py
+++ b/psyneulink/core/globals/utilities.py
@@ -95,6 +95,8 @@
 import inspect
 import logging
 import numbers
+import psyneulink
+import re
 import time
 import warnings
 import weakref
@@ -108,7 +110,7 @@
 
 __all__ = [
     'append_type_to_name', 'AutoNumber', 'ContentAddressableList', 'convert_to_list', 'convert_to_np_array',
-    'convert_all_elements_to_np_array', 'NodeRole', 'get_class_attributes', 'flatten_list',
+    'convert_all_elements_to_np_array', 'copy_iterable_with_shared', 'NodeRole', 'get_class_attributes', 'flatten_list', 'get_all_explicit_arguments',
     'get_modulationOperation_name', 'get_value_from_array', 'is_component',
     'is_distance_metric', 'is_matrix',
     'insert_list', 'is_matrix_spec', 'all_within_range', 'is_iterable',
@@ -116,8 +118,9 @@
     'is_value_spec', 'iscompatible', 'kwCompatibilityLength', 'kwCompatibilityNumeric', 'kwCompatibilityType',
     'make_readonly_property', 'merge_param_dicts',
     'Modulation', 'MODULATION_ADD', 'MODULATION_MULTIPLY','MODULATION_OVERRIDE',
-    'multi_getattr', 'np_array_less_than_2d', 'object_has_single_value', 'optional_parameter_spec', 'normpdf',
-    'parameter_spec', 'powerset', 'random_matrix', 'ReadOnlyOrderedDict', 'safe_len', 'scalar_distance', 'sinusoid',
+    'multi_getattr', 'np_array_less_than_2d', 'object_has_single_value', 'optional_parameter_spec', 'normpdf', 'parse_valid_identifier', 'parse_string_to_psyneulink_object_string',
+    'parameter_spec', 'powerset', 'random_matrix', 'ReadOnlyOrderedDict', 'safe_equals', 'safe_len',
+    'scalar_distance', 'sinusoid',
     'tensor_power', 'TEST_CONDTION', 'type_match',
     'underscore_to_camelCase', 'UtilitiesError', 'unproxy_weakproxy'
 ]
@@ -777,14 +780,16 @@ def __deepcopy__(self, memo):
     return __deepcopy__
 
 
-def copy_dict_or_list_with_shared(obj, shared_types=None):
+def copy_iterable_with_shared(obj, shared_types=None):
     try:
         shared_types = tuple(shared_types)
     except TypeError:
-        shared_types = ()
+        shared_types = (shared_types, )
 
     dict_types = (dict, collections.UserDict)
     list_types = (list, collections.UserList, collections.deque)
+    tuple_types = (tuple, )
+    all_types_using_recursion = dict_types + list_types + tuple_types
 
     if isinstance(obj, dict_types):
         result = obj.__class__()
@@ -792,8 +797,8 @@ def copy_dict_or_list_with_shared(obj, shared_types=None):
             # key can never be unhashable dict or list
             new_k = k if isinstance(k, shared_types) else copy.deepcopy(k)
 
-            if isinstance(v, dict_types + list_types):
-                new_v = copy_dict_or_list_with_shared(v, shared_types)
+            if isinstance(v, all_types_using_recursion):
+                new_v = copy_iterable_with_shared(v, shared_types)
             elif isinstance(v, shared_types):
                 new_v = v
             else:
@@ -804,16 +809,36 @@ def copy_dict_or_list_with_shared(obj, shared_types=None):
             except UtilitiesError:
                 # handle ReadOnlyOrderedDict
                 result.__additem__(new_k, new_v)
-    elif isinstance(obj, list_types):
-        result = obj.__class__()
+
+    elif isinstance(obj, list_types + tuple_types):
+        is_tuple = isinstance(obj, tuple_types)
+        if is_tuple:
+            result = list()
+
+        # If this is a deque, make sure we copy the maxlen parameter as well
+        elif isinstance(obj, collections.deque):
+            # FIXME: Should have a better method for supporting properties like this in general
+            # We could do something like result = copy(obj); result.clear() but that would be
+            # wasteful copying I guess.
+            result = obj.__class__(maxlen=obj.maxlen)
+        else:
+            result = obj.__class__()
+
         for item in obj:
-            if isinstance(item, dict_types + list_types):
-                new_item = copy_dict_or_list_with_shared(item, shared_types)
+            if isinstance(item, all_types_using_recursion):
+                new_item = copy_iterable_with_shared(item, shared_types)
             elif isinstance(item, shared_types):
                 new_item = item
             else:
                 new_item = copy.deepcopy(item)
             result.append(new_item)
+
+        if is_tuple:
+            try:
+                result = obj.__class__(result)
+            except TypeError:
+                # handle namedtuple
+                result = obj.__class__(*result)
     else:
         raise TypeError
 
@@ -1448,11 +1473,14 @@ def insert_list(list1, position, list2):
     """Insert list2 into list1 at position"""
     return list1[:position] + list2 + list1[position:]
 
+
 def convert_to_list(l):
     if l is None:
         return None
     elif isinstance(l, list):
         return l
+    elif isinstance(l, ContentAddressableList):
+        return list(l)
     elif isinstance(l, set):
         return list(l)
     else:
@@ -1461,12 +1489,14 @@ def convert_to_list(l):
 def flatten_list(l):
     return [item for sublist in l for item in sublist]
 
+
 _seed = int(time.monotonic())
 def get_global_seed(offset=1):
     global _seed
     _seed += offset
     return _seed - offset
 
+
 def set_global_seed(new_seed):
     global _seed
     _seed = new_seed
@@ -1484,6 +1514,23 @@ def safe_len(arr, fallback=1):
         return fallback
 
 
+def safe_equals(x, y):
+    """
+        An == comparison that handles numpy's new behavior of returning
+        an array of booleans instead of a single boolean for ==
+    """
+    with warnings.catch_warnings():
+        warnings.simplefilter('error')
+        try:
+            val = x == y
+            if isinstance(val, bool):
+                return val
+            else:
+                raise ValueError
+        except (ValueError, DeprecationWarning, FutureWarning):
+            return np.array_equal(x, y)
+
+
 import typecheck as tc
 @tc.typecheck
 def _get_arg_from_stack(arg_name:str):
@@ -1663,3 +1710,73 @@ def unproxy_weakproxy(proxy):
             True
     """
     return proxy.__repr__.__self__
+
+
+def parse_valid_identifier(orig_identifier):
+    """
+        Returns
+        -------
+            A version of **orig_identifier** with characters replaced
+            so that it is a valid python identifier
+    """
+    change_invalid_beginning = re.sub(r'^([^a-zA-Z_])', r'_\1', orig_identifier)
+    return re.sub(r'[^a-zA-Z0-9_]', '_', change_invalid_beginning)
+
+
+def parse_string_to_psyneulink_object_string(string):
+    """
+        Returns
+        -------
+            a string corresponding to **string** that is an attribute
+            of psyneulink if it exists, otherwise None
+
+            The output of this function will cause
+            getattr(psyneulink, <output>) to return a psyneulink object
+    """
+    try:
+        eval(f'psyneulink.{string}')
+        return string
+    except (AttributeError, SyntaxError, TypeError):
+        pass
+
+    # handle potential psyneulink keyword
+    try:
+        # insert space between camel case words
+        keyword = re.sub('([a-z])([A-Z])', r'\1 \2', string)
+        keyword = keyword.upper().replace(' ', '_')
+        eval(f'psyneulink.{keyword}')
+        return keyword
+    except (AttributeError, SyntaxError, TypeError):
+        pass
+
+    return None
+
+
+def get_all_explicit_arguments(cls_, func_str):
+    """
+        Returns
+        -------
+            all explicitly specified (named) arguments for the function
+            **cls_**.**funct_str** including any arguments specified in
+            functions of the same name on parent classes, if \\*args or
+            \\*\\*kwargs are specified
+    """
+    all_arguments = set()
+
+    for cls_ in cls_.__mro__:
+        func = getattr(cls_, func_str)
+        has_args_or_kwargs = False
+
+        for arg_name, arg in inspect.signature(func).parameters.items():
+            if (
+                arg.kind is inspect.Parameter.VAR_POSITIONAL
+                or arg.kind is inspect.Parameter.VAR_KEYWORD
+            ):
+                has_args_or_kwargs = True
+            else:
+                all_arguments.add(arg_name)
+
+        if not has_args_or_kwargs:
+            break
+
+    return all_arguments
diff --git a/psyneulink/core/scheduling/condition.py b/psyneulink/core/scheduling/condition.py
index 8e39c36a70c..8197ec42bfc 100644
--- a/psyneulink/core/scheduling/condition.py
+++ b/psyneulink/core/scheduling/condition.py
@@ -293,9 +293,13 @@ def converge(mech, thresh):
 """
 
 import collections
+import dill
+import inspect
 import logging
 import warnings
 
+from psyneulink.core.globals.json import JSONDumpable
+from psyneulink.core.globals.keywords import MODEL_SPEC_ID_TYPE
 from psyneulink.core.globals.parameters import parse_context
 from psyneulink.core.globals.utilities import call_with_pruned_args
 from psyneulink.core.scheduling.time import TimeScale
@@ -404,7 +408,7 @@ def add_condition_set(self, conditions):
             self.add_condition(owner, conditions[owner])
 
 
-class Condition(object):
+class Condition(JSONDumpable):
     """
     Used in conjunction with a `Scheduler` to specify the condition under which a `Component` should be
     allowed to execute.
@@ -489,6 +493,33 @@ def is_satisfied(self, *args, context=None, execution_id=None, **kwargs):
             **kwargs_to_pass
         )
 
+    @property
+    def _dict_summary(self):
+        from psyneulink.core.components.component import Component
+
+        if type(self) is Condition:
+            try:
+                func_val = inspect.getsource(self.func)
+            except OSError:
+                func_val = dill.dumps(self.func)
+        else:
+            func_val = None
+
+        args_list = []
+        for a in self.args:
+            if isinstance(a, Component):
+                a = a.name
+            elif isinstance(a, Condition):
+                a = a._dict_summary
+            args_list.append(a)
+
+        return {
+            MODEL_SPEC_ID_TYPE: self.__class__.__name__,
+            'function': func_val,
+            'args': args_list,
+            'kwargs': self.kwargs,
+        }
+
 
 class _DependencyValidation:
     @Condition.owner.setter
diff --git a/psyneulink/core/scheduling/scheduler.py b/psyneulink/core/scheduling/scheduler.py
index d7bff4191d6..e063ae978dc 100644
--- a/psyneulink/core/scheduling/scheduler.py
+++ b/psyneulink/core/scheduling/scheduler.py
@@ -276,6 +276,7 @@
 from toposort import toposort, toposort_flatten
 
 from psyneulink.core.globals.context import Context, handle_external_context
+from psyneulink.core.globals.json import JSONDumpable
 from psyneulink.core.scheduling.condition import All, AllHaveRun, Always, Condition, ConditionSet, EveryNCalls, Never
 from psyneulink.core.scheduling.time import Clock, TimeScale
 
@@ -295,7 +296,7 @@ def __str__(self):
         return repr(self.error_value)
 
 
-class Scheduler(object):
+class Scheduler(JSONDumpable):
     """Generates an order of execution for `Components <Component>` in a `Composition <Composition>` or graph
     specification dictionary, possibly determined by a set of `Conditions <Condition>`.
 
@@ -825,22 +826,19 @@ def run(self, termination_conds=None, context=None, base_context=Context(executi
 
         return self.execution_list[context.execution_id]
 
+    @property
     def _dict_summary(self):
         return {
             'conditions': {
                 'termination': {
-                    str(k): str(v) for k, v in self.termination_conds.items()
+                    str(k): v._dict_summary for k, v in self.termination_conds.items()
                 },
                 'node': {
-                    n.name: str(self.conditions[n]) for n in self.nodes if n in self.conditions
+                    n.name: self.conditions[n]._dict_summary for n in self.nodes if n in self.conditions
                 }
             }
         }
 
-    def json_summary(self):
-        import json
-        return json.dumps(self._dict_summary(), sort_keys=True, indent=4, separators=(',', ': '))
-
     @property
     def clock(self):
         return self.clocks[self.default_execution_id]
diff --git a/psyneulink/library/components/mechanisms/modulatory/control/agt/lccontrolmechanism.py b/psyneulink/library/components/mechanisms/modulatory/control/agt/lccontrolmechanism.py
index 8d379dc88da..550d05c8579 100644
--- a/psyneulink/library/components/mechanisms/modulatory/control/agt/lccontrolmechanism.py
+++ b/psyneulink/library/components/mechanisms/modulatory/control/agt/lccontrolmechanism.py
@@ -846,6 +846,12 @@ def _instantiate_output_states(self, context=None):
 
         super()._instantiate_output_states(context=context)
 
+    def _check_for_composition(self, context=None):
+        from psyneulink.core.compositions.composition import Composition
+        if self.modulated_mechanisms == ALL:
+            raise LCControlMechanismError(f"'ALL' not currently supported for '{MODULATED_MECHANISMS}' argument "
+                                          f"of {self.__class__.__name__} in context of a {Composition.__name__}")
+
     def _execute(
         self,
         variable=None,
diff --git a/psyneulink/library/components/mechanisms/modulatory/control/evc/evcauxiliary.py b/psyneulink/library/components/mechanisms/modulatory/control/evc/evcauxiliary.py
index ce23f87184f..71f4d972260 100644
--- a/psyneulink/library/components/mechanisms/modulatory/control/evc/evcauxiliary.py
+++ b/psyneulink/library/components/mechanisms/modulatory/control/evc/evcauxiliary.py
@@ -92,7 +92,7 @@ class Parameters(Function_Base.Parameters):
                     :type: int
 
         """
-        variable = Parameter(None, read_only=True)
+        variable = Parameter(None, read_only=True, pnl_internal=True, constructor_argument='default_variable')
 
     classPreferences = {
         PREFERENCE_SET_NAME: 'ValueFunctionCustomClassPreferences',
diff --git a/psyneulink/library/components/mechanisms/processing/integrator/ddm.py b/psyneulink/library/components/mechanisms/processing/integrator/ddm.py
index 5379e2cb953..68bd74870fa 100644
--- a/psyneulink/library/components/mechanisms/processing/integrator/ddm.py
+++ b/psyneulink/library/components/mechanisms/processing/integrator/ddm.py
@@ -830,12 +830,13 @@ class Parameters(ProcessingMechanism.Parameters):
     def __init__(self,
                  default_variable=None,
                  size=None,
-                 input_format:tc.optional(tc.enum(SCALAR, ARRAY, VECTOR))=SCALAR,
+                 input_format:tc.optional(tc.enum(SCALAR, ARRAY, VECTOR))=None,
                  function=DriftDiffusionAnalytical(drift_rate=1.0,
                                                    starting_point=0.0,
                                                    threshold=1.0,
                                                    noise=0.5,
                                                    t0=.200),
+                 input_states=None,
                  output_states:tc.optional(tc.any(str, Iterable))=(DECISION_VARIABLE, RESPONSE_TIME),
                  params=None,
                  name=None,
@@ -846,6 +847,13 @@ def __init__(self,
                                                            DDM_standard_output_states,
                                                            indices=SEQUENTIAL)
 
+        if input_format is not None and input_states is not None:
+            raise DDMError(
+                'Only one of input_format and input_states should be specified.'
+            )
+        elif input_format is None:
+            input_format = SCALAR
+
         # If input_format is specified to be ARRAY or VECTOR, instantiate:
         #    InputState with:
         #        2-item array as its variable
@@ -887,9 +895,6 @@ def __init__(self,
 
             ])
 
-        else:
-            input_states = None
-
         # Default output_states is specified in constructor as a tuple rather than a list
         # to avoid "gotcha" associated with mutable default arguments
         # (see: bit.ly/2uID3s3 and http://docs.python-guide.org/en/latest/writing/gotchas/)
@@ -1059,12 +1064,6 @@ def _validate_params(self, request_set, target_set=None, context=None):
                 raise DDMError("PROGRAM ERROR: unrecognized specification for {} of {} ({})".
                                format(THRESHOLD, self.name, threshold))
 
-    def _instantiate_attributes_before_function(self, function=None, context=None):
-        """Delete params not in use, call super.instantiate_execute_method
-        """
-
-        super()._instantiate_attributes_before_function(function=function, context=context)
-
     def _instantiate_plotting_functions(self, context=None):
         if "DriftDiffusionIntegrator" in str(self.function):
             self.get_axes_function = DriftDiffusionIntegrator(rate=self.function_params['rate'],
diff --git a/psyneulink/library/components/mechanisms/processing/integrator/episodicmemorymechanism.py b/psyneulink/library/components/mechanisms/processing/integrator/episodicmemorymechanism.py
index a50e476fb10..444de269dc7 100644
--- a/psyneulink/library/components/mechanisms/processing/integrator/episodicmemorymechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/integrator/episodicmemorymechanism.py
@@ -186,7 +186,7 @@ class Parameters(ProcessingMechanism_Base.Parameters):
                     :type: list
 
         """
-        variable = Parameter([[0]])
+        variable = Parameter([[0]], pnl_internal=True, constructor_argument='default_variable')
 
     def __init__(self,
                  content_size:int=1,
diff --git a/psyneulink/library/components/mechanisms/processing/leabramechanism.py b/psyneulink/library/components/mechanisms/processing/leabramechanism.py
index cf0f81de001..24cbd1d62da 100644
--- a/psyneulink/library/components/mechanisms/processing/leabramechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/leabramechanism.py
@@ -215,7 +215,7 @@ class Parameters(Function_Base.Parameters):
                     :type:
 
         """
-        variable = Parameter(np.array([[0], [0]]), read_only=True)
+        variable = Parameter(np.array([[0], [0]]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         network = None
 
     def __init__(self,
diff --git a/psyneulink/library/components/mechanisms/processing/objective/comparatormechanism.py b/psyneulink/library/components/mechanisms/processing/objective/comparatormechanism.py
index 5e327de6122..c75237d196d 100644
--- a/psyneulink/library/components/mechanisms/processing/objective/comparatormechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/objective/comparatormechanism.py
@@ -343,7 +343,7 @@ class Parameters(ObjectiveMechanism.Parameters):
 
         """
         # By default, ComparatorMechanism compares two 1D np.array input_states
-        variable = Parameter(np.array([[0], [0]]), read_only=True)
+        variable = Parameter(np.array([[0], [0]]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         function = Parameter(LinearCombination(weights=[[-1], [1]]), stateful=False, loggable=False)
         sample = None
         target = None
diff --git a/psyneulink/library/components/mechanisms/processing/objective/predictionerrormechanism.py b/psyneulink/library/components/mechanisms/processing/objective/predictionerrormechanism.py
index c1f74e93f77..6955d5e4feb 100644
--- a/psyneulink/library/components/mechanisms/processing/objective/predictionerrormechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/objective/predictionerrormechanism.py
@@ -284,7 +284,7 @@ class Parameters(ComparatorMechanism.Parameters):
 
         """
 
-        variable = Parameter(None, read_only=True)
+        variable = Parameter(None, read_only=True, pnl_internal=True, constructor_argument='default_variable')
         learning_rate = Parameter(0.3, modulable=True)
         function = PredictionErrorDeltaFunction
         sample = None
diff --git a/psyneulink/library/components/mechanisms/processing/transfer/lcamechanism.py b/psyneulink/library/components/mechanisms/processing/transfer/lcamechanism.py
index 98c8cd6e782..9503eaca956 100644
--- a/psyneulink/library/components/mechanisms/processing/transfer/lcamechanism.py
+++ b/psyneulink/library/components/mechanisms/processing/transfer/lcamechanism.py
@@ -536,12 +536,6 @@ class Parameters(RecurrentTransferMechanism.Parameters):
                     :default value: 0.5
                     :type: float
 
-                matrix
-                    see `matrix <LCAMechanism.matrix>`
-
-                    :default value: None
-                    :type:
-
                 self_excitation
                     see `self_excitation <LCAMechanism.self_excitation>`
 
@@ -557,10 +551,10 @@ class Parameters(RecurrentTransferMechanism.Parameters):
         """
         function = Parameter(Logistic, stateful=False, loggable=False)
 
-        matrix = Parameter(None, modulable=True)
         leak = Parameter(0.5, modulable=True)
+        auto = Parameter(0.0, modulable=True, aliases='self_excitation')
+        hetero = Parameter(-1.0, modulable=True)
         competition = Parameter(1.0, modulable=True)
-        self_excitation = Parameter(0.0, modulable=True)
         time_step_size = Parameter(0.1, modulable=True)
 
         initial_value = None
@@ -583,8 +577,9 @@ def __init__(self,
                  function=Logistic,
                  initial_value=None,
                  leak=0.5,
-                 competition=1.0,
-                 self_excitation=0.0,
+                 competition=None,
+                 hetero=None,
+                 self_excitation=None,
                  noise=0.0,
                  integrator_mode=True,
                  time_step_size=0.1,
@@ -608,6 +603,20 @@ def __init__(self,
                           "args")
         # matrix = np.full((size[0], size[0]), -inhibition) * get_matrix(HOLLOW_MATRIX,size[0],size[0])
 
+        if competition is not None and hetero is not None:
+            if competition != -1.0 * hetero:
+                raise LCAError(
+                    'Both competition and hetero are specified. competition '
+                    'must have the same magnitude but opposite sign of hetero. '
+                    'Provided values: competition = {0} , hetero = {1}'.format(
+                        competition,
+                        hetero
+                    )
+                )
+        elif competition is not None:
+            hetero = -competition
+        elif hetero is not None:
+            competition = -hetero
 
         integrator_function = LeakyCompetingIntegrator
 
@@ -615,6 +624,7 @@ def __init__(self,
         params = self._assign_args_to_param_dicts(input_states=input_states,
                                                   leak=leak,
                                                   self_excitation=self_excitation,
+                                                  hetero=hetero,
                                                   competition=competition,
                                                   integrator_mode=integrator_mode,
                                                   time_step_size=time_step_size,
@@ -630,7 +640,7 @@ def __init__(self,
                          size=size,
                          input_states=input_states,
                          auto=self_excitation,
-                         hetero=-competition,
+                         hetero=hetero,
                          function=function,
                          integrator_function=LeakyCompetingIntegrator,
                          initial_value=initial_value,
diff --git a/psyneulink/library/components/projections/pathway/autoassociativeprojection.py b/psyneulink/library/components/projections/pathway/autoassociativeprojection.py
index 7ee198a4c52..06bf34bea0a 100644
--- a/psyneulink/library/components/projections/pathway/autoassociativeprojection.py
+++ b/psyneulink/library/components/projections/pathway/autoassociativeprojection.py
@@ -282,7 +282,7 @@ class Parameters(MappingProjection.Parameters):
                     :type: str
 
         """
-        variable = Parameter(np.array([[0]]), read_only=True)
+        variable = Parameter(np.array([[0]]), read_only=True, pnl_internal=True, constructor_argument='default_variable')
         # function is always LinearMatrix that requires 1D input
         function = LinearMatrix
 
diff --git a/psyneulink/library/compositions/autodiffcomposition.py b/psyneulink/library/compositions/autodiffcomposition.py
index b28cd6acb29..090cbba2ce6 100644
--- a/psyneulink/library/compositions/autodiffcomposition.py
+++ b/psyneulink/library/compositions/autodiffcomposition.py
@@ -523,10 +523,6 @@ def __init__(self,
 
         self.min_delta = min_delta
 
-        # CW 11/1/18: maybe we should make scheduler a property, like in Composition
-        # # MODIFIED 10/2/19 OLD:
-        # self.scheduler = None
-        # MODIFIED 10/2/19 NEW: [JDC]
         if not disable_cuda and torch.cuda.is_available():
             if cuda_index is None:
                 self.device = torch.device('cuda')
@@ -565,7 +561,10 @@ def _build_pytorch_representation(self, context=None):
         if self.loss is not None:
             logger.warning("Overwriting loss function for AutodiffComposition {}! Old loss function: {}".format(
                 self, self.loss))
-        self.loss = self._get_loss(self.loss_spec)
+        if callable(self.loss_spec):
+            self.loss = self.loss_spec
+        else:
+            self.loss = self._get_loss(self.loss_spec)
 
     def _make_optimizer(self, optimizer_type, learning_rate, weight_decay, context):
         if not isinstance(learning_rate, (int, float)):
@@ -734,17 +733,18 @@ def autodiff_training(self, inputs, targets, total_epochs, curr_epoch, context=N
 
         # backpropagate to compute gradients and perform learning update for parameters
         optimizer.zero_grad()
-        curr_loss = curr_loss / num_inputs / 2
+        curr_loss = curr_loss / \
+                    num_inputs / \
+                    2
         printable = {}
         for component in curr_tensor_outputs.keys():
             printable[component] = curr_tensor_outputs[component].detach().numpy()
-        np.set_printoptions(precision=3)
         if self.force_no_retain_graph:
             curr_loss.backward(retain_graph=False)
         else:
             curr_loss.backward(retain_graph=True)
-        self.parameters.pytorch_representation._get(context).copy_weights_to_psyneulink(context)
         optimizer.step()
+        self.parameters.pytorch_representation._get(context).copy_weights_to_psyneulink(context)
 
         if curr_epoch == total_epochs - 1 and not do_logging:
             self.parameters.pytorch_representation._get(context).\
diff --git a/requirements.txt b/requirements.txt
index 78e94556812..3d1a759b8f4 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,7 @@
 toposort==1.4
-numpy<1.16
+numpy
 pillow
 typecheck-decorator==1.2
 llvmlite
+elfi
+dill
diff --git a/setup.py b/setup.py
index 092ddc4f3c2..7083db7d7f9 100644
--- a/setup.py
+++ b/setup.py
@@ -18,7 +18,7 @@ def get_requirements(require_name=None):
     with open(path.join(here, prefix + 'requirements.txt'), encoding='utf-8') as f:
         return f.read().strip().split('\n')
 
-
+		
 setup(
     name='psyneulink',
 
diff --git a/tests/composition/test_autodiffcomposition.py b/tests/composition/test_autodiffcomposition.py
index 6ceaa35974c..85bbde0519b 100644
--- a/tests/composition/test_autodiffcomposition.py
+++ b/tests/composition/test_autodiffcomposition.py
@@ -744,6 +744,241 @@ def test_semantic_net_training_correctness(self, eps, opt, from_pnl_or_no,mode,b
         benchmark(sem_net.run,inputs={'inputs': inputs_dict,
                                       'targets': targets_dict,
                                       'epochs': eps}, bin_execute=mode)
+
+    def test_pytorch_equivalence(self):
+        from torch import nn, Tensor
+        iSs = np.array(
+            [np.array([0.47360805, 0.8009108, 0.5204775, 0.53737324, 0.7586156,
+                    0.1059076, 0.9025985, 0.44994998, 0.61306345, 0.75068617,
+                    0.60783064, 0.32504722, 0.58185035, 0.4143686, 0.4746975]),
+             np.array([0.33739617, 0.6481719, 0.36824155, 0.53737324, 0.7586156,
+                    0.1059076, 0.21655035, 0.13521817, 0.324141, 0.65314,
+                    0.17090958, 0.35815218, 0.03842543, 0.63427407, 0.95894927]),
+             np.array([0.33739617, 0.6481719, 0.36824155, 0.53737324, 0.7586156,
+                    0.1059076, 0.9025985, 0.44994998, 0.61306345, 0.65314,
+                    0.17090958, 0.35815218, 0.58185035, 0.4143686, 0.4746975]),
+             np.array([0.95715517, 0.14035077, 0.87008727, 0.47360042, 0.18633235,
+                    0.73691815, 0.14967486, 0.22232139, 0.38648897, 0.75068617,
+                    0.60783064, 0.32504722, 0.6527903, 0.6350589, 0.9952996]),
+             np.array([0.47360805, 0.8009108, 0.5204775, 0.47360042, 0.18633235,
+                    0.73691815, 0.9025985, 0.44994998, 0.61306345, 0.9023486,
+                    0.09928035, 0.96980906, 0.03842543, 0.63427407, 0.95894927]),
+             np.array([0.33739617, 0.6481719, 0.36824155, 0.53737324, 0.7586156,
+                    0.1059076, 0.9025985, 0.44994998, 0.61306345, 0.9023486,
+                    0.09928035, 0.96980906, 0.03842543, 0.63427407, 0.95894927]),
+             np.array([0.47360805, 0.8009108, 0.5204775, 0.47360042, 0.18633235,
+                    0.73691815, 0.14967486, 0.22232139, 0.38648897, 0.65314,
+                    0.17090958, 0.35815218, 0.58185035, 0.4143686, 0.4746975]),
+             np.array([0.95715517, 0.14035077, 0.87008727, 0.47360042, 0.18633235,
+                    0.73691815, 0.9025985, 0.44994998, 0.61306345, 0.75068617,
+                    0.60783064, 0.32504722, 0.6527903, 0.6350589, 0.9952996]),
+             np.array([0.47360805, 0.8009108, 0.5204775, 0.53737324, 0.7586156,
+                    0.1059076, 0.21655035, 0.13521817, 0.324141, 0.75068617,
+                    0.60783064, 0.32504722, 0.6527903, 0.6350589, 0.9952996]),
+             np.array([0.33739617, 0.6481719, 0.36824155, 0.53737324, 0.7586156,
+                    0.1059076, 0.14967486, 0.22232139, 0.38648897, 0.9023486,
+                    0.09928035, 0.96980906, 0.03842543, 0.63427407, 0.95894927]),
+             np.array([0.95715517, 0.14035077, 0.87008727, 0.47360042, 0.18633235,
+                    0.73691815, 0.9025985, 0.44994998, 0.61306345, 0.9023486,
+                    0.09928035, 0.96980906, 0.6527903, 0.6350589, 0.9952996]),
+             np.array([0.33739617, 0.6481719, 0.36824155, 0.47360042, 0.18633235,
+                    0.73691815, 0.14967486, 0.22232139, 0.38648897, 0.75068617,
+                    0.60783064, 0.32504722, 0.03842543, 0.63427407, 0.95894927]),
+             np.array([0.33739617, 0.6481719, 0.36824155, 0.53737324, 0.7586156,
+                    0.1059076, 0.14967486, 0.22232139, 0.38648897, 0.65314,
+                    0.17090958, 0.35815218, 0.03842543, 0.63427407, 0.95894927]),
+             np.array([0.95715517, 0.14035077, 0.87008727, 0.47360042, 0.18633235,
+                    0.73691815, 0.21655035, 0.13521817, 0.324141, 0.75068617,
+                    0.60783064, 0.32504722, 0.6527903, 0.6350589, 0.9952996]),
+             np.array([0.33739617, 0.6481719, 0.36824155, 0.47360042, 0.18633235,
+                    0.73691815, 0.9025985, 0.44994998, 0.61306345, 0.9023486,
+                    0.09928035, 0.96980906, 0.6527903, 0.6350589, 0.9952996])]
+        )
+
+        cSs = np.array(
+            [np.array([0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 1., 0., 0.]),
+             np.array([0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 1.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.,
+                    0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.,
+                    0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 1., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 1., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 1.]),
+             np.array([0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
+                    0., 0., 0., 0., 0., 0., 0., 1.])]
+        )
+
+        oSs = np.array(
+            [np.array([0., 1., -0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([1., 0., -0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., -0., 0., 1., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., -0., 0.]),
+             np.array([0., 0., 0., 0., 1., -0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., -0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., -0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., -0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 1., -0., 0., 0., 0., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., -0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.]),
+             np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.])]
+        )
+
+        nf = 3
+        nd = 5
+        nh = 200
+
+        D_i = nf * nd
+        D_c = nd ** 2
+        D_h = nh
+        D_o = nf * nd
+
+        wih = np.random.rand(D_i, D_h) * 0.02 - 0.01
+        wch = np.random.rand(D_c, D_h) * 0.02 - 0.01
+        wco = np.random.rand(D_c, D_o) * 0.02 - 0.01
+        who = np.random.rand(D_h, D_o) * 0.02 - 0.01
+
+        patience = 10
+        min_delt = 0.00001
+        learning_rate = 100
+
+        il = TransferMechanism(size=D_i, name='input')
+        cl = TransferMechanism(size=D_c, name='control')
+        hl = TransferMechanism(size=D_h, name='hidden',
+                               function=Logistic(bias=-2))
+        ol = TransferMechanism(size=D_o, name='output',
+                               function=Logistic(bias=-2))
+
+        input_set = {
+            'inputs': {
+                il: iSs,
+                cl: cSs
+            },
+            'targets': {
+                ol: oSs
+            }
+        }
+
+        pih = MappingProjection(matrix=wih)
+        pch = MappingProjection(matrix=wch)
+        pco = MappingProjection(matrix=wco)
+        pho = MappingProjection(matrix=who)
+
+        mnet = AutodiffComposition(param_init_from_pnl=True,
+                                   patience=patience,
+                                   min_delta=min_delt,
+                                   learning_rate=learning_rate,
+                                   learning_enabled=True)
+
+        mnet.add_node(il)
+        mnet.add_node(cl)
+        mnet.add_node(hl)
+        mnet.add_node(ol)
+        mnet.add_projection(projection=pih, sender=il, receiver=hl)
+        mnet.add_projection(projection=pch, sender=cl, receiver=hl)
+        mnet.add_projection(projection=pco, sender=cl, receiver=ol)
+        mnet.add_projection(projection=pho, sender=hl, receiver=ol)
+
+        mnet.run(
+            inputs=input_set,
+            minibatch_size=1,
+        )
+        mnet.learning_enabled = False
+
+        mnet.run(
+            inputs=input_set
+        )
+
+        loss = nn.MSELoss(reduction='sum')
+        labels = Tensor(oSs.reshape(225))
+        output = Tensor(mnet.parameters.results.get(mnet)[-15:]).reshape(225)
+
+        assert np.allclose(loss(labels, output), 26.765404)
+
+        comparator = Tensor([
+            6.1453427e-03, 1.0000000e+00, 4.3089520e-03, 4.6516648e-03,
+            8.2618001e-08, 7.6950570e-03, 1.0012715e-02, 7.4602116e-04,
+            5.5932072e-03, 8.2061728e-03, 1.3183967e-02, 6.8695140e-03,
+            2.0386763e-03, 1.6051590e-02, 4.4970796e-03, 2.5264964e-02,
+            9.9999952e-01, 1.2149608e-02, 1.2654287e-02, 8.4562558e-08,
+            2.1860752e-02, 3.0164845e-02, 1.7228123e-03, 1.6270705e-02,
+            2.3551809e-02, 4.0039439e-02, 1.9407738e-02, 5.5244947e-03,
+            5.3207204e-02, 1.2475645e-02, 1.8263543e-02, 9.9999857e-01,
+            1.3606172e-02, 1.4083516e-02, 1.9825113e-07, 2.0812556e-02,
+            9.8510243e-02, 3.6772678e-04, 2.3218473e-02, 2.1310158e-02,
+            4.1438844e-02, 1.9753182e-02, 1.4779154e-04, 5.3911228e-02,
+            1.4016392e-02, 2.2770427e-02, 9.9999523e-01, 1.6785931e-02,
+            1.7425330e-02, 8.5163043e-07, 2.7639847e-02, 3.6300030e-02,
+            3.1191204e-03, 2.1499839e-02, 2.9859981e-02, 4.6279125e-02,
+            2.4875764e-02, 8.4926197e-03, 5.8906939e-02, 1.7091349e-02,
+            2.5059190e-02, 9.9999011e-01, 1.8544273e-02, 1.9354496e-02,
+            1.0527428e-06, 3.0156212e-02, 3.8953356e-02, 3.7354573e-03,
+            2.3501266e-02, 3.2080259e-02, 4.9301058e-02, 4.3696441e-02,
+            9.6132793e-03, 6.1628751e-02, 1.8898886e-02, 2.1750819e-02,
+            9.9999368e-01, 1.6748825e-02, 1.7393829e-02, 7.1830226e-07,
+            2.5006970e-02, 2.7698321e-02, 3.3105435e-03, 2.0801542e-02,
+            2.5950141e-02, 3.3558644e-02, 2.2958852e-02, 2.0256745e-02,
+            2.3319282e-01, 1.7054005e-02, 1.8514888e-02, 9.9999905e-01,
+            1.3226544e-02, 1.3782033e-02, 2.6026042e-11, 4.6064097e-02,
+            3.1815756e-02, 1.9899406e-03, 1.7096445e-02, 2.5150523e-02,
+            4.1936234e-02, 1.9550020e-02, 5.8615361e-03, 5.4353956e-02,
+            1.3454205e-02, 2.6853021e-02, 9.9997890e-01, 2.0612849e-02,
+            2.1297636e-02, 3.8647496e-10, 6.3426509e-02, 4.1563153e-02,
+            4.5182779e-03, 2.5162309e-02, 3.4463432e-02, 5.1794391e-02,
+            2.7855596e-02, 1.0657175e-02, 6.3647740e-02, 2.0887125e-02,
+            2.0779613e-02, 9.9999750e-01, 1.5266245e-02, 1.5672959e-02,
+            3.2588846e-07, 2.3561811e-02, 3.4370810e-02, 2.5927520e-03,
+            1.9366659e-02, 6.3743673e-02, 4.4676617e-02, 2.2506185e-02,
+            7.1200798e-03, 5.6437019e-02, 1.5500024e-02, 1.9989355e-02,
+            9.9999821e-01, 1.4523782e-02, 1.5081550e-02, 2.4768514e-07,
+            2.3564184e-02, 3.3220161e-02, 2.3716728e-03, 1.8615939e-02,
+            2.3655901e-02, 4.3229431e-02, 2.1647181e-02, 3.9079070e-02,
+            5.5960458e-02, 1.4844272e-02, 2.6667269e-02, 9.9996638e-01,
+            2.1370204e-02, 2.1930600e-02, 3.0933686e-06, 2.9115165e-02,
+            1.2657930e-01, 8.4896327e-04, 3.4305997e-02, 2.9406046e-02,
+            5.1382497e-02, 2.8318554e-02, 2.7292687e-04, 6.3303888e-02,
+            2.1923987e-02, 1.8142583e-02, 9.9999869e-01, 1.3500703e-02,
+            1.3975278e-02, 1.8918573e-07, 2.0690627e-02, 9.8083377e-02,
+            3.6229755e-04, 2.3060752e-02, 2.1189153e-02, 4.1289508e-02,
+            1.9628568e-02, 1.4622087e-04, 5.3754900e-02, 1.3907125e-02,
+            1.6623152e-02, 9.9999928e-01, 1.2156339e-02, 1.2701786e-02,
+            1.0281526e-07, 1.9703880e-02, 2.2795949e-02, 1.8327459e-03,
+            1.5732812e-02, 2.0650970e-02, 2.8753385e-02, 1.7773779e-02,
+            1.3212827e-02, 2.1228336e-01, 1.2412207e-02, 2.2249922e-02,
+            9.9999511e-01, 1.6479362e-02, 1.7094113e-02, 5.8574432e-07,
+            2.6067821e-02, 3.1332519e-02, 3.1530680e-03, 2.1082299e-02,
+            2.7464284e-02, 1.6418625e-01, 2.3776721e-02, 8.3778230e-03,
+            5.7937458e-02, 1.6737318e-02, 2.3775091e-02, 9.9998677e-01,
+            1.8625231e-02, 1.9302633e-02, 1.3714227e-06, 2.7059222e-02,
+            2.9545579e-02, 4.0283184e-03, 2.2817709e-02, 2.7989613e-02,
+            3.5323191e-02, 2.4989001e-02, 2.3326760e-02, 2.4044928e-01,
+            1.8946640e-02
+        ])
+
+        np.allclose(output,comparator,atol=1.e-6)
+
 @pytest.mark.pytorch
 @pytest.mark.actime
 class TestTrainingTime:
@@ -1338,7 +1573,6 @@ class TestTrainingIdenticalness():
         ]
     )
     def test_xor_training_identicalness(self, eps, opt):
-
         # SET UP MECHANISMS FOR COMPOSITION
 
         xor_in = TransferMechanism(name='xor_in',
@@ -1393,7 +1627,8 @@ def test_xor_training_identicalness(self, eps, opt):
 
         xor = AutodiffComposition(param_init_from_pnl=True,
                                   learning_rate=10,
-                                  optimizer_type=opt)
+                                  optimizer_type=opt
+                                  )
 
         xor.add_node(xor_in)
         xor.add_node(xor_hid)
@@ -1420,6 +1655,7 @@ def test_xor_training_identicalness(self, eps, opt):
         inputs_dict = {"inputs": {xor_in:xor_inputs},
                        "targets": {xor_out:xor_targets},
                        "epochs": eps}
+
         result = xor.run(inputs=inputs_dict)
         comp_weights = xor.get_parameters()[0]
 
@@ -1450,7 +1686,6 @@ def test_xor_training_identicalness(self, eps, opt):
         ]
     )
     def test_semantic_net_training_identicalness(self, eps, opt):
-
         # SET UP MECHANISMS FOR SEMANTIC NET:
 
         nouns_in = TransferMechanism(name="nouns_input",
@@ -1593,7 +1828,8 @@ def test_semantic_net_training_identicalness(self, eps, opt):
 
         sem_net = AutodiffComposition(param_init_from_pnl=True,
                                       learning_rate=0.5,
-                                      optimizer_type=opt)
+                                      optimizer_type=opt,
+                                      )
 
         sem_net.add_node(nouns_in)
         sem_net.add_node(rels_in)
@@ -1698,6 +1934,7 @@ def test_semantic_net_training_identicalness(self, eps, opt):
 
         # TRAIN COMPOSITION
         sem_net.learning_enabled=True
+
         result = sem_net.run(inputs={"inputs": inputs_dict,
                                      "targets": targets_dict,
                                      "epochs": eps}
diff --git a/tests/composition/test_composition.py b/tests/composition/test_composition.py
index 05fd19008b7..8ff7afdf9c3 100644
--- a/tests/composition/test_composition.py
+++ b/tests/composition/test_composition.py
@@ -579,6 +579,7 @@ def test_controller_objective_mech_not_terminal_fall_back(self):
         assert comp.controller.objective_mechanism in comp.get_nodes_by_role(NodeRole.OUTPUT)
         assert B not in comp.get_nodes_by_role(NodeRole.OUTPUT)
 
+
 class TestGraphCycles:
 
     def test_recurrent_transfer_mechanisms(self):
diff --git a/tests/composition/test_control.py b/tests/composition/test_control.py
index a8f7db6da09..b07714ad67d 100644
--- a/tests/composition/test_control.py
+++ b/tests/composition/test_control.py
@@ -47,10 +47,13 @@ def test_add_controller_in_comp_constructor_then_add_node_with_control_specified
         # ControlProjection specified on Mechanism should initially be in deferred_init,
         #    but then initialized and added to controller when the Mechanism is added.
         ddm = pnl.DDM(function=pnl.DriftDiffusionAnalytical(
+                                # drift_rate=(1.0,
+                                #             pnl.ControlProjection(
+                                #                   function=pnl.Linear,
+                                #                   control_signal_params={ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3)}))))
                                 drift_rate=(1.0,
-                                            pnl.ControlProjection(
-                                                  function=pnl.Linear,
-                                                  control_signal_params={ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3)}))))
+                                            pnl.ControlSignal(allocation_samples=np.arange(0.1, 1.01, 0.3),
+                                                              intensity_cost_function=pnl.Linear))))
         ctl_mech = pnl.ControlMechanism()
         comp = pnl.Composition(controller=ctl_mech)
         comp.add_node(ddm)
@@ -129,6 +132,30 @@ def test_modulation_of_control_signal_intensity_cost_function_MULTIPLICATIVE(sel
         comp.run(inputs={mech:[3]}, num_trials=2)
         assert np.allclose(ctl_mech_A.control_signals[0].intensity_cost, 8103.083927575384008)
 
+    def test_feedback_assignment_for_multiple_control_projections_to_same_mechanism(self):
+        """Test that multiple ControlProjections from a ControlMechanism to the same Mechanism are treated
+        same as a single Controlprojection to that Mechanism.
+        Note: Even though both mech and control_mech don't receive pathway inputs, since control_mech projects to mech,
+        control_mech is assigned as NodeRole.INPUT (can be overridden with assignments in add_nodes)
+        """
+        mech = pnl.ProcessingMechanism(input_states=['A','B','C'])
+        control_mech = pnl.ControlMechanism(control=mech.input_states[0])
+        comp = pnl.Composition()
+        comp.add_nodes([mech, control_mech])
+        result = comp.run(inputs={control_mech:[2]}, num_trials=3)
+        # assert np.allclose(result, [[2],[2],[2]])
+        assert pnl.NodeRole.INPUT not in comp.get_roles_by_node(mech)
+        assert pnl.NodeRole.INPUT in comp.get_roles_by_node(control_mech)
+
+        # Should produce same result as above
+        mech = pnl.ProcessingMechanism(input_states=['A','B','C'])
+        control_mech = pnl.ControlMechanism(control=mech.input_states) # Note multiple parallel ControlProjections
+        comp = pnl.Composition()
+        comp.add_nodes([mech, control_mech])
+        comp.run(inputs={control_mech:[2]}, num_trials=3)
+        assert pnl.NodeRole.INPUT not in comp.get_roles_by_node(mech)
+        assert pnl.NodeRole.INPUT in comp.get_roles_by_node(control_mech)
+
     def test_modulation_of_control_signal_intensity_cost_function_ADDITIVE(self):
         # tests additive modulation of default intensity_cost_function (Exponential) of
         #    a ControlMechanism's default function (TransferWithCosts)
diff --git a/tests/control/test_param_estimation.py b/tests/control/test_param_estimation.py
new file mode 100644
index 00000000000..680d2092ff3
--- /dev/null
+++ b/tests/control/test_param_estimation.py
@@ -0,0 +1,123 @@
+import pytest
+
+import numpy as np
+import scipy.stats
+
+from psyneulink.core.compositions import Composition
+from psyneulink.core.components.mechanisms.processing.processingmechanism import ProcessingMechanism
+from psyneulink.core.components.mechanisms.processing.objectivemechanism import ObjectiveMechanism
+from psyneulink.core.globals.sampleiterator import SampleSpec
+from psyneulink.core.components.mechanisms.modulatory.control.optimizationcontrolmechanism import OptimizationControlMechanism
+from psyneulink.core.components.states.modulatorysignals.controlsignal import ControlSignal
+from psyneulink.core.globals.keywords import OVERRIDE
+from psyneulink.core.components.functions.optimizationfunctions import ParamEstimationFunction
+
+def test_moving_average():
+
+    # Set an arbitrary seed and a global random state to keep the randomly generated quantities the same between runs
+    seed = 20170530  # this will be separately given to ELFI
+    np.random.seed(seed)
+
+    # true parameters
+    t1_true = 0.6
+    t2_true = 0.2
+
+    # Define a function that simulates a 2nd order moving average, assuming mean zero:
+    # y_t = w_t + t1*w_t-1 + t2*w_t-2
+    # where t1 and t2 are real and w_k is i.i.d sequence white noise with N(0,1)
+    def MA2(input=[0], t1=0.5, t2=0.5, n_obs=100, batch_size=1, random_state=None):
+        # FIXME: Convert arguments to scalar if they are not. Why is this nescessary?
+        # PsyNeuLink, when creating a user defined function, seems to expect the function
+        # to support inputs of type np.ndarray even when they are only allowed to be
+        # scalars.
+        n_obs = n_obs[0] if (type(n_obs) is np.ndarray) else n_obs
+        batch_size = batch_size[0] if (type(batch_size) is np.ndarray) else batch_size
+
+        # Make inputs 2d arrays for numpy broadcasting with w
+        t1 = np.asanyarray(t1).reshape((-1, 1))
+        t2 = np.asanyarray(t2).reshape((-1, 1))
+        random_state = random_state or np.random
+
+        w = random_state.randn(int(batch_size), int(n_obs) + 2)  # i.i.d. sequence ~ N(0,1)
+        x = w[:, 2:] + t1 * w[:, 1:-1] + t2 * w[:, :-2]
+        return x
+
+    # Lets make some observed data. This will be the data we try to fit parameters for.
+    y_obs = MA2(t1_true, t2_true)
+
+    # Make a processing mechanism out of our simulator.
+    ma_mech = ProcessingMechanism(function=MA2,
+                                      size=1,
+                                      name='Moving Average (2nd Order)')
+
+    # Now lets add it to a composition
+    comp = Composition(name="Moving_Average")
+    comp.add_node(ma_mech)
+
+    # Now lets setup some control signals for the parameters we want to
+    # infer. This is where we would like to specify priors.
+    signalSearchRange = SampleSpec(start=0.1, stop=2.0, step=0.2)
+    t1_control_signal = ControlSignal(projections=[('t1', ma_mech)],
+                                      allocation_samples=signalSearchRange,
+                                      modulation=OVERRIDE)
+    t2_control_signal = ControlSignal(projections=[('t2', ma_mech)],
+                                      allocation_samples=signalSearchRange,
+                                      modulation=OVERRIDE)
+
+    # A function to calculate the auto-covariance with specific lag for a
+    # time series. We will use this function to compute the summary statistics
+    # for generated and observed data so that we can compute a metric between the
+    # two. In PsyNeuLink terms, this will be part of an ObjectiveMechanism.
+    # A function to calculate the auto-covariance with specific lag for a
+    # time series. We will use this function to compute the summary statistics
+    # for generated and observed data so that we can compute a metric between the
+    # two. In PsyNeuLink terms, this will be part of an ObjectiveMechanism.
+    def autocov(agent_rep, x=None, lag=1):
+        if x is None:
+            return np.asarray(0.0)
+
+        C = np.mean(x[:, lag:] * x[:, :-lag], axis=1)
+        return C
+
+    # # Lets make one function that computes all the summary stats in one go because PsyNeuLink
+    # # objective mechanism expect a single function.
+    # def objective_function(x):
+    #     return np.concatenate((autocov(x), autocov(x, lag=2)))
+    #
+    # # Objective Mechanism and its function currently need to be specified in the script.
+    # # (In future versions, this will be set up automatically)
+    # objective_mech = ObjectiveMechanism(function=objective_function,
+    #                                         monitor=[ma_mech])
+
+    # Setup the controller with the ParamEstimationFunction
+    comp.add_controller(
+        controller=OptimizationControlMechanism(
+            agent_rep=comp,
+            function=ParamEstimationFunction(
+                priors={'t1': (scipy.stats.uniform, 0, 2), 't2': (scipy.stats.uniform, 0, 2)},
+                observed=y_obs,
+                summary=[(autocov, 1), (autocov, 2)],
+                discrepancy='euclidean',
+                n_samples=3, quantile=0.01, # Set very small now cause things are slow.
+                seed=seed),
+            objective_mechanism=False,
+            control_signals=[t1_control_signal, t2_control_signal]))
+
+    comp.disable_all_history()
+
+    # Lets setup some input to the mechanism, not that it uses it for anything.
+    stim_list_dict = {ma_mech: [0]}
+
+    # # FIXME: Show graph fails when the controller doesn't have an objective mechanism.
+    # comp.show_graph(show_controller=True,
+    #                 show_projection_labels=True,
+    #                 show_node_structure=True,
+    #                 show_cim=True,
+    #                 show_dimensions=True)
+
+    comp.run(inputs=stim_list_dict)
+
+    # FIXME: The final test should be to check if the true parameters set above are
+    # recovered approximately. Not sure how to get all the samples out from
+    # above yet though so just pass for now.
+    assert True
diff --git a/tests/functions/test_buffer.py b/tests/functions/test_buffer.py
index a9262e2b4c0..8029b2f7a75 100644
--- a/tests/functions/test_buffer.py
+++ b/tests/functions/test_buffer.py
@@ -121,7 +121,7 @@ def test_buffer_as_function_of_processing_mech(self, benchmark):
                                                 history=3))
         val = P.execute(1.0)
 
-        assert np.allclose(val, [[0., 1.]])
+        assert np.allclose(np.asfarray(val), [[0., 1.]])
         benchmark(P.execute, 5.0)
         # fails due to value and variable problems when Buffer is the function of a mechanism
         # P = ProcessingMechanism(function=Buffer(default_variable=[[0.0], [1.0], [2.0]],
@@ -146,7 +146,7 @@ def assemble_full_result():
         result = system.run(inputs={P: [[1.0], [2.0], [3.0], [4.0], [5.0]]},
                             call_after_trial=assemble_full_result)
         # only returns index 0 item of the deque on each trial  (output state value)
-        assert np.allclose(result, [[[0.0]], [[0.0]], [[1.0]], [[2.0]], [[3.0]]])
+        assert np.allclose(np.asfarray(result), [[[0.0]], [[0.0]], [[1.0]], [[2.0]], [[3.0]]])
 
         # stores full mechanism value (full deque) on each trial
         expected_full_result = [np.array([[0.], [1.]]),
@@ -155,5 +155,6 @@ def assemble_full_result():
                                 np.array([[2.], [3.], [4.]]),
                                 np.array([[3.], [4.], [5.]])]
         for i in range(5):
-            assert np.allclose(expected_full_result[i], full_result[i])
+            assert np.allclose(expected_full_result[i],
+                               np.asfarray(full_result[i]))
 
diff --git a/tests/functions/test_objective.py b/tests/functions/test_objective.py
new file mode 100644
index 00000000000..23076328bfb
--- /dev/null
+++ b/tests/functions/test_objective.py
@@ -0,0 +1,8 @@
+import psyneulink as pnl
+
+
+def test_Stability_squeezes_variable():
+    s1 = pnl.Stability(default_variable=[[0.0, 0.0]])
+    s2 = pnl.Stability(default_variable=[0.0, 0.0])
+
+    assert s1.execute([5, 5]) == s2.execute([5, 5])
diff --git a/tests/functions/test_transfer.py b/tests/functions/test_transfer.py
index f8aad3714e3..cf0bf6b5ab8 100644
--- a/tests/functions/test_transfer.py
+++ b/tests/functions/test_transfer.py
@@ -28,7 +28,7 @@
 gaussian_helper = RAND3 * gaussian_helper + RAND4
 
 def gaussian_distort_helper(seed):
-    state = np.random.RandomState(np.asarray([seed]))
+    state = np.random.RandomState([seed])
     # compensate for construction
     state.normal(test_var + RAND1, RAND2)
     return RAND4 * state.normal(test_var + RAND1, RAND2) + RAND3
diff --git a/tests/json/model_basic.py b/tests/json/model_basic.py
new file mode 100644
index 00000000000..ce970179dd4
--- /dev/null
+++ b/tests/json/model_basic.py
@@ -0,0 +1,20 @@
+import psyneulink as pnl
+
+comp = pnl.Composition(name='comp')
+A = pnl.TransferMechanism(function=pnl.Linear(slope=5.0, intercept=2.0), name='A')
+B = pnl.TransferMechanism(function=pnl.Logistic, name='B')
+
+for m in [A, B]:
+    comp.add_node(m)
+
+comp.add_projection(pnl.MappingProjection(), A, B)
+
+comp.scheduler.add_condition_set({
+    A: pnl.EveryNPasses(1),
+    B: pnl.EveryNCalls(A, 2),
+})
+
+comp.termination_processing = {
+    pnl.TimeScale.RUN: pnl.AfterNTrials(1),
+    pnl.TimeScale.TRIAL: pnl.AfterNCalls(B, 4)
+}
diff --git a/tests/json/model_nested_comp_with_scheduler.py b/tests/json/model_nested_comp_with_scheduler.py
new file mode 100644
index 00000000000..045e4eed4c1
--- /dev/null
+++ b/tests/json/model_nested_comp_with_scheduler.py
@@ -0,0 +1,38 @@
+import psyneulink as pnl
+
+comp = pnl.Composition(name='comp')
+inner_comp = pnl.Composition(name='Inner Composition')
+A = pnl.TransferMechanism(function=pnl.Linear(slope=5.0, intercept=2.0), name='A')
+B = pnl.TransferMechanism(function=pnl.Logistic, name='B')
+C = pnl.RecurrentTransferMechanism(name='C')
+D = pnl.IntegratorMechanism(function=pnl.SimpleIntegrator, name='D')
+
+E = pnl.TransferMechanism(name='E')
+F = pnl.TransferMechanism(name='F')
+
+
+for m in [E, F]:
+    inner_comp.add_node(m)
+
+
+for m in [A, B, C, D, inner_comp]:
+    comp.add_node(m)
+
+comp.add_projection(pnl.MappingProjection(), A, B)
+comp.add_projection(pnl.MappingProjection(), A, C)
+comp.add_projection(pnl.MappingProjection(), B, D)
+comp.add_projection(pnl.MappingProjection(), C, D)
+comp.add_projection(pnl.MappingProjection(), C, inner_comp)
+
+inner_comp.add_projection(pnl.MappingProjection(), E, F)
+
+comp.scheduler.add_condition_set({
+    A: pnl.EveryNPasses(1),
+    B: pnl.EveryNCalls(A, 2),
+    C: pnl.EveryNCalls(B, 2)
+})
+
+comp.termination_processing = {
+    pnl.TimeScale.RUN: pnl.AfterNTrials(1),
+    pnl.TimeScale.TRIAL: pnl.AfterNCalls(D, 4)
+}
diff --git a/tests/json/model_with_control.py b/tests/json/model_with_control.py
new file mode 100644
index 00000000000..0f6c1d612a4
--- /dev/null
+++ b/tests/json/model_with_control.py
@@ -0,0 +1,72 @@
+import numpy as np
+import psyneulink as pnl
+
+# Mechanisms
+Input = pnl.TransferMechanism(name='Input')
+reward = pnl.TransferMechanism(
+    output_states=[pnl.RESULT, pnl.OUTPUT_MEAN, pnl.OUTPUT_VARIANCE], name='reward'
+)
+Decision = pnl.DDM(
+    function=pnl.DriftDiffusionAnalytical(
+        drift_rate=(
+            1.0,
+            pnl.ControlProjection(
+                function=pnl.Linear,
+                control_signal_params={
+                    pnl.ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3)
+                },
+            ),
+        ),
+        threshold=(
+            1.0,
+            pnl.ControlProjection(
+                function=pnl.Linear,
+                control_signal_params={
+                    pnl.ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3)
+                },
+            ),
+        ),
+        noise=0.5,
+        starting_point=0,
+        t0=0.45,
+    ),
+    output_states=[
+        pnl.DECISION_VARIABLE,
+        pnl.RESPONSE_TIME,
+        pnl.PROBABILITY_UPPER_THRESHOLD,
+    ],
+    name='Decision',
+)
+
+comp = pnl.Composition(name='comp')
+comp.add_node(reward, required_roles=[pnl.NodeRole.OUTPUT])
+comp.add_node(Decision, required_roles=[pnl.NodeRole.OUTPUT])
+task_execution_pathway = [Input, pnl.IDENTITY_MATRIX, Decision]
+comp.add_linear_processing_pathway(task_execution_pathway)
+
+comp.add_controller(
+    controller=pnl.OptimizationControlMechanism(
+        agent_rep=comp,
+        features=[Input.input_state, reward.input_state],
+        feature_function=pnl.AdaptiveIntegrator(rate=0.5),
+        objective_mechanism=pnl.ObjectiveMechanism(
+            function=pnl.LinearCombination(operation=pnl.PRODUCT),
+            monitor=[
+                reward,
+                Decision.output_states[pnl.PROBABILITY_UPPER_THRESHOLD],
+                (Decision.output_states[pnl.RESPONSE_TIME], -1, 1),
+            ],
+        ),
+        function=pnl.GridSearch,
+        control=[
+            {
+                pnl.PROJECTIONS: ('drift_rate', Decision),
+                pnl.ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3),
+            },
+            {
+                pnl.PROJECTIONS: (pnl.THRESHOLD, Decision),
+                pnl.ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3),
+            },
+        ],
+    )
+)
diff --git a/tests/json/stroop_conflict_monitoring.py b/tests/json/stroop_conflict_monitoring.py
new file mode 100644
index 00000000000..d46b18a70b8
--- /dev/null
+++ b/tests/json/stroop_conflict_monitoring.py
@@ -0,0 +1,84 @@
+import psyneulink as pnl
+import numpy as np
+
+# CONSTRUCT THE MODEL ***********************************
+
+# Construct the color naming pathway:
+color_input = pnl.ProcessingMechanism(
+    name="color_input", size=2
+)  # Note:  default function is Linear
+color_input_to_hidden_wts = np.array([[2, -2], [-2, 2]])
+color_hidden = pnl.ProcessingMechanism(
+    name="color_hidden", size=2, function=pnl.Logistic(bias=-4)
+)
+color_hidden_to_output_wts = np.array([[2, -2], [-2, 2]])
+output = pnl.ProcessingMechanism(name="OUTPUT", size=2, function=pnl.Logistic)
+color_pathway = [
+    color_input,
+    color_input_to_hidden_wts,
+    color_hidden,
+    color_hidden_to_output_wts,
+    output,
+]
+
+# Construct the word reading pathway (using the same output_layer)
+word_input = pnl.ProcessingMechanism(name="word_input", size=2)
+word_input_to_hidden_wts = np.array([[3, -3], [-3, 3]])
+word_hidden = pnl.ProcessingMechanism(
+    name="word_hidden", size=2, function=pnl.Logistic(bias=-4)
+)
+word_hidden_to_output_wts = np.array([[3, -3], [-3, 3]])
+word_pathway = [
+    word_input,
+    word_input_to_hidden_wts,
+    word_hidden,
+    word_hidden_to_output_wts,
+    output,
+]
+
+# Construct the task specification pathways
+task_input = pnl.ProcessingMechanism(name="task_input", size=2)
+task = pnl.LCAMechanism(name="TASK", size=2, initial_value=[0.5, 0.5])
+task_color_wts = np.array([[4, 4], [0, 0]])
+task_word_wts = np.array([[0, 0], [4, 4]])
+task_color_pathway = [task_input, task, task_color_wts, color_hidden]
+task_word_pathway = [task_input, task, task_word_wts, word_hidden]
+
+# Construct the decision pathway:
+decision = pnl.DDM(name="DECISION", input_format=pnl.ARRAY)
+decision_pathway = [output, decision]
+
+# Construct control mechanism
+control = pnl.ControlMechanism(
+    name="CONTROL",
+    objective_mechanism=pnl.ObjectiveMechanism(
+        name="Conflict Monitor",
+        function=pnl.Energy(size=2, matrix=[[0, -2.5], [-2.5, 0]]),
+        monitor=output,
+    ),
+    default_allocation=[0.5],
+    control_signals=[(pnl.GAIN, task)],
+)
+
+# Construct the Composition:
+Stroop_model = pnl.Composition(name="Stroop_model")
+Stroop_model.add_linear_processing_pathway(color_pathway)
+Stroop_model.add_linear_processing_pathway(word_pathway)
+Stroop_model.add_linear_processing_pathway(task_color_pathway)
+Stroop_model.add_linear_processing_pathway(task_word_pathway)
+Stroop_model.add_linear_processing_pathway(decision_pathway)
+Stroop_model.add_controller(control)
+
+# Assign conditions:
+settling_time = 10
+Stroop_model.scheduler.add_condition(
+    color_hidden, pnl.EveryNCalls(task, settling_time)
+)
+Stroop_model.scheduler.add_condition(
+    word_hidden, pnl.EveryNCalls(task, settling_time)
+)
+Stroop_model.scheduler.add_condition(
+    output,
+    pnl.All(pnl.EveryNCalls(color_hidden, 1), pnl.EveryNCalls(word_hidden, 1)),
+)
+Stroop_model.scheduler.add_condition(decision, pnl.EveryNCalls(output, 1))
diff --git a/tests/json/test_json.py b/tests/json/test_json.py
new file mode 100644
index 00000000000..2d1dafe5014
--- /dev/null
+++ b/tests/json/test_json.py
@@ -0,0 +1,63 @@
+import numpy as np
+import os
+import psyneulink as pnl
+import pytest
+import random
+
+# stroop stimuli
+red = [1, 0]
+green = [0, 1]
+word = [0, 1]
+color = [1, 0]
+
+num_trials = 5
+stroop_stimuli = {
+    'color_input': [red] * num_trials,
+    'word_input': [green] * num_trials,
+    'task_input': [color] * num_trials,
+}
+
+
+@pytest.mark.parametrize(
+    'filename, composition_name, input_dict_str',
+    [
+        ('model_basic.py', 'comp', '{A: 1}'),
+        ('model_nested_comp_with_scheduler.py', 'comp', '{A: 1}'),
+        (
+            'model_with_control.py',
+            'comp',
+            '{Input: [0.5, 0.123], reward: [20, 20]}'
+        ),
+        (
+            'stroop_conflict_monitoring.py',
+            'Stroop_model',
+            str(stroop_stimuli).replace("'", '')
+        )
+    ]
+)
+def test_json_results_equivalence(
+    filename,
+    composition_name,
+    input_dict_str,
+):
+    filename = f'{os.path.dirname(__file__)}/{filename}'
+    with open(filename, 'r') as orig_file:
+        exec(orig_file.read())
+        exec(f'{composition_name}.run(inputs={input_dict_str})')
+        orig_results = eval(f'{composition_name}.results')
+
+    # reset random seed
+    seed = 0
+    random.seed(seed)
+    np.random.seed(seed)
+    pnl.core.globals.utilities.set_global_seed(seed)
+
+    exec(
+        pnl.generate_script_from_json(
+            eval(f'{composition_name}.json_summary')
+        )
+    )
+    exec(f'{composition_name}.run(inputs={input_dict_str})')
+    new_results = eval(f'{composition_name}.results')
+
+    assert orig_results == new_results
diff --git a/tests/llvm/test_builtins_random.py b/tests/llvm/test_builtins_random.py
index 204f24310f8..09283b36dd3 100644
--- a/tests/llvm/test_builtins_random.py
+++ b/tests/llvm/test_builtins_random.py
@@ -16,10 +16,10 @@
 def test_random(benchmark, mode):
     res = []
     if mode == 'numpy':
-        # Python treats every seed as array, and numpy promotes elements to int64
-        state = np.random.RandomState(np.asarray([SEED]))
-        res += [state.randint(0xffffffff, dtype=np.int64)]
-        res += [state.randint(0xffffffff, dtype=np.int64)]
+        # Numpy promotes elements to int64
+        state = np.random.RandomState([SEED])
+        res.append(state.randint(0xffffffff, dtype=np.int64))
+        res.append(state.randint(0xffffffff, dtype=np.int64))
         benchmark(state.randint, 0xffffffff, dtype=np.int64)
     elif mode == 'LLVM':
         init_fun = pnlvm.LLVMBinaryFunction.get('__pnl_builtin_mt_rand_init')
@@ -29,9 +29,9 @@ def test_random(benchmark, mode):
         gen_fun = pnlvm.LLVMBinaryFunction.get('__pnl_builtin_mt_rand_int32')
         out = ctypes.c_longlong()
         gen_fun(state, out)
-        res += [out.value]
+        res.append(out.value)
         gen_fun(state, out)
-        res += [out.value]
+        res.append(out.value)
         benchmark(gen_fun, state, out)
     elif mode == 'PTX':
         init_fun = pnlvm.LLVMBinaryFunction.get('__pnl_builtin_mt_rand_init')
@@ -43,9 +43,9 @@ def test_random(benchmark, mode):
         out = np.asarray([0], dtype=np.int64)
         gpu_out = pnlvm.jit_engine.pycuda.driver.Out(out)
         gen_fun.cuda_call(gpu_state, gpu_out)
-        res += [out[0]]
+        res.append(out[0])
         gen_fun.cuda_call(gpu_state, gpu_out)
-        res += [out[0]]
+        res.append(out[0])
         benchmark(gen_fun.cuda_call, gpu_state, gpu_out)
 
     assert np.allclose(res, [3626764237, 1654615998])
@@ -61,14 +61,14 @@ def test_random_float(benchmark, mode):
     if mode == 'Python':
         # Python treats every seed as array
         state = random.Random(SEED)
-        res += [state.random()]
-        res += [state.random()]
+        res.append(state.random())
+        res.append(state.random())
         benchmark(state.random)
     elif mode == 'numpy':
-        # Python treats every seed as array, and numpy promotes elements to int64
-        state = np.random.RandomState(np.asarray([SEED]))
-        res += [state.random_sample()]
-        res += [state.random_sample()]
+        # numpy promotes elements to int64
+        state = np.random.RandomState([SEED])
+        res.append(state.random_sample())
+        res.append(state.random_sample())
         benchmark(state.random_sample)
     elif mode == 'LLVM':
         init_fun = pnlvm.LLVMBinaryFunction.get('__pnl_builtin_mt_rand_init')
@@ -78,9 +78,9 @@ def test_random_float(benchmark, mode):
         gen_fun = pnlvm.LLVMBinaryFunction.get('__pnl_builtin_mt_rand_double')
         out = ctypes.c_double()
         gen_fun(state, out)
-        res += [out.value]
+        res.append(out.value)
         gen_fun(state, out)
-        res += [out.value]
+        res.append(out.value)
         benchmark(gen_fun, state, out)
     elif mode == 'PTX':
         init_fun = pnlvm.LLVMBinaryFunction.get('__pnl_builtin_mt_rand_init')
@@ -92,9 +92,9 @@ def test_random_float(benchmark, mode):
         out = np.asfarray([0.0], dtype=np.float64)
         gpu_out = pnlvm.jit_engine.pycuda.driver.Out(out)
         gen_fun.cuda_call(gpu_state, gpu_out)
-        res += [out[0]]
+        res.append(out[0])
         gen_fun.cuda_call(gpu_state, gpu_out)
-        res += [out[0]]
+        res.apped(out[0])
         benchmark(gen_fun.cuda_call, gpu_state, gpu_out)
 
     assert np.allclose(res, [0.8444218515250481, 0.7579544029403025])
@@ -108,7 +108,7 @@ def test_random_float(benchmark, mode):
 def test_random_normal(benchmark, mode):
     if mode == 'numpy':
         # Python treats every seed as array, and numpy promotes elements to int64
-        state = np.random.RandomState(np.asarray([SEED]))
+        state = np.random.RandomState([SEED])
         res = state.normal()
         benchmark(state.normal)
     elif mode == 'LLVM':
diff --git a/tests/mechanisms/test_control_mechanisms.py b/tests/mechanisms/test_control_mechanism.py
similarity index 71%
rename from tests/mechanisms/test_control_mechanisms.py
rename to tests/mechanisms/test_control_mechanism.py
index 97143cd76b2..7fa7fa5503f 100644
--- a/tests/mechanisms/test_control_mechanisms.py
+++ b/tests/mechanisms/test_control_mechanism.py
@@ -74,7 +74,6 @@ def report_trial(system):
         # (4) mechanisms A and B should always have the same gain values (b/c they are identical)
         assert np.allclose(mod_gain_assigned_to_A, mod_gain_assigned_to_B)
 
-
     @pytest.mark.mechanism
     @pytest.mark.control_mechanism
     @pytest.mark.benchmark(group="LCControlMechanism Basic")
@@ -127,7 +126,6 @@ def test_lc_control_modulated_mechanisms_all(self):
         assert T_1.parameter_states[pnl.SLOPE].mod_afferents[0] in LC.control_signals[0].efferents
         assert T_2.parameter_states[pnl.SLOPE].mod_afferents[0] in LC.control_signals[0].efferents
 
-
     def test_control_modulation(self):
         Tx = pnl.TransferMechanism(name='Tx')
         Ty = pnl.TransferMechanism(name='Ty')
@@ -149,6 +147,84 @@ def test_control_modulation(self):
         result = S.run(inputs={Tx:[1,1], Ty:[4,4]})
         assert result == [[[4.], [4.]], [[4.], [4.]]]
 
+    def test_identicalness_of_control_and_gating(self):
+        """Tests same configuration as gating in tests/mechansims/test_gating_mechanism"""
+        Input_Layer = pnl.TransferMechanism(name='Input Layer', function=pnl.Logistic, size=2)
+        Hidden_Layer_1 = pnl.TransferMechanism(name='Hidden Layer_1', function=pnl.Logistic, size=5)
+        Hidden_Layer_2 = pnl.TransferMechanism(name='Hidden Layer_2', function=pnl.Logistic, size=4)
+        Output_Layer = pnl.TransferMechanism(name='Output Layer', function=pnl.Logistic, size=3)
+    
+        Control_Mechanism = pnl.ControlMechanism(size=[1], control=[Hidden_Layer_1.input_state,
+                                                                    Hidden_Layer_2.input_state,
+                                                                    Output_Layer.input_state])
+    
+        Input_Weights_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
+        Middle_Weights_matrix = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
+        Output_Weights_matrix = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
+        # This projection is specified in add_backpropagation_learning_pathway method below
+        Input_Weights = pnl.MappingProjection(name='Input Weights',matrix=Input_Weights_matrix)
+        # This projection is "discovered" by add_backpropagation_learning_pathway method below
+        Middle_Weights = pnl.MappingProjection(name='Middle Weights',sender=Hidden_Layer_1,receiver=Hidden_Layer_2,
+            matrix={
+                pnl.VALUE: Middle_Weights_matrix,
+                pnl.FUNCTION: pnl.AccumulatorIntegrator,
+                pnl.FUNCTION_PARAMS: {
+                    pnl.DEFAULT_VARIABLE: Middle_Weights_matrix,
+                    pnl.INITIALIZER: Middle_Weights_matrix,
+                    pnl.RATE: Middle_Weights_matrix
+                },
+            }
+        )
+        Output_Weights = pnl.MappingProjection(sender=Hidden_Layer_2,
+                                           receiver=Output_Layer,
+                                           matrix=Output_Weights_matrix)
+    
+        pathway = [Input_Layer, Input_Weights, Hidden_Layer_1, Hidden_Layer_2, Output_Layer]
+        comp = pnl.Composition()
+        learning_components = comp.add_backpropagation_learning_pathway(pathway=pathway)
+        # c.add_linear_processing_pathway(pathway=z)
+        comp.add_node(Control_Mechanism)
+    
+        stim_list = {
+            Input_Layer: [[-1, 30]],
+            Control_Mechanism: [1.0],
+            learning_components[pnl.TARGET_MECHANISM]: [[0, 0, 1]]}
+    
+        comp.run(num_trials=3, inputs=stim_list)
+    
+        expected_results = [[[0.81493513, 0.85129046, 0.88154205]],
+                            [[0.81250527, 0.84947508, 0.88159668]],
+                            [[0.81003707, 0.84762987, 0.88165066]]]
+        assert np.allclose(comp.results, expected_results)
+    
+        stim_list[Control_Mechanism]=[0.0]
+        results = comp.run(num_trials=1, inputs=stim_list)
+        expected_results = [[[0.5, 0.5, 0.5]]]
+        assert np.allclose(results, expected_results)
+    
+        stim_list[Control_Mechanism]=[2.0]
+        results = comp.run(num_trials=1, inputs=stim_list)
+        expected_results = [[0.96801676, 0.98304415, 0.99225722]]
+        assert np.allclose(results, expected_results)
+
+    def test_control_of_all_input_states(self):
+        mech = pnl.ProcessingMechanism(input_states=['A','B','C'])
+        control_mech = pnl.ControlMechanism(control=mech.input_states)
+        comp = pnl.Composition()
+        comp.add_nodes([(mech, pnl.NodeRole.INPUT), (control_mech, pnl.NodeRole.INPUT)])
+        results = comp.run(inputs={mech:[[2],[2],[2]], control_mech:[2]}, num_trials=2)
+        np.allclose(results, [[4],[4],[4]])
+
+    def test_control_of_all_output_states(self):
+        mech = pnl.ProcessingMechanism(output_states=[{pnl.VARIABLE: (pnl.OWNER_VALUE, 0)},
+                                                      {pnl.VARIABLE: (pnl.OWNER_VALUE, 0)},
+                                                      {pnl.VARIABLE: (pnl.OWNER_VALUE, 0)}],)
+        control_mech = pnl.ControlMechanism(control=mech.output_states)
+        comp = pnl.Composition()
+        comp.add_nodes([(mech, pnl.NodeRole.INPUT), (control_mech, pnl.NodeRole.INPUT)])
+        results = comp.run(inputs={mech:[[2]], control_mech:[3]}, num_trials=2)
+        np.allclose(results, [[6],[6],[6]])
+
     def test_control_signal_default_allocation_specification(self):
 
         m1 = pnl.ProcessingMechanism()
diff --git a/tests/mechanisms/test_ddm_mechanism.py b/tests/mechanisms/test_ddm_mechanism.py
index 24caf0fcadc..8b48c791b5a 100644
--- a/tests/mechanisms/test_ddm_mechanism.py
+++ b/tests/mechanisms/test_ddm_mechanism.py
@@ -23,42 +23,42 @@ def test_valid(self):
         #  returns previous_value + rate * variable * time_step_size  + noise
         #  0.0 + 1.0 * 1.0 * 1.0 + 0.0
         D.execute(1.0)
-        assert np.allclose(D.value,  [[1.0], [1.0]])
-        assert np.allclose(D.output_states[0].value, 1.0)
-        assert np.allclose(D.output_states[1].value, 1.0)
+        assert np.allclose(np.asfarray(D.value),  [[1.0], [1.0]])
+        assert np.allclose(D.output_states[0].value[0][0], 1.0)
+        assert np.allclose(D.output_states[1].value[0][0], 1.0)
 
         # reinitialize function
         D.function.reinitialize(2.0, 0.1)
         assert np.allclose(D.function.value[0], 2.0)
         assert np.allclose(D.function.previous_value, 2.0)
         assert np.allclose(D.function.previous_time, 0.1)
-        assert np.allclose(D.value,  [[1.0], [1.0]])
-        assert np.allclose(D.output_states[0].value, 1.0)
-        assert np.allclose(D.output_states[1].value, 1.0)
+        assert np.allclose(np.asfarray(D.value),  [[1.0], [1.0]])
+        assert np.allclose(D.output_states[0].value[0][0], 1.0)
+        assert np.allclose(D.output_states[1].value[0][0], 1.0)
 
         # reinitialize function without value spec
         D.function.reinitialize()
         assert np.allclose(D.function.value[0], 0.0)
         assert np.allclose(D.function.previous_value, 0.0)
         assert np.allclose(D.function.previous_time, 0.0)
-        assert np.allclose(D.value, [[1.0], [1.0]])
-        assert np.allclose(D.output_states[0].value, 1.0)
-        assert np.allclose(D.output_states[1].value, 1.0)
+        assert np.allclose(np.asfarray(D.value), [[1.0], [1.0]])
+        assert np.allclose(D.output_states[0].value[0][0], 1.0)
+        assert np.allclose(D.output_states[1].value[0][0], 1.0)
 
         # reinitialize mechanism
         D.reinitialize(2.0, 0.1)
         assert np.allclose(D.function.value[0], 2.0)
         assert np.allclose(D.function.previous_value, 2.0)
         assert np.allclose(D.function.previous_time, 0.1)
-        assert np.allclose(D.value, [[2.0], [0.1]])
+        assert np.allclose(np.asfarray(D.value), [[2.0], [0.1]])
         assert np.allclose(D.output_states[0].value, 2.0)
         assert np.allclose(D.output_states[1].value, 0.1)
 
         D.execute(1.0)
         #  2.0 + 1.0 = 3.0 ; 0.1 + 1.0 = 1.1
-        assert np.allclose(D.value, [[[3.0]], [[1.1]]])
-        assert np.allclose(D.output_states[0].value, 3.0)
-        assert np.allclose(D.output_states[1].value, 1.1)
+        assert np.allclose(np.asfarray(D.value), [[[3.0]], [[1.1]]])
+        assert np.allclose(D.output_states[0].value[0][0], 3.0)
+        assert np.allclose(D.output_states[1].value[0][0], 1.1)
 
         # reinitialize mechanism without value spec
         D.reinitialize()
@@ -685,12 +685,12 @@ def test_DDM_time():
     np.testing.assert_allclose(time_0, 0.5, atol=1e-08)
 
     time_1 = D.execute(10)[1][0]   # t_1  = 0.5 + 0.2 = 0.7
-    np.testing.assert_allclose(time_1, 0.7, atol=1e-08)
+    np.testing.assert_allclose(time_1[0], 0.7, atol=1e-08)
 
     for i in range(10):                                     # t_11 = 0.7 + 10*0.2 = 2.7
         D.execute(10)
     time_12 = D.execute(10)[1][0]                              # t_12 = 2.7 + 0.2 = 2.9
-    np.testing.assert_allclose(time_12, 2.9, atol=1e-08)
+    np.testing.assert_allclose(time_12[0], 2.9, atol=1e-08)
 
 
 def test_WhenFinished_DDM_Analytical():
diff --git a/tests/mechanisms/test_gating_mechanism.py b/tests/mechanisms/test_gating_mechanism.py
index 4d564722249..fc3e3435751 100644
--- a/tests/mechanisms/test_gating_mechanism.py
+++ b/tests/mechanisms/test_gating_mechanism.py
@@ -14,217 +14,23 @@
 from psyneulink.core.globals.preferences.basepreferenceset import REPORT_OUTPUT_PREF, VERBOSE_PREF
 from psyneulink.core.compositions.composition import Composition
 
+def test_gating_with_composition():
+    """Tests same configuration as control of InputState in tests/mechansims/test_identicalness_of_control_and_gating
+    """
+    Input_Layer = TransferMechanism(name='Input Layer', function=Logistic, size=2)
+    Hidden_Layer_1 = TransferMechanism(name='Hidden Layer_1', function=Logistic, size=5)
+    Hidden_Layer_2 = TransferMechanism(name='Hidden Layer_2', function=Logistic, size=4)
+    Output_Layer = TransferMechanism(name='Output Layer', function=Logistic, size=3)
 
-# def test_gating():
-#     Input_Layer = TransferMechanism(
-#         name='Input Layer',
-#         function=Logistic,
-#         default_variable=np.zeros((2,))
-#     )
-#
-#     Hidden_Layer_1 = TransferMechanism(
-#         name='Hidden Layer_1',
-#         function=Logistic(),
-#         default_variable=np.zeros((5,))
-#     )
-#
-#     Hidden_Layer_2 = TransferMechanism(
-#         name='Hidden Layer_2',
-#         function=Logistic(),
-#         default_variable=[0, 0, 0, 0]
-#     )
-#
-#     Output_Layer = TransferMechanism(
-#         name='Output Layer',
-#         function=Logistic,
-#         default_variable=[0, 0, 0]
-#     )
-#
-#     Gating_Mechanism = GatingMechanism(
-#         # default_gating_allocation=0.0,
-#         size=[1],
-#         gating_signals=[
-#             Hidden_Layer_1,
-#             Hidden_Layer_2,
-#             Output_Layer,
-#         ]
-#     )
-#
-#     Input_Weights_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
-#     Middle_Weights_matrix = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
-#     Output_Weights_matrix = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
-#
-#     # TEST PROCESS.LEARNING WITH:
-#     # CREATION OF FREE STANDING PROJECTIONS THAT HAVE NO LEARNING (Input_Weights, Middle_Weights and Output_Weights)
-#     # INLINE CREATION OF PROJECTIONS (Input_Weights, Middle_Weights and Output_Weights)
-#     # NO EXPLICIT CREATION OF PROJECTIONS (Input_Weights, Middle_Weights and
-#     # Output_Weights)
-#
-#     # This projection will be used by the process below by referencing it in the process' pathway;
-#     #    note: sender and receiver args don't need to be specified
-#     Input_Weights = MappingProjection(
-#         name='Input Weights',
-#         matrix=Input_Weights_matrix
-#     )
-#
-#     # This projection will be used by the process below by assigning its sender and receiver args
-#     #    to mechanismss in the pathway
-#     Middle_Weights = MappingProjection(
-#         name='Middle Weights',
-#         sender=Hidden_Layer_1,
-#         receiver=Hidden_Layer_2,
-#         matrix={
-#             VALUE: Middle_Weights_matrix,
-#             FUNCTION: AccumulatorIntegrator,
-#             FUNCTION_PARAMS: {
-#                 DEFAULT_VARIABLE: Middle_Weights_matrix,
-#                 INITIALIZER: Middle_Weights_matrix,
-#                 RATE: Middle_Weights_matrix
-#             },
-#         }
-#     )
-#
-#     Output_Weights = MappingProjection(
-#         name='Output Weights',
-#         sender=Hidden_Layer_2,
-#         receiver=Output_Layer,
-#         matrix=Output_Weights_matrix
-#     )
-#
-#     z = Process(
-#         # default_variable=[0, 0],
-#         size=2,
-#         pathway=[
-#             Input_Layer,
-#             # The following reference to Input_Weights is needed to use it in the pathway
-#             # since it's sender and receiver args are not specified in its
-#             # declaration above
-#             Input_Weights,
-#             Hidden_Layer_1,
-#             # No projection specification is needed here since the sender arg for Middle_Weights
-#             #    is Hidden_Layer_1 and its receiver arg is Hidden_Layer_2
-#             # Middle_Weights,
-#             Hidden_Layer_2,
-#             # Output_Weights does not need to be listed for the same reason as Middle_Weights
-#             # If Middle_Weights and/or Output_Weights is not declared above, then the process
-#             #    will assign a default for missing projection
-#             # Output_Weights,
-#             Output_Layer
-#         ],
-#         clamp_input=SOFT_CLAMP,
-#         learning=LEARNING,
-#         learning_rate=1.0,
-#         target=[0, 0, 1],
-#         prefs={
-#             VERBOSE_PREF: False,
-#             REPORT_OUTPUT_PREF: True
-#         }
-#     )
-#
-#     g = Process(
-#         default_variable=[1.0],
-#         pathway=[Gating_Mechanism]
-#     )
-#
-#     stim_list = {
-#         Input_Layer: [[-1, 30]],
-#         Gating_Mechanism: [1.0]
-#     }
-#     target_list = {
-#         Output_Layer: [[0, 0, 1]]
-#     }
-#
-#     def print_header():
-#         print("\n\n**** TRIAL: ", 'time_placeholder')
-#
-#     def show_target():
-#         i = s.input
-#         t = s.target_input_states[0].value
-#         print('\nOLD WEIGHTS: \n')
-#         print('- Input Weights: \n', Input_Weights.matrix)
-#         print('- Middle Weights: \n', Middle_Weights.matrix)
-#         print('- Output Weights: \n', Output_Weights.matrix)
-#         print('\nSTIMULI:\n\n- Input: {}\n- Target: {}\n'.format(i, t))
-#         print('ACTIVITY FROM OLD WEIGHTS: \n')
-#         print('- Middle 1: \n', Hidden_Layer_1.value)
-#         print('- Middle 2: \n', Hidden_Layer_2.value)
-#         print('- Output:\n', Output_Layer.value)
-#
-#     s = System(
-#         processes=[z, g],
-#         targets=[0, 0, 1],
-#         learning_rate=1.0
-#     )
-#
-#     s.reportOutputPref = True
-#     # s.show_graph(show_learning=True)
-#
-#     results = s.run(
-#         num_trials=10,
-#         inputs=stim_list,
-#         targets=target_list,
-#         call_before_trial=print_header,
-#         call_after_trial=show_target,
-#     )
-
-def test_gating_composition_with_composition():
-    Input_Layer = TransferMechanism(
-        name='Input Layer',
-        function=Logistic,
-        default_variable=np.zeros((2,))
-    )
-
-    Hidden_Layer_1 = TransferMechanism(
-        name='Hidden Layer_1',
-        function=Logistic(),
-        default_variable=np.zeros((5,))
-    )
-
-    Hidden_Layer_2 = TransferMechanism(
-        name='Hidden Layer_2',
-        function=Logistic(),
-        default_variable=[0, 0, 0, 0]
-    )
-
-    Output_Layer = TransferMechanism(
-        name='Output Layer',
-        function=Logistic,
-        default_variable=[0, 0, 0]
-    )
-
-    Gating_Mechanism = GatingMechanism(
-        # default_gating_allocation=0.0,
-            size=[1],
-            gate=[
-                Hidden_Layer_1,
-                Hidden_Layer_2,
-                Output_Layer,
-            ]
-    )
+    Gating_Mechanism = GatingMechanism(size=[1], gate=[Hidden_Layer_1, Hidden_Layer_2, Output_Layer])
 
     Input_Weights_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
     Middle_Weights_matrix = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
     Output_Weights_matrix = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
-
-    # TEST PROCESS.LEARNING WITH:
-    # CREATION OF FREE STANDING PROJECTIONS THAT HAVE NO LEARNING (Input_Weights, Middle_Weights and Output_Weights)
-    # INLINE CREATION OF PROJECTIONS (Input_Weights, Middle_Weights and Output_Weights)
-    # NO EXPLICIT CREATION OF PROJECTIONS (Input_Weights, Middle_Weights and
-    # Output_Weights)
-
-    # This projection will be used by the process below by referencing it in the process' pathway;
-    #    note: sender and receiver args don't need to be specified
-    Input_Weights = MappingProjection(
-        name='Input Weights',
-        matrix=Input_Weights_matrix
-    )
-
-    # This projection will be used by the process below by assigning its sender and receiver args
-    #    to mechanismss in the pathway
-    Middle_Weights = MappingProjection(
-        name='Middle Weights',
-        sender=Hidden_Layer_1,
-        receiver=Hidden_Layer_2,
+    # This projection is specified in add_backpropagation_learning_pathway method below
+    Input_Weights = MappingProjection(name='Input Weights',matrix=Input_Weights_matrix)
+    # This projection is "discovered" by add_backpropagation_learning_pathway method below
+    Middle_Weights = MappingProjection(name='Middle Weights',sender=Hidden_Layer_1,receiver=Hidden_Layer_2,
         matrix={
             VALUE: Middle_Weights_matrix,
             FUNCTION: AccumulatorIntegrator,
@@ -235,160 +41,35 @@ def test_gating_composition_with_composition():
             },
         }
     )
+    Output_Weights = MappingProjection(sender=Hidden_Layer_2, receiver=Output_Layer, matrix=Output_Weights_matrix)
 
-    Output_Weights = MappingProjection(
-        name='Output Weights',
-        sender=Hidden_Layer_2,
-        receiver=Output_Layer,
-        matrix=Output_Weights_matrix
-    )
-
-    z = [Input_Layer, Input_Weights, Hidden_Layer_1, Hidden_Layer_2, Output_Layer]
-    c = Composition()
-
-    learning_components = c.add_backpropagation_learning_pathway(pathway=z)
+    pathway = [Input_Layer, Input_Weights, Hidden_Layer_1, Hidden_Layer_2, Output_Layer]
+    comp = Composition()
+    learning_components = comp.add_backpropagation_learning_pathway(pathway=pathway)
     # c.add_linear_processing_pathway(pathway=z)
-    c.add_node(Gating_Mechanism)
-
-    # g = Process(
-    #     default_variable=[1.0],
-    #     pathway=[Gating_Mechanism]
-    # )
+    comp.add_node(Gating_Mechanism)
 
     stim_list = {
         Input_Layer: [[-1, 30]],
         Gating_Mechanism: [1.0],
         learning_components[TARGET_MECHANISM]: [[0, 0, 1]]}
 
-    results = c.run(
-            num_trials=10,
-            inputs=stim_list
-    )
+    comp.run(num_trials=3, inputs=stim_list)
+
+    expected_results = [[[0.81493513, 0.85129046, 0.88154205]],
+                        [[0.81250527, 0.84947508, 0.88159668]],
+                        [[0.81003707, 0.84762987, 0.88165066]]]
+    assert np.allclose(comp.results, expected_results)
 
+    stim_list[Gating_Mechanism]=[0.0]
+    results = comp.run(num_trials=1, inputs=stim_list)
+    expected_results = [[[0.5, 0.5, 0.5]]]
+    assert np.allclose(results, expected_results)
 
-# def test_gating_with_UDF():
-#     def my_linear_fct(
-#         x,
-#         m=2.0,
-#         b=0.0,
-#         params={
-#             pnl.ADDITIVE_PARAM: 'b',
-#             pnl.MULTIPLICATIVE_PARAM: 'm'
-#         }
-#     ):
-#         return m * x + b
-#
-#     def my_simple_linear_fct(
-#         x,
-#         m=1.0,
-#         b=0.0
-#     ):
-#         return m * x + b
-#
-#     def my_exp_fct(
-#         x,
-#         r=1.0,
-#         # b=pnl.CONTROL,
-#         b=0.0,
-#         params={
-#             pnl.ADDITIVE_PARAM: 'b',
-#             pnl.MULTIPLICATIVE_PARAM: 'r'
-#         }
-#     ):
-#         return x**r + b
-#
-#     def my_sinusoidal_fct(
-#         input,
-#         phase=0,
-#         amplitude=1,
-#         params={
-#             pnl.ADDITIVE_PARAM: 'phase',
-#             pnl.MULTIPLICATIVE_PARAM: 'amplitude'
-#         }
-#     ):
-#         frequency = input[0]
-#         t = input[1]
-#         return amplitude * np.sin(2 * np.pi * frequency * t + phase)
-#
-#     Input_Layer = pnl.TransferMechanism(
-#         name='Input_Layer',
-#         default_variable=np.zeros((2,)),
-#         function=psyneulink.core.components.functions.transferfunctions.Logistic
-#     )
-#
-#     Output_Layer = pnl.TransferMechanism(
-#         name='Output_Layer',
-#         default_variable=[0, 0, 0],
-#         function=psyneulink.core.components.functions.transferfunctions.Linear,
-#         # function=pnl.Logistic,
-#         # output_states={pnl.NAME: 'RESULTS USING UDF',
-#         #                pnl.VARIABLE: [(pnl.OWNER_VALUE,0), pnl.TIME_STEP],
-#         #                pnl.FUNCTION: my_sinusoidal_fct}
-#         output_states={
-#             pnl.NAME: 'RESULTS USING UDF',
-#             # pnl.VARIABLE: (pnl.OWNER_VALUE, 0),
-#             pnl.FUNCTION: psyneulink.core.components.functions.transferfunctions.Linear(slope=pnl.GATING)
-#             # pnl.FUNCTION: pnl.Logistic(gain=pnl.GATING)
-#             # pnl.FUNCTION: my_linear_fct
-#             # pnl.FUNCTION: my_exp_fct
-#             # pnl.FUNCTION:pnl.UserDefinedFunction(custom_function=my_simple_linear_fct,
-#             #                                      params={pnl.ADDITIVE_PARAM:'b',
-#             #                                              pnl.MULTIPLICATIVE_PARAM:'m',
-#             #                                              },
-#             # m=pnl.GATING,
-#             # b=2.0
-#             # )
-#         }
-#     )
-#
-#     Gating_Mechanism = pnl.GatingMechanism(
-#         # default_gating_allocation=0.0,
-#         size=[1],
-#         gating_signals=[
-#             # Output_Layer
-#             Output_Layer.output_state,
-#         ]
-#     )
-#
-#     p = pnl.Process(
-#         size=2,
-#         pathway=[
-#             Input_Layer,
-#             Output_Layer
-#         ],
-#         prefs={
-#             pnl.VERBOSE_PREF: False,
-#             pnl.REPORT_OUTPUT_PREF: False
-#         }
-#     )
-#
-#     g = pnl.Process(
-#         default_variable=[1.0],
-#         pathway=[Gating_Mechanism]
-#     )
-#
-#     stim_list = {
-#         Input_Layer: [[-1, 30], [-1, 30], [-1, 30], [-1, 30]],
-#         Gating_Mechanism: [[0.0], [0.5], [1.0], [2.0]]
-#     }
-#
-#     mySystem = pnl.System(processes=[p, g])
-#
-#     mySystem.reportOutputPref = False
-#
-#     results = mySystem.run(
-#         num_trials=4,
-#         inputs=stim_list,
-#     )
-#
-#     expected_results = [
-#         [np.array([0., 0., 0.])],
-#         [np.array([0.63447071, 0.63447071, 0.63447071])],
-#         [np.array([1.26894142, 1.26894142, 1.26894142])],
-#         [np.array([2.53788284, 2.53788284, 2.53788284])]
-#     ]
-#
-#     np.testing.assert_allclose(results, expected_results)
+    stim_list[Gating_Mechanism]=[2.0]
+    results = comp.run(num_trials=1, inputs=stim_list)
+    expected_results = [[0.96801676, 0.98304415, 0.99225722]]
+    assert np.allclose(results, expected_results)
 
 def test_gating_with_UDF_with_composition():
     def my_linear_fct(
@@ -452,21 +133,10 @@ def my_sinusoidal_fct(
             pnl.NAME: 'RESULTS USING UDF',
             # pnl.VARIABLE: (pnl.OWNER_VALUE, 0),
             pnl.FUNCTION: psyneulink.core.components.functions.transferfunctions.Linear(slope=pnl.GATING)
-            # pnl.FUNCTION: pnl.Logistic(gain=pnl.GATING)
-            # pnl.FUNCTION: my_linear_fct
-            # pnl.FUNCTION: my_exp_fct
-            # pnl.FUNCTION:pnl.UserDefinedFunction(custom_function=my_simple_linear_fct,
-            #                                      params={pnl.ADDITIVE_PARAM:'b',
-            #                                              pnl.MULTIPLICATIVE_PARAM:'m',
-            #                                              },
-            # m=pnl.GATING,
-            # b=2.0
-            # )
         }
     )
 
     Gating_Mechanism = pnl.GatingMechanism(
-        # default_gating_allocation=0.0,
         size=[1],
         gating_signals=[
             # Output_Layer
diff --git a/tests/mechanisms/test_input_state_spec.py b/tests/mechanisms/test_input_state_spec.py
index dd3d14b5b77..874a307120e 100644
--- a/tests/mechanisms/test_input_state_spec.py
+++ b/tests/mechanisms/test_input_state_spec.py
@@ -1,6 +1,7 @@
 import numpy as np
 import psyneulink as pnl
 import pytest
+import re
 
 from psyneulink.core.components.functions.combinationfunctions import Reduce
 from psyneulink.core.components.mechanisms.modulatory.control.gating.gatingmechanism import GatingMechanism
@@ -18,6 +19,7 @@
 mismatches_size_error_text = 'not compatible with the default variable determined from size parameter'
 mismatches_more_input_states_than_default_variable_error_text = 'There are more InputStates specified'
 mismatches_fewer_input_states_than_default_variable_error_text = 'There are fewer InputStates specified'
+mismatches_specified_matrix_pattern = r'The number of rows \(\d\) of the matrix provided for .+ does not equal the length \(\d\) of the sender vector'
 
 
 class TestInputStateSpec:
@@ -564,17 +566,19 @@ def tests_for_projection_with_matrix_and_sender_mismatches_default(self):
             m = TransferMechanism(size=3, output_states=[pnl.TRANSFER_OUTPUT.MEAN])
             p = MappingProjection(sender=m, matrix=[[0,0,0], [0,0,0]])
             T = TransferMechanism(input_states=[p])
-        assert 'Specification of matrix and/or default_variable for LinearMatrix Function-0 is not valid. ' \
-               'The shapes of variable (1, 1) and matrix (2, 3) are not compatible for multiplication' \
-               in str(error_text.value)
+        assert re.match(
+            mismatches_specified_matrix_pattern,
+            error_text.value.error_value
+        )
 
         with pytest.raises(FunctionError) as error_text:
             m2 = TransferMechanism(size=2, output_states=[pnl.TRANSFER_OUTPUT.MEAN])
             p2 = MappingProjection(sender=m2, matrix=[[1,1,1],[1,1,1]])
             T2 = TransferMechanism(input_states=[p2])
-        assert 'Specification of matrix and/or default_variable for LinearMatrix Function-1 is not valid. ' \
-               'The shapes of variable (1, 1) and matrix (2, 3) are not compatible for multiplication' \
-               in str(error_text.value)
+        assert re.match(
+            mismatches_specified_matrix_pattern,
+            error_text.value.error_value
+        )
 
     # ------------------------------------------------------------------------------------------------
     # TEST 33
diff --git a/tests/projections/test_projections.py b/tests/projections/test_projection.py
similarity index 100%
rename from tests/projections/test_projections.py
rename to tests/projections/test_projection.py
diff --git a/tests/projections/test_projections_specifications.py b/tests/projections/test_projection_specifications.py
similarity index 88%
rename from tests/projections/test_projections_specifications.py
rename to tests/projections/test_projection_specifications.py
index 4715cc8dff6..05fe5038ea4 100644
--- a/tests/projections/test_projections_specifications.py
+++ b/tests/projections/test_projection_specifications.py
@@ -6,9 +6,52 @@
 import psyneulink.core.components.functions.statefulfunctions.integratorfunctions
 import psyneulink.core.components.functions.transferfunctions
 
-
 class TestProjectionSpecificationFormats:
 
+    def test_projection_specification_formats(self):
+        """Test various matrix and Projection specifications
+        Also tests assignment of Projections to pathay of Composition using add_linear_processing_pathway:
+        - Projection explicitly specified in sequence (M1_M2_proj)
+        - Projection pre-constructed and assigned to Mechanisms, but not specified in pathway(M2_M3_proj)
+        - Projection specified in pathway that is duplicate one preconstructed and assigned to Mechanisms (M3_M4_proj)
+          (currently it should be ignored; in the future, if/when Projections between the same sender and receiver
+           in different Compositions are allowed, then it should be used)
+        """
+        M1 = pnl.ProcessingMechanism(size=2)
+        M2 = pnl.ProcessingMechanism(size=5)
+        M3 = pnl.ProcessingMechanism(size=4)
+        M4 = pnl.ProcessingMechanism(size=3)
+
+        M1_M2_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
+        M2_M3_matrix = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
+        M3_M4_matrix_A = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 5)
+        M3_M4_matrix_B = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
+
+        M1_M2_proj = pnl.MappingProjection(matrix=M1_M2_matrix)
+        M2_M3_proj = pnl.MappingProjection(sender=M2,
+                                           receiver=M3,
+                                           matrix={pnl.VALUE: M2_M3_matrix,
+                                                   pnl.FUNCTION: pnl.AccumulatorIntegrator,
+                                                   pnl.FUNCTION_PARAMS: {pnl.DEFAULT_VARIABLE: M2_M3_matrix,
+                                                                         pnl.INITIALIZER: M2_M3_matrix}})
+        M3_M4_proj_A = pnl.MappingProjection(sender=M3, receiver=M4, matrix=M3_M4_matrix_A)
+        c = pnl.Composition()
+        c.add_linear_processing_pathway(pathway=[M1,
+                                                 M1_M2_proj,
+                                                 M2,
+                                                 M3,
+                                                 M3_M4_matrix_B,
+                                                 M4])
+
+        assert np.allclose(M2_M3_proj.matrix, M2_M3_matrix)
+        assert M2.efferents[0] is M2_M3_proj
+        assert np.allclose(M3.efferents[0].matrix, M3_M4_matrix_A)
+        # This is if different Projections are allowed between the same sender and receiver in different Compositions:
+        # assert np.allclose(M3.efferents[1].matrix, M3_M4_matrix_B)
+        c.run(inputs={M1:[2, -30]})
+        # assert np.allclose(c.results, [[-130.19166667, -152.53333333, -174.875]])
+        assert np.allclose(c.results, [[ -78.115,  -91.52 , -104.925]])
+
     def test_multiple_modulatory_projection_specs(self):
 
         M = pnl.DDM(name='MY DDM')
@@ -306,7 +349,6 @@ def test_formats_for_gating_specification_of_input_and_output_states(self):
         # assert 'Primary OutputState of ControlMechanism-1 (ControlSignal-0) ' \
         #        'cannot be used as a sender of a Projection to OutputState of T2' in error_text.value.args[0]
 
-
     # KDM: this is a good candidate for pytest.parametrize
     def test_masked_mapping_projection(self):
 
diff --git a/tests/scheduling/test_scheduler.py b/tests/scheduling/test_scheduler.py
index 09058299238..c29cd7ce222 100644
--- a/tests/scheduling/test_scheduler.py
+++ b/tests/scheduling/test_scheduler.py
@@ -179,7 +179,7 @@ def change_termination_processing():
                             [np.array([[2.]]), np.array([[1.]])],
                             [np.array([[10.]]), np.array([[10.]])],
                             [np.array([[2.]]), np.array([[1.]])]]
-        assert np.allclose(expected_results, S.results)
+        assert np.allclose(expected_results, np.asfarray(S.results))
 
 
 
diff --git a/tests/system/test_reinitialize_values.py b/tests/system/test_reinitialize_values.py
index 30e471c1fbb..316dcd0548b 100644
--- a/tests/system/test_reinitialize_values.py
+++ b/tests/system/test_reinitialize_values.py
@@ -187,6 +187,9 @@ def test_save_state_before_simulations(self):
                         B.parameters.value.get(S)[0],
                         C.parameters.value.get(S)]
 
-        assert np.allclose(run_2_values, run_3_values)
-        assert np.allclose(run_1_values, [np.array([[0.36]]), np.array([[0.056]]), np.array([[0.056]])])
-        assert np.allclose(run_2_values, [np.array([[0.5904]]), np.array([[0.16384]]), np.array([[0.16384]])])
+        assert np.allclose(np.asfarray(run_2_values),
+                           np.asfarray(run_3_values))
+        assert np.allclose(np.asfarray(run_1_values),
+                           [np.array([[0.36]]), np.array([[0.056]]), np.array([[0.056]])])
+        assert np.allclose(np.asfarray(run_2_values),
+                           [np.array([[0.5904]]), np.array([[0.16384]]), np.array([[0.16384]])])