diff --git a/src/ui/src/builder/BuilderApp.vue b/src/ui/src/builder/BuilderApp.vue
index 7bd2b21fc..961e8cc0c 100644
--- a/src/ui/src/builder/BuilderApp.vue
+++ b/src/ui/src/builder/BuilderApp.vue
@@ -253,6 +253,11 @@ function handleRendererDrop(ev: DragEvent) {
 function handleRendererClick(ev: PointerEvent): void {
 	if (builderMode.value === "preview") return;
 
+	const unselectableEl: HTMLElement = (ev.target as HTMLElement).closest(
+		"[data-writer-unselectable]",
+	);
+	if (unselectableEl) return;
+
 	const targetEl: HTMLElement = (ev.target as HTMLElement).closest(
 		"[data-writer-id]",
 	);
diff --git a/src/ui/src/builder/BuilderSettings.vue b/src/ui/src/builder/BuilderSettings.vue
index d28c93039..9ed24163f 100644
--- a/src/ui/src/builder/BuilderSettings.vue
+++ b/src/ui/src/builder/BuilderSettings.vue
@@ -1,9 +1,7 @@
 <template>
 	<div v-if="ssbm.isSelectionActive()" class="BuilderSettings">
 		<div class="windowBar">
-			<div class="title">
-				{{ componentDefinition.name }}
-			</div>
+			<div class="title">{{ componentDefinition.name }}</div>
 			<button
 				v-if="description || docsString"
 				class="windowAction"
@@ -46,9 +44,18 @@
 
 		<div class="sections" :inert="readonly">
 			<BuilderSettingsProperties></BuilderSettingsProperties>
-			<BuilderSettingsBinding v-if="isBindable"></BuilderSettingsBinding>
-			<BuilderSettingsHandlers></BuilderSettingsHandlers>
-			<BuilderSettingsVisibility></BuilderSettingsVisibility>
+			<template
+				v-if="
+					!componentDefinition.toolkit ||
+					componentDefinition.toolkit == 'core'
+				"
+			>
+				<BuilderSettingsBinding
+					v-if="isBindable"
+				></BuilderSettingsBinding>
+				<BuilderSettingsHandlers></BuilderSettingsHandlers>
+				<BuilderSettingsVisibility></BuilderSettingsVisibility>
+			</template>
 		</div>
 
 		<div class="debug">
diff --git a/src/ui/src/builder/BuilderSettingsHandlers.vue b/src/ui/src/builder/BuilderSettingsHandlers.vue
index 463fe156d..81baf732c 100644
--- a/src/ui/src/builder/BuilderSettingsHandlers.vue
+++ b/src/ui/src/builder/BuilderSettingsHandlers.vue
@@ -39,6 +39,13 @@
 							>
 								Go to page "{{ pageKey }}"
 							</option>
+							<option
+								v-for="workflowKey in workflowKeys"
+								:key="`$runWorkflow_${workflowKey}`"
+								:value="`$runWorkflow_${workflowKey}`"
+							>
+								Run workflow "{{ workflowKey }}"
+							</option>
 							<template v-if="isHandlerInvalid(eventType)">
 								<option
 									:value="component.handlers?.[eventType]"
@@ -140,6 +147,13 @@
 							>
 								Go to page "{{ pageKey }}"
 							</option>
+							<option
+								v-for="workflowKey in workflowKeys"
+								:key="`$runWorkflow_${workflowKey}`"
+								:value="`$runWorkflow_${workflowKey}`"
+							>
+								Run workflow "{{ workflowKey }}"
+							</option>
 						</select>
 						<span class="desc"
 							>The function that will handle the event.</span
@@ -186,14 +200,25 @@ const recognisedEvents: ComputedRef<WriterComponentDefinition["events"]> =
 	});
 
 const userFunctions = computed(() => wf.getUserFunctions());
+
 const pageKeys = computed(() => {
 	const pages = wf.getComponents("root");
 	const pageKeys = pages
+		.filter((page) => page.type == "page")
 		.map((page) => page.content["key"])
 		.filter((pageKey) => Boolean(pageKey));
 	return pageKeys;
 });
 
