diff --git a/tools/test/scenarios/fast.xml b/tools/test/scenarios/fast.xml
new file mode 100644
index 0000000..89fe845
--- /dev/null
+++ b/tools/test/scenarios/fast.xml
@@ -0,0 +1,30 @@
+<!--
+  ~ Copyright 2015 Open Networking Laboratory
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+<scenario name="smoke" description="ONOS smoke test">
+    <import file="${ONOS_SCENARIOS}/prerequisites.xml"/>
+
+    <import file="${ONOS_SCENARIOS}/setup.xml"/>
+    <dependency name="Setup" requires="Prerequisites"/>
+
+    <import file="${ONOS_SCENARIOS}/net-fast.xml"/>
+    <dependency name="Net-Fast" requires="Setup"/>
+
+    <import file="${ONOS_SCENARIOS}/archetypes.xml"/>
+    <dependency name="Archetypes" requires="Setup"/>
+
+    <import file="${ONOS_SCENARIOS}/wrapup.xml"/>
+    <dependency name="Wrapup" requires="~Archetypes,~Setup,~Net-Fast"/>
+</scenario>