+const workflowKeys = computed(() => {
+	const workflows = wf.getComponents("workflows_root");
+	const workflowKeys = workflows
+		.filter((workflow) => workflow.type == "workflows_workflow")
+		.map((workflow) => workflow.content["key"])
+		.filter((workflowKey) => Boolean(workflowKey));
+	return workflowKeys;
+});
+
 const isHandlerInvalid = (eventType: string) => {
 	const handlerFunctionName = component.value.handlers?.[eventType];
 	if (!handlerFunctionName) return false;
diff --git a/src/ui/src/builder/useComponentActions.ts b/src/ui/src/builder/useComponentActions.ts
index 86a39c425..8f87e2044 100644
--- a/src/ui/src/builder/useComponentActions.ts
+++ b/src/ui/src/builder/useComponentActions.ts
@@ -127,6 +127,12 @@ export function useComponentActions(wf: Core, ssbm: BuilderManager) {
 		type: string,
 		parentId: Component["id"],
 		position?: number,
+		initProperties?: Partial<
+			Omit<
+				Component,
+				"id" | "type" | "parent" | "content" | "handlers" | "position"
+			>
+		>,
 	) {
 		const newId = generateNewComponentId();
 		const definition = wf.getComponentDefinition(type);
@@ -137,6 +143,7 @@ export function useComponentActions(wf: Core, ssbm: BuilderManager) {
 		});
 
 		const component = {
+			...(initProperties ?? {}),
 			id: newId,
 			type,
 			parentId,
@@ -160,8 +167,19 @@ export function useComponentActions(wf: Core, ssbm: BuilderManager) {
 		type: string,
 		parentId: Component["id"],
 		position?: number,
+		initProperties?: Partial<
+			Omit<
+				Component,
+				"id" | "type" | "parent" | "content" | "handlers" | "position"
+			>
+		>,
 	): Component["id"] {
-		const component = createComponent(type, parentId, position);
+		const component = createComponent(
+			type,
+			parentId,
+			position,
+			initProperties,
+		);
 		const transactionId = `create-${component.id}`;
 		ssbm.openMutationTransaction(transactionId, `Create`);
 		wf.addComponent(component);
@@ -688,6 +706,71 @@ export function useComponentActions(wf: Core, ssbm: BuilderManager) {
 		wf.sendComponentUpdate();
 	}
 
+	/**
+	 * Add an out
+	 */
+	function addOut(
+		componentId: Component["id"],
+		out: Component["outs"][number],
+	) {
+		const component = wf.getComponentById(componentId);
+		if (!component) return;
+		const transactionId = `add-${componentId}-out-${out.outId}-${out.toNodeId}`;
+		ssbm.openMutationTransaction(transactionId, `Add out`, true);
+		ssbm.registerPreMutation(component);
+
+		component.outs = [...(component.outs ?? []), out];
+
+		ssbm.registerPostMutation(component);
+		ssbm.closeMutationTransaction(transactionId);
+		wf.sendComponentUpdate();
+	}
+
+	/**
+	 * Remove an out
+	 */
+	function removeOut(
+		componentId: Component["id"],
+		out: Component["outs"][number],
+	) {
+		const component = wf.getComponentById(componentId);
+		if (!component) return;
+		const transactionId = `edit-${componentId}-out-${out.outId}-${out.toNodeId}`;
+		ssbm.openMutationTransaction(transactionId, `Edit out`, true);
+		ssbm.registerPreMutation(component);
+
+		component.outs = component.outs.filter(
+			(o) => !(out.outId === o.outId && out.toNodeId === o.toNodeId),
+		);
+
+		ssbm.registerPostMutation(component);
+		ssbm.closeMutationTransaction(transactionId);
+		wf.sendComponentUpdate();
+	}
+
+	/**
+	 * Change coordinates
+	 */
+	function changeCoordinates(
+		componentId: Component["id"],
+		x: number,
+		y: number,
+	) {
+		const component = wf.getComponentById(componentId);
+		if (!component) return;
+
+		const transactionId = `change-${componentId}-coordinates`;
+		ssbm.openMutationTransaction(transactionId, `Change coordinates`, true);
+		ssbm.registerPreMutation(component);
+
+		component.x = Math.floor(x);
+		component.y = Math.floor(y);
+
+		ssbm.registerPostMutation(component);
+		ssbm.closeMutationTransaction(transactionId);
+		wf.sendComponentUpdate();
+	}
+
 	/**
 	 * Set the value for a component's visibility.
 	 */
@@ -833,6 +916,9 @@ export function useComponentActions(wf: Core, ssbm: BuilderManager) {
 		undo,
 		redo,
 		setContentValue,
+		addOut,
+		removeOut,
+		changeCoordinates,
 		setVisibleValue,
 		setBinding,
 		getUndoRedoSnapshot,
diff --git a/src/ui/src/components/workflows/WorkflowsWorkflow.vue b/src/ui/src/components/workflows/WorkflowsWorkflow.vue
index 69b130c0f..b9672f274 100644
--- a/src/ui/src/components/workflows/WorkflowsWorkflow.vue
+++ b/src/ui/src/components/workflows/WorkflowsWorkflow.vue
@@ -12,7 +12,9 @@
 				v-for="(arrow, arrowId) in arrows"
 				:key="arrowId"
 				:arrow="arrow"
-				@click="handleArrowClick"
+				:is-selected="selectedArrow == arrowId"
+				@click="handleArrowClick($event, arrowId)"
+				@delete="handleDeleteClick($event, arrow)"
 			></WorkflowArrow>
 		</svg>
 		<template v-for="component in children" :key="component.id">
@@ -61,9 +63,19 @@ export default {
 		previewField: "key",
 	},
 };
+
+export type WorkflowArrowData = {
+	x1: number;
+	y1: number;
+	x2: number;
+	y2: number;
+	color: string;
+	fromNodeId: Component["id"];
+	out: Component["outs"][number];
+};
 </script>
 <script setup lang="ts">
-import { Ref, computed, inject, onMounted, ref } from "vue";
+import { Ref, computed, inject, nextTick, onMounted, ref } from "vue";
 import { useComponentActions } from "@/builder/useComponentActions";
 import { useDragDropComponent } from "@/builder/useDragDropComponent";
 import injectionKeys from "@/injectionKeys";
@@ -73,9 +85,10 @@ const rootEl: Ref<HTMLElement | null> = ref(null);
 const fields = inject(injectionKeys.evaluatedFields);
 const wf = inject(injectionKeys.core);
 const wfbm = inject(injectionKeys.builderManager);
-const arrows = ref([]);
+const arrows: Ref<WorkflowArrowData[]> = ref([]);
 const renderOffset = ref({ x: 0, y: 0 });
 let clickOffset = { x: 0, y: 0 };
+const selectedArrow = ref(null);
 
 const workflowComponentId = inject(injectionKeys.componentId);
 
@@ -83,7 +96,8 @@ const children = computed(() =>
 	wf.getComponents(workflowComponentId, { sortedByPosition: true }),
 );
 
-const { createAndInsertComponent } = useComponentActions(wf, wfbm);
+const { createAndInsertComponent, addOut, removeOut, changeCoordinates } =
+	useComponentActions(wf, wfbm);
 const { getComponentInfoFromDrag } = useDragDropComponent(wf);
 
 const activeNodeOut: Ref<{
@@ -119,6 +133,8 @@ function refreshArrows() {
 					x2: toCBR.x - canvasCBR.x,
 					y2: toCBR.y - canvasCBR.y + toCBR.height / 2,
 					color: getComputedStyle(fromEl).backgroundColor,
+					fromNodeId,
+					out,
 				});
 			});
 		});
@@ -191,7 +207,17 @@ function handleDrop(ev: DragEvent) {
 	createNode(draggedType, x, y);
 }
 
-function handleArrowClick() {}
+function handleArrowClick(ev: MouseEvent, arrowId: number) {
+	if (selectedArrow.value == arrowId) {
+		selectedArrow.value = null;
+		return;
+	}
+	selectedArrow.value = arrowId;
+}
+
+async function handleDeleteClick(ev: MouseEvent, arrow: WorkflowArrowData) {
+	removeOut(arrow.fromNodeId, arrow.out);
+}
 
 function handleNodeDragStart(ev: DragEvent) {
 	ev.stopPropagation();
@@ -209,55 +235,70 @@ function handleNodeDrag(ev: DragEvent, componentId: Component["id"]) {
 	if (x < 0 || y < 0) return;
 
 	const component = wf.getComponentById(componentId);
-	component.x = x - clickOffset.x;
-	component.y = y - clickOffset.y;
-	refreshArrows();
+
+	const newX = x - clickOffset.x;
+	const newY = y - clickOffset.y;
+
+	if (component.x == newX && component.y == newY) return;
+
+	component.x = newX;
+	component.y = newY;
+
+	setTimeout(() => {
+		// Debouncing
+		if (component.x !== newX) return;
+		if (component.y !== newY) return;
+		changeCoordinates(componentId, newX, newY);
+	}, 200);
 }
 
 function handleNodeDragend(ev: DragEvent) {
 	ev.preventDefault();
 }
 
-function handleNodeClick(ev: MouseEvent, componentId: Component["id"]) {
+async function handleNodeClick(ev: MouseEvent, componentId: Component["id"]) {
 	if (!activeNodeOut.value) return;
 	if (activeNodeOut.value.fromComponentId == componentId) return;
 
-	const component = wf.getComponentById(activeNodeOut.value.fromComponentId);
-
-	component.outs = [
-		...(component.outs ?? []),
-		{
-			toNodeId: componentId,
-			outId: activeNodeOut.value.outId,
-		},
-	];
+	addOut(activeNodeOut.value.fromComponentId, {
+		toNodeId: componentId,
+		outId: activeNodeOut.value.outId,
+	});
 
 	activeNodeOut.value = null;
-	refreshArrows();
 }
 
-function createNode(type: string, x: number, y: number) {
-	const componentId = createAndInsertComponent(type, workflowComponentId);
-	const component = wf.getComponentById(componentId);
-	component.x = x;
-	component.y = y;
+async function createNode(type: string, x: number, y: number) {
+	createAndInsertComponent(type, workflowComponentId, undefined, { x, y });
 }
 
-watch(children, async (postChildren, preChildren) => {
-	// Remove references when a node is deleted
+watch(
+	children,
+	async (postChildren, preChildren) => {
+		// Remove references when a node is deleted
+
+		const preIds = new Set(preChildren.map((c) => c.id));
+		const postIds = new Set(postChildren.map((c) => c.id));
+		const removedIds = new Set(
+			[...preIds].filter((cId) => !postIds.has(cId)),
+		);
 
-	const preIds = preChildren.map((c) => c.id);
-	const postIds = postChildren.map((c) => c.id);
-	const removedIds = preIds.filter((cId) => !postIds.includes(cId));
-	removedIds.forEach((removedId) => {
 		postChildren.forEach((c) => {
-			if (!c.outs || c.outs.length == 0) return;
-			c.outs = c.outs.filter((out) => out.toNodeId !== removedId);
+			if (!c.outs || c.outs.length === 0) return;
+			c.outs = c.outs.filter((out) => !removedIds.has(out.toNodeId));
 		});
-	});
-	refreshArrows();
-	await wf.sendComponentUpdate();
-});
+
+		// Refresh arrows
+
+		await nextTick();
+		refreshArrows();
+
+		if (removedIds.size > 0) {
+			wf.sendComponentUpdate();
+		}
+	},
+	{ deep: true },
+);
 
 onMounted(() => {
 	refreshArrows();
diff --git a/src/ui/src/components/workflows/abstract/WorkflowsNode.vue b/src/ui/src/components/workflows/abstract/WorkflowsNode.vue
index 04dac5d4f..3a2816b35 100644
--- a/src/ui/src/components/workflows/abstract/WorkflowsNode.vue
+++ b/src/ui/src/components/workflows/abstract/WorkflowsNode.vue
@@ -42,6 +42,7 @@ export default {
 		toolkit: "workflows",
 		category: "Other",
 		fields: {},
+		allowedParentTypes: ["workflows_workflow"],
 		previewField: "text",
 	},
 };
diff --git a/src/ui/src/components/workflows/base/WorkflowArrow.vue b/src/ui/src/components/workflows/base/WorkflowArrow.vue
index 3d9c83f82..5eebc8d75 100644
--- a/src/ui/src/components/workflows/base/WorkflowArrow.vue
+++ b/src/ui/src/components/workflows/base/WorkflowArrow.vue
@@ -1,79 +1,104 @@
 <template>
-	<g tabindex="0" @click="handleClick">
-		<path :d="pathD" :style="{ stroke: props.arrow.color }"></path>
+	<g class="WorkflowArrow" tabindex="0" data-writer-unselectable="true">
+		<path :d="pathD" :style="{ stroke: arrow.color }"></path>
 		<path
 			:d="pathD"
 			:style="{
-				stroke: props.arrow.color,
+				stroke: arrow.color,
 				strokeWidth: 12,
 				opacity: isSelected ? `0.2` : `0`,
 			}"
 		></path>
+		<g
+			v-if="isSelected"
+			class="delete"
+			tabindex="0"
+			aria-label="Delete relation"
+			@click="handleDeleteClick"
+			@keypress.enter="handleDeleteClick"
+		>
+			<circle :cx="points[3].x" :cy="points[3].y" r="12" />
+			<line
+				class="cross"
+				:x1="points[3].x - 4"
+				:y1="points[3].y - 4"
+				:x2="points[3].x + 4"
+				:y2="points[3].y + 4"
+				:stroke="arrow.color"
+				stroke-width="2"
+			/>
+			<line
+				class="cross"
+				:x1="points[3].x + 4"
+				:y1="points[3].y - 4"
+				:x2="points[3].x - 4"
+				:y2="points[3].y + 4"
+				:stroke="arrow.color"
+				stroke-width="2"
+			/>
+		</g>
 	</g>
 </template>
 
 <script setup lang="ts">
 import { computed, ref } from "vue";
+import { type WorkflowArrowData } from "../WorkflowsWorkflow.vue";
+
+const PROTRUSION_LENGTH = 30;
+const emit = defineEmits(["delete"]);
 
 const props = defineProps<{
-	arrow: {
-		x1: number;
-		y1: number;
-		x2: number;
-		y2: number;
-		color: string;
-	};
+	arrow: WorkflowArrowData;
+	isSelected: boolean;
 }>();
 
-const isSelected = ref(false);
-
-function handleClick() {
-	isSelected.value = true;
-}
-
-const pathD = computed(() => {
+const points = computed(() => {
 	const xDif = props.arrow.x2 - props.arrow.x1;
 	const yDif = props.arrow.y2 - props.arrow.y1;
 
-	const protrusionLength = 30;
-
-	const points = [
+	const ps = [
 		{ x: props.arrow.x1, y: props.arrow.y1 },
-		{ x: props.arrow.x1 + protrusionLength, y: props.arrow.y1 },
+		{ x: props.arrow.x1 + PROTRUSION_LENGTH, y: props.arrow.y1 },
 		{
-			x: props.arrow.x1 + protrusionLength,
+			x: props.arrow.x1 + PROTRUSION_LENGTH,
 			y: props.arrow.y1 + yDif * 0.25,
 		},
 		{ x: props.arrow.x1 + xDif * 0.5, y: props.arrow.y1 + yDif * 0.5 },
 		{
-			x: props.arrow.x2 - protrusionLength,
+			x: props.arrow.x2 - PROTRUSION_LENGTH,
 			y: props.arrow.y1 + yDif * 0.75,
 		},
-		{ x: props.arrow.x2 - protrusionLength, y: props.arrow.y2 },
+		{ x: props.arrow.x2 - PROTRUSION_LENGTH, y: props.arrow.y2 },
 		{ x: props.arrow.x2, y: props.arrow.y2 },
 	];
+	return ps;
+});
 
+const pathD = computed(() => {
+	const xDif = props.arrow.x2 - props.arrow.x1;
+	const ps = points.value;
 	let s: string;
 
-	if (xDif > protrusionLength) {
-		s = `M ${points[0].x} ${points[0].y}`;
-		s += `C ${points[3].x} ${points[0].y}, ${points[3].x} ${points[6].y}, ${points[6].x} ${points[6].y}`;
+	if (xDif > PROTRUSION_LENGTH) {
+		s = `M ${ps[0].x} ${ps[0].y}`;
+		s += `C ${ps[3].x} ${ps[0].y}, ${ps[3].x} ${ps[6].y}, ${ps[6].x} ${ps[6].y}`;
 	} else {
-		s = `M ${points[0].x} ${points[0].y}`;
-		s += `C ${points[1].x} ${points[1].y}, ${points[2].x} ${points[2].y}, ${points[3].x} ${points[3].y}`;
-		s += `C ${points[4].x} ${points[4].y}, ${points[5].x} ${points[5].y}, ${points[6].x} ${points[6].y}`;
+		s = `M ${ps[0].x} ${ps[0].y}`;
+		s += `C ${ps[1].x} ${ps[1].y}, ${ps[2].x} ${ps[2].y}, ${ps[3].x} ${ps[3].y}`;
+		s += `C ${ps[4].x} ${ps[4].y}, ${ps[5].x} ${ps[5].y}, ${ps[6].x} ${ps[6].y}`;
 	}
 
 	return s;
 });
+
+function handleDeleteClick() {
+	emit("delete");
+}
 </script>
 
 <style scoped>
 @import "@/renderer/sharedStyles.css";
 
-.WorkflowsArrow {
-}
-
 g {
 	outline: none;
 }
@@ -81,4 +106,13 @@ g {
 path {
 	fill: none;
 }
+
+circle {
+	fill: white;
+	filter: drop-shadow(0 0 2px rgba(0, 0, 0, 0.2));
+}
+
+g.delete .cross {
+	stroke: black;
+}
 </style>
diff --git a/src/ui/src/core/typeHierarchy.ts b/src/ui/src/core/typeHierarchy.ts
index f2065b0fa..ff33586e5 100644
--- a/src/ui/src/core/typeHierarchy.ts
+++ b/src/ui/src/core/typeHierarchy.ts
@@ -30,20 +30,30 @@ function getAllowedSet(
 ): Set<Component["type"]> {
 	const { type, parentId } = components[componentId];
 	const supportedTypes = getSupportedComponentTypes().filter(
-		(t) => t !== "root",
+		(t) => t !== "root" && t !== "workflows_root",
 	);
-	const { allowedChildrenTypes } = getComponentDefinition(type);
+	const { allowedChildrenTypes, toolkit } = getComponentDefinition(type);
 	if (!allowedChildrenTypes) return new Set([]);
 
-	let allowed = new Set<string>(allowedChildrenTypes);
+	let allowed: Set<string> = new Set(allowedChildrenTypes);
 	if (allowedChildrenTypes.includes("*")) {
-		return new Set(supportedTypes);
+		allowed = new Set([...allowed, ...supportedTypes]);
 	}
 	if (allowed.delete("inherit")) {
 		if (!parentId) return allowed;
 		const parentContainable = getContainableTypes(components, parentId);
 		allowed = new Set([...allowed, ...parentContainable]);
 	}
+
+	if (toolkit) {
+		allowed = new Set(
+			Array.from(allowed).filter(
+				(childType) =>
+					getComponentDefinition(childType).toolkit == toolkit,
+			),
+		);
+	}
+
 	return allowed;
 }
 
diff --git a/src/ui/src/renderer/ComponentProxy.vue b/src/ui/src/renderer/ComponentProxy.vue
index 326623405..99c0bd5d3 100644
--- a/src/ui/src/renderer/ComponentProxy.vue
+++ b/src/ui/src/renderer/ComponentProxy.vue
@@ -203,7 +203,8 @@ export default {
 			handlerFunctionName: string,
 			isBinding: boolean,
 		) => {
-			const isForwardable = !handlerFunctionName.startsWith("$");
+			const isForwardable = !handlerFunctionName.startsWith("$goToPage_");
+
 			if (isForwardable && !isBinding) {
 				return (ev: Event) => {
 					// Only include payload if there's a function waiting for it on the other side
@@ -219,6 +220,11 @@ export default {
 					) {
 						includePayload = true;
 					}
+
+					if (handlerFunctionName.startsWith("$runWorkflow_")) {
+						includePayload = true;
+					}
+
 					wf.forwardEvent(ev, instancePath, includePayload);
 				};
 			}
diff --git a/src/ui/src/renderer/useEvaluator.ts b/src/ui/src/renderer/useEvaluator.ts
index f1bbcd770..69c6199b8 100644
--- a/src/ui/src/renderer/useEvaluator.ts
+++ b/src/ui/src/renderer/useEvaluator.ts
@@ -174,7 +174,7 @@ export function useEvaluator(wf: Core) {
 			try {
 				parsedValue = JSON.parse(evaluated);
 			} catch {
-				return JSON.parse(defaultValue) ?? null;
+				return JSON.parse(defaultValue ?? null);
 			}
 			return parsedValue;
 		} else if (fieldType == FieldType.Number) {
@@ -183,7 +183,7 @@ export function useEvaluator(wf: Core) {
 			if (isValueEmpty) return floatDefaultValue ?? null;
 
 			const n = parseFloat(evaluated);
-			if (typeof n === undefined || Number.isNaN(n))
+			if (typeof n === "undefined" || Number.isNaN(n))
 				return floatDefaultValue ?? null;
 			return n;
 		} else if (fieldType == FieldType.IdKey) {
diff --git a/src/writer/abstract.py b/src/writer/abstract.py
index 2574b6967..b0ce57f98 100644
--- a/src/writer/abstract.py
+++ b/src/writer/abstract.py
@@ -13,107 +13,4 @@
 templates:Dict[str, AbstractTemplate]  = {}
 
 def register_abstract_template(type: str, abstract_template: AbstractTemplate):
-    templates[type] = abstract_template
-
-
-register_abstract_template("workflows_setstate", AbstractTemplate(
-    baseType="workflows_node",
-    writer={
-        "name": "Set state",
-        "description": "Set the value for a state element",
-        "category": "Content",
-        "allowedParentTypes": ["workflows_workflow"],
-        "fields": {
-            "element": {
-                "name": "State element",
-                "type": "Text",
-            },
-            "value": {
-                "name": "Value",
-                "type": "Text",
-            },
-        },
-        "outs": {
-            "success": {
-                "name": "Success",
-                "description": "If the function doesn't raise an Exception.",
-                "style": "success",
-            },
-            "error": {
-                "name": "Error",
-                "description": "If the function raises an Exception.",
-                "style": "error",
-            },
-        },
-    }
-))
-
-register_abstract_template("workflows_writercompletion", AbstractTemplate(
-    baseType="workflows_node",
-    writer={
-        "name": "Writer Completion",
-        "description": "Set the value for a state element",
-        "category": "Content",
-        "allowedParentTypes": ["workflows_workflow"],
-        "fields": {
-            "prompt": {
-                "name": "Prompt",
-                "type": "Text",
-            },
-            "tools": {
-                "name": "Tools",
-                "type": "Object"
-            }
-        },
-        "outs": {
-            "$tools": {
-                "field": "tools"
-            },
-            "success": {
-                "name": "Success",
-                "description": "If the function doesn't raise an Exception.",
-                "style": "success",
-            },
-            "error": {
-                "name": "Error",
-                "description": "If the function raises an Exception.",
-                "style": "error",
-            },
-        },
-    }
-))
-
-register_abstract_template("workflows_writerclassification", AbstractTemplate(
-    baseType="workflows_node",
-    writer={
-        "name": "Writer Classification",
-        "description": "Classify a text.",
-        "category": "Content",
-        "allowedParentTypes": ["workflows_workflow"],
-        "fields": {
-            "text": {
-                "name": "Text",
-                "type": "Text",
-            },
-            "categories": {
-                "name": "Categories",
-                "type": "Key-Value"
-            },
-            "additionalContext": {
-                "name": "Additional context",
-                "type": "Text",
-                "control": "Textarea"
-            },
-        },
-        "outs": {
-            "$dynamic": {
-                "field": "categories"
-            },
-            "error": {
-                "name": "Error",
-                "description": "If the function raises an Exception.",
-                "style": "error",
-            },
-        },
-    }
-))
\ No newline at end of file
+    templates[type] = abstract_template
\ No newline at end of file
diff --git a/src/writer/core.py b/src/writer/core.py
index b5b194740..b0044546e 100644
--- a/src/writer/core.py
+++ b/src/writer/core.py
@@ -42,6 +42,7 @@
 
 import pyarrow  # type: ignore
 
+import writer.workflows
 from writer import core_ui
 from writer.core_ui import Component
 from writer.ss_types import (
@@ -1089,7 +1090,7 @@ def execute(self, args: dict):
 
 class MiddlewareRegistry:
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.registry: List[MiddlewareExecutor] = []
 
     def register(self, middleware: Callable):
@@ -1167,7 +1168,7 @@ def register_module(self, module: ModuleType):
                 f"Attempted to register a non-module object: {module}"
                 )
 
-    def find_handler(self, handler_name: str) -> Optional[Callable]:
+    def find_handler_callable(self, handler_name: str) -> Optional[Callable]:
         if handler_name not in self.handler_map:
             return None
         handler_entry: EventHandlerRegistry.HandlerEntry = \
@@ -1425,16 +1426,13 @@ def replacer(matched):
             full_match = self.template_regex.fullmatch(field_value)
 
             if full_match is None:
-                print(f"Did not obtain full match for {field_key}")
                 replaced = self.template_regex.sub(lambda m: str(replacer(m)), field_value)
             else:
-                print(f"Obtained full match for {field_key}")
                 replaced = replacer(full_match)
 
             if (replaced is not None) and as_json:
                 return json.loads(replaced)
             else:
-                print(f"Returning {field_key} as {type(replaced)}")
                 return replaced
         else:
             raise ValueError(f"Couldn't acquire a component by ID '{component_id}'")
@@ -1696,6 +1694,27 @@ def _handle_binding(self, event_type, target_component, instance_path, payload)
             return
         self.evaluator.set_state(binding["stateRef"], instance_path, payload)
 
+    def _get_workflow_callable(self, workflow_key):
+        def fn(payload, context, session):
+            execution_env = {
+                "payload": payload,
+                "context": context,
+                "session": session
+            }
+            writer.workflows.run_workflow_by_key(self.session, workflow_key, execution_env)
+        return fn
+
+    def _get_handler_callable(self, handler: str) -> Optional[Callable]:
+        if handler.startswith("$runWorkflow_"):
+            workflow_key = handler[13:] 
+            return self._get_workflow_callable(workflow_key)
+
+        current_app_process = get_app_process()
+        handler_registry = current_app_process.handler_registry
+        callable_handler = handler_registry.find_handler_callable(handler)
+        return callable_handler
+
+
     def _call_handler_callable(
         self,
         event_type: str,
@@ -1703,18 +1722,18 @@ def _call_handler_callable(
         instance_path: List[InstancePathItem],
         payload: Any
     ) -> Any:
-        current_app_process = get_app_process()
-        handler_registry = current_app_process.handler_registry
         if not target_component.handlers:
             return
         handler = target_component.handlers.get(event_type)
         if not handler:
             return
 
-        callable_handler = handler_registry.find_handler(handler)
-        if not callable_handler:
+        handler_callable = self._get_handler_callable(handler)
+        if not handler_callable:
             raise ValueError(f"""Invalid handler. Couldn't find the handler "{ handler }".""")
 
+        print("paylo is " + repr(payload))
+
         # Preparation of arguments
         context_data = self.evaluator.get_context_data(instance_path)
         context_data['event'] = event_type
@@ -1727,13 +1746,13 @@ def _call_handler_callable(
         }
 
         # Invocation of handler
+        current_app_process = get_app_process()
         result = None
         captured_stdout = None
         with core_ui.use_component_tree(self.session.session_component_tree), \
             contextlib.redirect_stdout(io.StringIO()) as f:
             middlewares_executors = current_app_process.middleware_registry.executors()
-
-            result = writer_event_handler_invoke_with_middlewares(middlewares_executors, callable_handler, writer_args)
+            result = writer_event_handler_invoke_with_middlewares(middlewares_executors, handler_callable, writer_args)
             captured_stdout = f.getvalue()
 
         if captured_stdout:
diff --git a/src/writer/workflows.py b/src/writer/workflows.py
new file mode 100644
index 000000000..481257966
--- /dev/null
+++ b/src/writer/workflows.py
@@ -0,0 +1,84 @@
+from typing import Dict, List, Tuple
+
+import writer.core
+import writer.workflows_blocks
+from writer.core_ui import Component
+
+
+def _get_workflow_nodes(component_id):
+    return writer.core.base_component_tree.get_descendents(component_id)
+
+def run_workflow_by_key(session, workflow_key: str, execution_env: Dict):
+    state = session.session_state
+    state.add_log_entry("info", "Workflow", f"""Running workflow "{workflow_key}".""")
+
+    all_components = writer.core.base_component_tree.components.values()
+    workflows = list(filter(lambda c: c.type == "workflows_workflow" and c.content.get("key") == workflow_key, all_components))
+    if len(workflows) == 0:
+        return
+    workflow = workflows[0]
+
+    run_workflow(session, workflow.id, execution_env)
+    state.add_log_entry("info", "Workflow", f"""Finished executing workflow "{workflow_key}".""")
+
+
+def run_workflow(session, component_id: str, execution_env: Dict):
+    final_nodes = _get_final_nodes(component_id)
+    execution: Dict = {}
+    for node in final_nodes:
+        _run_node(node, execution, session, execution_env)
+
+
+def _get_final_nodes(component_id):
+    final_nodes = []
+    nodes = _get_workflow_nodes(component_id)
+    for node in nodes:
+        if not node.outs:
+            final_nodes.append(node)
+    return final_nodes
+
+def _get_dependencies(target_node: "Component"):
+    dependencies:List[Tuple] = []
+    parent_id = target_node.parentId
+    if not parent_id:
+        return dependencies
+    nodes = _get_workflow_nodes(parent_id)
+    for node in nodes:
+        if not node.outs:
+            continue
+        for out in node.outs:
+            to_node_id = out.get("toNodeId")
+            out_id = out.get("outId")
+            if to_node_id == target_node.id:
+                dependencies.append((node, out_id))
+    return dependencies
+    
+
+def _run_node(target_node: "Component", execution, session, execution_env: Dict):
+    tool_class = writer.workflows_blocks.blocks.block_map.get(target_node.type)
+    if not tool_class:
+        raise RuntimeError(f"Couldn't find tool for {target_node.type}.")
+    session.session_state.add_log_entry("info", "Workflow", f"""Running node "{target_node.id}".""")
+    dependencies = _get_dependencies(target_node)
+
+    tool = execution.get(target_node.id)
+    if tool:
+        return tool 
+
+    result = None
+    matched_dependencies = 0
+    for node, out_id in dependencies:
+        tool = _run_node(node, execution, session, execution_env)
+        if not tool:
+            continue
+        if tool.outcome == out_id:
+            matched_dependencies += 1
+        result = tool.result
+
+    if len(dependencies) > 0 and matched_dependencies == 0:
+        return
+
+    tool = tool_class(target_node, execution, session, (execution_env | {"result": result}))
+    tool.run()
+    execution[target_node.id] = tool
+    return tool
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/__init__.py b/src/writer/workflows_blocks/__init__.py
new file mode 100644
index 000000000..5d64d8a7b
--- /dev/null
+++ b/src/writer/workflows_blocks/__init__.py
@@ -0,0 +1,11 @@
+from writer.workflows_blocks.httprequest import HTTPRequest
+from writer.workflows_blocks.runworkflow import RunWorkflow
+from writer.workflows_blocks.setstate import SetState
+from writer.workflows_blocks.writerclassification import WriterClassification
+from writer.workflows_blocks.writercompletion import WriterCompletion
+
+SetState.register("workflows_setstate")
+WriterClassification.register("workflows_writerclassification")
+WriterCompletion.register("workflows_writercompletion")
+HTTPRequest.register("workflows_httprequest")
+RunWorkflow.register("workflows_runworkflow")
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/blocks.py b/src/writer/workflows_blocks/blocks.py
new file mode 100644
index 000000000..5937f9588
--- /dev/null
+++ b/src/writer/workflows_blocks/blocks.py
@@ -0,0 +1,32 @@
+from typing import Dict
+
+import writer.core
+import writer.core_ui
+import writer.workflows_blocks
+from writer.ss_types import InstancePath
+
+block_map = {}
+
+class WorkflowBlock:
+    
+    @classmethod
+    def register(cls, type: str):
+        block_map[type] = cls
+
+    def __init__(self, component: "writer.core_ui.Component", execution: Dict, session: "writer.core.WriterSession", execution_env: Dict):
+        self.outcome = None
+        self.component = component
+        self.execution = execution
+        self.session = session
+        self.execution_env = execution_env
+        self.result = None
+        self.evaluator = writer.core.Evaluator(session.session_state, session.session_component_tree)
+        self.instance_path: InstancePath = [{"componentId": self.component.id, "instanceNumber": 0}]
+
+    def _get_field(self, field_key: str, as_json=False):
+        v = self.evaluator.evaluate_field(self.instance_path, field_key, base_context=self.execution_env, as_json=as_json)
+
+        return v
+
+    def run(self):
+        pass
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/foreach.py b/src/writer/workflows_blocks/foreach.py
new file mode 100644
index 000000000..3d0648a56
--- /dev/null
+++ b/src/writer/workflows_blocks/foreach.py
@@ -0,0 +1,65 @@
+import writer.workflows
+from writer.abstract import register_abstract_template
+from writer.ss_types import AbstractTemplate
+from writer.workflows_blocks.blocks import WorkflowBlock
+
+
+class ForEach(WorkflowBlock):
+
+    @classmethod
+    def register(cls, type: str):
+        super(ForEach, cls).register(type)
+        register_abstract_template(type, AbstractTemplate(
+            baseType="workflows_node",
+            writer={
+                "name": "For-each loop",
+                "description": "Executes a workflow repeatedly, based on the items provided.",
+                "category": "Content",
+                "fields": {
+                    "workflowKey": {
+                        "name": "Workflow key",
+                        "desc": "The workflow which will be executed for each item.",
+                        "type": "Text",
+                    },
+                    "items": {
+                        "name": "Items",
+                        "desc": "The item value will be passed in the execution environment and will be available via @{item}.",
+                        "default": "{}",
+                        "type": "Object",
+                        "control": "Textarea"
+                    },
+                    "executionEnv": {
+                        "name": "Execution environment",
+                        "desc": "You can add other values to the execution environment.",
+                        "default": "{}",
+                        "type": "Object",
+                        "control": "Textarea"
+                    },
+                },
+                "outs": {
+                    "success": {
+                        "name": "Success",
+                        "description": "The workflow wasn't executed successfully.",
+                        "style": "success",
+                    },
+                    "error": {
+                        "name": "Error",
+                        "description": "The workflow wasn't executed successfully.",
+                        "style": "error",
+                    },
+                },
+            }
+        ))
+
+    def run(self):
+        workflow_key = self._get_field("workflowKey")
+        items = self._get_field("items")
+        base_execution_env = self._get_field("executionEnv")
+
+        try:
+            for item in items:
+                writer.workflows.run_workflow_by_key(self.session, workflow_key, base_execution_env | { "item": item })
+            self.outcome = "success"
+        except Exception:
+            self.result = "HTTP call failed."
+            self.outcome = "connectionError"
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/httprequest.py b/src/writer/workflows_blocks/httprequest.py
new file mode 100644
index 000000000..6780b37f3
--- /dev/null
+++ b/src/writer/workflows_blocks/httprequest.py
@@ -0,0 +1,75 @@
+import requests
+
+from writer.abstract import register_abstract_template
+from writer.ss_types import AbstractTemplate
+from writer.workflows_blocks.blocks import WorkflowBlock
+
+
+class HTTPRequest(WorkflowBlock):
+
+    @classmethod
+    def register(cls, type: str):
+        super(HTTPRequest, cls).register(type)
+        register_abstract_template(type, AbstractTemplate(
+            baseType="workflows_node",
+            writer={
+                "name": "HTTP Request",
+                "description": "Executes an HTTP request",
+                "category": "Content",
+                "fields": {
+                    "method": {
+                        "name": "Method",
+                        "type": "Text",
+                    },
+                    "url": {
+                        "name": "URL",
+                        "type": "Text",
+                    },
+                    "headers": {
+                        "name": "Headers",
+                        "type": "Key-Value",
+                        "default": "{}",
+                    },
+                    "body": {
+                        "name": "Body",
+                        "type": "Text",
+                        "control": "Textarea"
+                    },
+                },
+                "outs": {
+                    "success": {
+                        "name": "Success",
+                        "description": "The request was successful.",
+                        "style": "success",
+                    },
+                    "responseError": {
+                        "name": "Response error",
+                        "description": "The connection was established successfully but an error response code was received.",
+                        "style": "error",
+                    },
+                    "connectionError": {
+                        "name": "Connection error",
+                        "description": "The connection couldn't be established.",
+                        "style": "error",
+                    },
+                },
+            }
+        ))
+
+    def run(self):
+        method = self._get_field("method")
+        url = self._get_field("url")
+        headers = self._get_field("headers")
+        body = self._get_field("body")
+
+        try:
+            req = requests.request(method, url, headers=headers, data=body)
+            self.result = req.text
+            if req.ok:
+                self.outcome = "success"
+            else:
+                self.outcome = "responseError"
+        except Exception as e:
+            print(e)
+            self.result = "HTTP call failed."
+            self.outcome = "connectionError"
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/runworkflow.py b/src/writer/workflows_blocks/runworkflow.py
new file mode 100644
index 000000000..257bd7460
--- /dev/null
+++ b/src/writer/workflows_blocks/runworkflow.py
@@ -0,0 +1,56 @@
+import writer.workflows
+from writer.abstract import register_abstract_template
+from writer.ss_types import AbstractTemplate
+from writer.workflows_blocks.blocks import WorkflowBlock
+
+
+class RunWorkflow(WorkflowBlock):
+
+    @classmethod
+    def register(cls, type: str):
+        super(RunWorkflow, cls).register(type)
+        register_abstract_template(type, AbstractTemplate(
+            baseType="workflows_node",
+            writer={
+                "name": "Run workflow",
+                "description": "Executes a workflow",
+                "category": "Content",
+                "fields": {
+                    "workflowKey": {
+                        "name": "Workflow key",
+                        "type": "Text",
+                    },
+                    "context": {
+                        "name": "Context",
+                        "desc": "Values passed in the context will be available using the template syntax i.e. @{my_context_var}",
+                        "default": "{}",
+                        "type": "Object",
+                        "control": "Textarea"
+                    },
+                },
+                "outs": {
+                    "success": {
+                        "name": "Success",
+                        "description": "The request was successful.",
+                        "style": "success",
+                    },
+                    "error": {
+                        "name": "Error",
+                        "description": "The workflow was executed successfully.",
+                        "style": "error",
+                    },
+                },
+            }
+        ))
+
+    def run(self):
+        workflow_key = self._get_field("workflowKey")
+        context = self._get_field("context", as_json=True)
+
+        try:
+            writer.workflows.run_workflow_by_key(self.session, workflow_key, context)
+            self.outcome = "success"
+        except Exception as e:
+            print("running the other workflow " + repr(e))
+            self.result = "Running workflow failed."
+            self.outcome = "error"
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/setstate.py b/src/writer/workflows_blocks/setstate.py
new file mode 100644
index 000000000..293014201
--- /dev/null
+++ b/src/writer/workflows_blocks/setstate.py
@@ -0,0 +1,50 @@
+from writer.abstract import register_abstract_template
+from writer.ss_types import AbstractTemplate
+from writer.workflows_blocks.blocks import WorkflowBlock
+
+
+class SetState(WorkflowBlock):
+
+    @classmethod
+    def register(cls, type: str):
+        super(SetState, cls).register(type)
+        register_abstract_template(type, AbstractTemplate(
+            baseType="workflows_node",
+            writer={
+                "name": "Set state",
+                "description": "Set the value for a state element",
+                "category": "Content",
+                "fields": {
+                    "element": {
+                        "name": "State element",
+                        "type": "Text",
+                    },
+                    "value": {
+                        "name": "Value",
+                        "type": "Text",
+                    },
+                },
+                "outs": {
+                    "success": {
+                        "name": "Success",
+                        "description": "If the function doesn't raise an Exception.",
+                        "style": "success",
+                    },
+                    "error": {
+                        "name": "Error",
+                        "description": "If the function raises an Exception.",
+                        "style": "error",
+                    },
+                },
+            }
+        ))
+
+    def run(self):
+        element = self._get_field("element")
+        value = self._get_field("value")
+
+        try:
+            self.evaluator.set_state(element, self.instance_path, value)
+            self.outcome = "success"
+        except Exception:
+            self.outcome = "error"
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/writerclassification.py b/src/writer/workflows_blocks/writerclassification.py
new file mode 100644
index 000000000..fb0781256
--- /dev/null
+++ b/src/writer/workflows_blocks/writerclassification.py
@@ -0,0 +1,84 @@
+import json
+
+from writer.abstract import register_abstract_template
+from writer.ss_types import AbstractTemplate
+from writer.workflows_blocks.blocks import WorkflowBlock
+
+
+class WriterClassification(WorkflowBlock):
+
+    @classmethod
+    def register(cls, type: str):
+        super(WriterClassification, cls).register(type)
+        register_abstract_template("workflows_writerclassification", AbstractTemplate(
+            baseType="workflows_node",
+            writer={
+                "name": "Writer Classification",
+                "description": "Classify a text.",
+                "category": "Content",
+                "fields": {
+                    "text": {
+                        "name": "Text",
+                        "type": "Text",
+                    },
+                    "categories": {
+                        "name": "Categories",
+                        "type": "Key-Value"
+                    },
+                    "additionalContext": {
+                        "name": "Additional context",
+                        "type": "Text",
+                        "control": "Textarea"
+                    },
+                },
+                "outs": {
+                    "$dynamic": {
+                        "field": "categories"
+                    },
+                    "error": {
+                        "name": "Error",
+                        "description": "If the function raises an Exception.",
+                        "style": "error",
+                    },
+                },
+            }
+        ))
+
+    def run(self):
+        import writer.ai
+
+        text = self._get_field("text")
+        additional_context = self._get_field("additionalContext")
+        categories = self._get_field("categories", as_json=True)
+        # model_id = self._get_field("modelId")
+
+        config = {}
+        # if model_id:
+        #     config["model"] = model_id
+
+        try:
+            prompt = f"""
+Classify the text under “CONTENT” into one of the following categories:
+
+{ json.dumps(categories) }
+
+Your output should be only the key and not contain anything else. For example: { " , ".join(list(categories.keys())) }.
+
+Additional context:
+
+{ additional_context }
+
+CONTENT:
+
+{ text }
+"""
+            result = writer.ai.complete(prompt, config).strip()
+            self.result = result
+            self.outcome = f"$dynamic_{result}"
+            print("result is")
+            print(self.result)
+            print(self.outcome)
+        except BaseException as e:
+            raise e
+            self.result = "Text completion failed"
+            self.outcome = "error"
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/writercompletion.py b/src/writer/workflows_blocks/writercompletion.py
new file mode 100644
index 000000000..b9695bfd1
--- /dev/null
+++ b/src/writer/workflows_blocks/writercompletion.py
@@ -0,0 +1,45 @@
+from writer.abstract import register_abstract_template
+from writer.ss_types import AbstractTemplate
+from writer.workflows_blocks.blocks import WorkflowBlock
+
+
+class WriterCompletion(WorkflowBlock):
+
+    @classmethod
+    def register(cls, type: str):
+        super(WriterCompletion, cls).register(type)
+        register_abstract_template("workflows_writercompletion", AbstractTemplate(
+            baseType="workflows_node",
+            writer={
+                "name": "Writer Completion",
+                "description": "Set the value for a state element",
+                "category": "Content",
+                "fields": {
+                    "prompt": {
+                        "name": "Prompt",
+                        "type": "Text",
+                    },
+                    "tools": {
+                        "name": "Tools",
+                        "type": "Object"
+                    }
+                },
+                "outs": {
+                    "$tools": {
+                        "field": "tools"
+                    },
+                    "success": {
+                        "name": "Success",
+                        "description": "If the function doesn't raise an Exception.",
+                        "style": "success",
+                    },
+                    "error": {
+                        "name": "Error",
+                        "description": "If the function raises an Exception.",
+                        "style": "error",
+                    },
+                },
+            }
+        ))
+
+    
\ No newline at end of file