diff --git a/src/ui/src/builder/BuilderApp.vue b/src/ui/src/builder/BuilderApp.vue
index fee3e0d26..eab0913c7 100644
--- a/src/ui/src/builder/BuilderApp.vue
+++ b/src/ui/src/builder/BuilderApp.vue
@@ -319,8 +319,8 @@ onMounted(() => {
 	--builderSubtleHighlightColor: rgba(0, 0, 0, 0.05);
 	--builderSubtleHighlightColorSolid: #f2f2f2;
 	--builderDisabledColor: rgb(180, 180, 180);
-	--builderSidebarWidth: max(265px, 27vh);
-	--builderSettingsWidth: max(265px, 27vh);
+	--builderSidebarWidth: 265px;
+	--builderSettingsWidth: 265px;
 	--builderActionOngoingColor: #333333;
 	--builderTopBarHeight: 48px;
 	--builderWarningTextColor: white;
diff --git a/src/ui/src/builder/BuilderEmbeddedCodeEditor.vue b/src/ui/src/builder/BuilderEmbeddedCodeEditor.vue
new file mode 100644
index 000000000..431dcbc87
--- /dev/null
+++ b/src/ui/src/builder/BuilderEmbeddedCodeEditor.vue
@@ -0,0 +1,83 @@
+<template>
+	<div ref="builderEditor" class="BuilderEmbeddedCodeEditor">
+		<div ref="editorContainer" class="editorContainer"></div>
+	</div>
+</template>
+
+<script setup lang="ts">
+import * as monaco from "monaco-editor";
+import "./builderEditorWorker";
+import { inject, onMounted, onUnmounted, Ref, ref, toRefs, watch } from "vue";
+import injectionKeys from "../injectionKeys";
+
+const wf = inject(injectionKeys.core);
+const wfbm = inject(injectionKeys.builderManager);
+
+const builderEditor: Ref<HTMLElement> = ref(null);
+const editorContainer: Ref<HTMLElement> = ref(null);
+let editor: monaco.editor.IStandaloneCodeEditor = null;
+
+// const editorCode = editor.getValue();
+
+// <input
+//     :value="props.modelValue"
+//     @input="emit('update:modelValue', ($event.target as HTMLInputElement).value)"
+//   />
+
+const props = defineProps<{
+	modelValue: string;
+}>();
+
+const { modelValue } = toRefs(props);
+
+const emit = defineEmits(["update:modelValue"]);
+
+// watch(modelValue, (newCode) => {
+//     const currentCode =
+// 	editor.setValue(newCode);
+// });
+
+onMounted(() => {
+	const targetEl = editorContainer.value;
+	editor = monaco.editor.create(targetEl, {
+		value: modelValue.value,
+		language: "json",
+		minimap: {
+			enabled: false,
+		},
+		lineNumbers: "off",
+		scrollbar: {
+			vertical: "auto",
+			horizontal: "auto",
+		},
+		fontSize: 12,
+		folding: false,
+		// theme: "",
+	});
+	editor.getModel().onDidChangeContent(() => {
+		const newCode = editor.getValue();
+		emit("update:modelValue", newCode);
+	});
+	window.addEventListener("resize", updateDimensions.bind(this));
+});
+
+function updateDimensions() {
+	editor.layout();
+}
+
+onUnmounted(() => {
+	editor.dispose();
+	window.removeEventListener("resize", updateDimensions.bind(this));
+});
+</script>
+
+<style scoped>
+@import "./sharedStyles.css";
+
+.BuilderEditor {
+}
+
+.editorContainer {
+	height: 200px;
+}
+</style>
diff --git a/src/ui/src/builder/BuilderFieldsTools.vue b/src/ui/src/builder/BuilderFieldsTools.vue
new file mode 100644
index 000000000..250d0dedf
--- /dev/null
+++ b/src/ui/src/builder/BuilderFieldsTools.vue
@@ -0,0 +1,287 @@
+<template>
+	<div
+		class="BuilderFieldsTools colorTransformer"
+		:data-automation-key="props.fieldKey"
+	>
+		<div class="tools">
+			<div
+				v-for="(tool, toolName) in tools"
+				:key="toolName"
+				class="tool"
+				@click="editTool(toolName)"
+			>
+				<div class="toolName">{{ toolName }}</div>
+				<button class="delete" @click.stop="deleteTool(toolName)">
+					<i class="material-symbols-outlined">delete</i>
+				</button>
+			</div>
+		</div>
+
+		<WdsButton size="small" @click="resetAndShowToolFormModal">
+			<i class="material-symbols-outlined">add</i>
+			Add tool</WdsButton
+		>
+		<BuilderModal
+			v-if="toolForm.isShown"
+			:close-action="customHandlerModalCloseAction"
+			icon="add"
+			modal-title="Add tool"
+		>
+			<WdsDropdownInput v-model="toolForm.type">
+				<option value="function">Function</option>
+				<option value="graph">Knowledge graph</option>
+			</WdsDropdownInput>
+			<WdsTextInput v-model="toolForm.name"></WdsTextInput>
+			<template v-if="toolForm.type == 'function'">
+				<BuilderEmbeddedCodeEditor
+					v-model="toolForm.code"
+				></BuilderEmbeddedCodeEditor>
+			</template>
+			<template v-if="toolForm.type == 'graph'">
+				<WdsTextInput v-model="toolForm.graphId"></WdsTextInput>
+			</template>
+			<div>
+				<WdsButton @click="saveToolForm">Save</WdsButton>
+			</div>
+		</BuilderModal>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { toRefs, inject, computed, ref } from "vue";
+import { Component, FieldControl } from "@/writerTypes";
+import { useComponentActions } from "./useComponentActions";
+import injectionKeys from "../injectionKeys";
+import WdsButton from "@/wds/WdsButton.vue";
+import BuilderModal, { ModalAction } from "./BuilderModal.vue";
+import WdsTextareaInput from "@/wds/WdsTextareaInput.vue";
+import WdsTextInput from "@/wds/WdsTextInput.vue";
+import WdsDropdownInput from "@/wds/WdsDropdownInput.vue";
+import BuilderEmbeddedCodeEditor from "./BuilderEmbeddedCodeEditor.vue";
+
+type FunctionTool = {
+	type: "function";
+	description: string;
+	parameters: Record<
+		string,
+		{
+			type: string;
+			description: string;
+		}
+	>;
+};
+
+type GraphTool = {
+	type: "graph";
+	graph_ids: string[];
+};
+
+type Tool = FunctionTool | GraphTool;
+
+type ToolForm = {
+	isShown: boolean;
+	type: "function" | "graph";
+	originalName?: string;
+	name: string;
+	code: string;
+	graphId: string;
+};
+
+const wf = inject(injectionKeys.core);
+const ssbm = inject(injectionKeys.builderManager);
+const { setContentValue } = useComponentActions(wf, ssbm);
+
+const initFunctionToolCode = `
+{
+	"description": "Gets info for an employee, given an employee id",
+    "parameters": {
+      "id": {"type": "string", "description": "Id of the employee"}
+    }
+}
+`.trim();
+
+const toolFormInitValue = {
+	isShown: false,
+	type: "function" as "function" | "graph",
+	name: "new_tool",
+	code: initFunctionToolCode,
+	graphId: "999-999",
+};
+
+const toolForm = ref<ToolForm>(toolFormInitValue);
+
+const props = defineProps<{
+	componentId: Component["id"];
+	fieldKey: string;
+}>();
+const { componentId, fieldKey } = toRefs(props);
+const component = computed(() => wf.getComponentById(componentId.value));
+
+const tools = computed<Record<string, Tool>>(() => {
+	let value = {};
+	try {
+		value = JSON.parse(component.value.content[fieldKey.value]);
+	} catch {
+		value = {};
+	}
+	return value;
+});
+
+function resetAndShowToolFormModal() {
+	toolForm.value = {
+		...toolFormInitValue,
+		isShown: true,
+	};
+}
+
+function getToolFromForm(): Tool {
+	const { type, code, graphId } = toolForm.value;
+	if (type == "function") {
+		return {
+			...JSON.parse(code),
+			type,
+		};
+	}
+	if (type == "graph") {
+		return {
+			type,
+			graph_ids: [graphId],
+		};
+	}
+	throw "Unexpected tool type.";
+}
+
+function validateToolForm(form: ToolForm): string[] {
+	let errors = [];
+	const { originalName, name } = form;
+	if (!name) {
+		errors.push("The name cannot be empty.");
+	}
+	if (
+		Object.keys(tools.value).includes(name) &&
+		!(originalName || originalName == name)
+	) {
+		errors.push("An existing tool with the specified name already exists.");
+	}
+	return errors;
+}
+
+function saveToolForm() {
+	const formErrors = validateToolForm(toolForm.value);
+	if (formErrors.length > 0) {
+		formErrors.forEach(alert);
+		return;
+	}
+	let toolFromForm: ReturnType<typeof getToolFromForm>;
+	try {
+		toolFromForm = getToolFromForm();
+	} catch {
+		alert("Incorrect tool definition");
+		return;
+	}
+	const newFieldValue = JSON.stringify({
+		...tools.value,
+		...(toolForm.value.originalName
+			? { [toolForm.value.originalName]: undefined }
+			: {}),
+		[toolForm.value.name]: toolFromForm,
+	});
+	setContentValue(component.value.id, fieldKey.value, newFieldValue);
+	toolForm.value.isShown = false;
+}
+
+function getFormFromToolEntry(toolName: string, tool: Tool): ToolForm {
+	const { type } = tool;
+	if (type == "function") {
+		return {
+			isShown: true,
+			type: "function",
+			originalName: toolName,
+			name: toolName,
+			graphId: "",
+			code: JSON.stringify(tool, undefined, 2),
+		};
+	}
+	if (type == "graph") {
+		return {
+			isShown: true,
+			type: "graph",
+			originalName: toolName,
+			name: toolName,
+			graphId: tool.graph_ids?.[0],
+			code: "",
+		};
+	}
+	throw "Unexpected tool type;";
+}
+
+function editTool(toolName: string) {
+	const tool = tools.value?.[toolName];
+	if (!tool) return;
+	toolForm.value = getFormFromToolEntry(toolName, tool);
+}
+
+function deleteTool(toolName: string) {
+	const newFieldValue = JSON.stringify({
+		...tools.value,
+		[toolName]: undefined,
+	});
+	setContentValue(component.value.id, fieldKey.value, newFieldValue);
+}
+
+const customHandlerModalCloseAction: ModalAction = {
+	desc: "Close",
+	fn: () => {
+		toolForm.value.isShown = false;
+	},
+};
+</script>
+
+<style scoped>
+@import "./sharedStyles.css";
+
+.BuilderFieldsTools {
+	--separatorColor: var(--builderSeparatorColor);
+	--intensifiedButtonColor: red;
+}
+
+.tools {
+	margin-bottom: 8px;
+}
+
+.tool {
+	display: flex;
+	align-items: center;
+	min-height: 38px;
+	padding-top: 4px;
+	margin-top: 4px;
+	cursor: pointer;
+}
+
+.tool:not(:first-of-type) {
+	border-top: 1px solid var(--builderSeparatorColor);
+}
+
+.tool .toolName {
+	flex: 1 0 auto;
+}
+
+.tool .delete {
+	display: none;
+	background: var(--builderBackgroundColor);
+	padding: 2px 4px 2px 4px;
+	font-size: 1.1rem;
+}
+
+.tool:hover .delete {
+	display: block;
+}
+
+.addToolTextarea {
+	font-family: monospace;
+}
+</style>
+
+<style scoped>
+@import "./sharedStyles.css";
+</style>
diff --git a/src/ui/src/builder/BuilderLogWorkflowExecution.vue b/src/ui/src/builder/BuilderLogWorkflowExecution.vue
index 43e0c4f23..048db2f06 100644
--- a/src/ui/src/builder/BuilderLogWorkflowExecution.vue
+++ b/src/ui/src/builder/BuilderLogWorkflowExecution.vue
@@ -16,7 +16,7 @@
 						entry.outcome
 					}}
 				</td>
-				<td>1s</td>
+				<td>{{ formatExecutionTime(entry.executionTimeInSeconds) }}</td>
 			</tr>
 		</table>
 	</div>
@@ -55,6 +55,16 @@ async function selectBlock(componentId: Component["id"]) {
 	await nextTick();
 	wfbm.setSelection(componentId, undefined, "log");
 }
+
+function formatExecutionTime(timeInSeconds: number): string {
+	if (timeInSeconds < 0) {
+		return "N/A";
+	}
+	if (timeInSeconds < 0.1) {
+		return "< 0.1s";
+	}
+	return `${timeInSeconds.toFixed(2)}s`;
+}
 </script>
 
 <style scoped>
diff --git a/src/ui/src/builder/BuilderSettingsProperties.vue b/src/ui/src/builder/BuilderSettingsProperties.vue
index 3564afb22..3739ef62e 100644
--- a/src/ui/src/builder/BuilderSettingsProperties.vue
+++ b/src/ui/src/builder/BuilderSettingsProperties.vue
@@ -26,10 +26,11 @@
 					:key="fieldKey"
 				>
 					<div class="fieldWrapper">
-						<div class="name">
+						<div v-if="propertyCategory != 'Tools'" class="name">
 							{{ fieldValue.name ?? fieldKey
 							}}<span class="type"> : {{ fieldValue.type }}</span>
 						</div>
+
 						<BuilderFieldsColor
 							v-if="fieldValue.type == FieldType.Color"
 							class="content"
@@ -107,6 +108,13 @@
 							:component-id="selectedComponent.id"
 						></BuilderFieldsPadding>
 
+						<BuilderFieldsTools
+							v-if="fieldValue.type == FieldType.Tools"
+							:field-key="fieldKey"
+							:component-id="selectedComponent.id"
+						>
+						</BuilderFieldsTools>
+
 						<div v-if="fieldValue.desc" class="desc">
 							{{ fieldValue.desc }}
 						</div>
@@ -130,6 +138,7 @@ import BuilderFieldsPadding from "./BuilderFieldsPadding.vue";
 import BuilderFieldsShadow from "./BuilderFieldsShadow.vue";
 import BuilderFieldsText from "./BuilderFieldsText.vue";
 import BuilderFieldsWidth from "./BuilderFieldsWidth.vue";
+import BuilderFieldsTools from "./BuilderFieldsTools.vue";
 
 const wf = inject(injectionKeys.core);
 const ssbm = inject(injectionKeys.builderManager);
@@ -148,7 +157,11 @@ const fields = computed(() => {
 	return definition.fields;
 });
 
-const fieldCategories = [FieldCategory.General, FieldCategory.Style];
+const fieldCategories = [
+	FieldCategory.General,
+	FieldCategory.Style,
+	FieldCategory.Tools,
+];
 
 const fieldsByCategory = computed(() => {
 	const entries = Object.entries(fields.value);
@@ -161,6 +174,9 @@ const fieldsByCategory = computed(() => {
 		[FieldCategory.Style]: entries.filter(
 			([_, fieldValue]) => fieldValue.category == FieldCategory.Style,
 		),
+		[FieldCategory.Tools]: entries.filter(
+			([_, fieldValue]) => fieldValue.category == FieldCategory.Tools,
+		),
 	};
 	return result;
 });
diff --git a/src/ui/src/builder/builderManager.ts b/src/ui/src/builder/builderManager.ts
index 6be0ac368..6113b9b30 100644
--- a/src/ui/src/builder/builderManager.ts
+++ b/src/ui/src/builder/builderManager.ts
@@ -21,6 +21,7 @@ const MAX_LOG_ENTRIES = 100;
 export type WorkflowExecutionLog = {
 	componentId: Component["id"];
 	outcome: string;
+	executionTimeInSeconds: number;
 	component?: Component;
 	componentDef?: WriterComponentDefinition;
 }[];
diff --git a/src/ui/src/builder/useComponentActions.ts b/src/ui/src/builder/useComponentActions.ts
index 3c3294f37..a7382bbde 100644
--- a/src/ui/src/builder/useComponentActions.ts
+++ b/src/ui/src/builder/useComponentActions.ts
@@ -489,6 +489,11 @@ export function useComponentActions(wf: Core, ssbm: BuilderManager) {
 					if (nc.parentId == c.id) {
 						nc.parentId = newId;
 					}
+					nc.outs?.forEach((out) => {
+						if (out.toNodeId == c.id) {
+							out.toNodeId = newId;
+						}
+					});
 				});
 			c.id = newId;
 		});
@@ -524,6 +529,15 @@ export function useComponentActions(wf: Core, ssbm: BuilderManager) {
 		if (clipboard === null) return;
 		const { operation, jsonSubtree } = clipboard;
 		const subtree = JSON.parse(jsonSubtree);
+
+		const rootComponent = subtree[0];
+		if (
+			typeof rootComponent.outs !== "undefined" &&
+			rootComponent.parentId !== targetParentId
+		) {
+			rootComponent.outs = [];
+		}
+
 		if (operation == ClipboardOperation.Cut)
 			return pasteCutComponent(targetParentId, subtree);
 		if (operation == ClipboardOperation.Copy)
@@ -541,6 +555,7 @@ export function useComponentActions(wf: Core, ssbm: BuilderManager) {
 
 		ssbm.setClipboard(null);
 		const rootComponent = subtree[0];
+
 		rootComponent.parentId = targetParentId;
 		rootComponent.position = getNextInsertionPosition(
 			targetParentId,
diff --git a/src/ui/src/components/core/other/CoreReuse.vue b/src/ui/src/components/core/other/CoreReuse.vue
index 80a84dd74..af43e616d 100644
--- a/src/ui/src/components/core/other/CoreReuse.vue
+++ b/src/ui/src/components/core/other/CoreReuse.vue
@@ -42,12 +42,10 @@ const shouldRender = ref(true);
 const proxyType = computed(
 	() => wf.getComponentById(fields.proxyId.value)?.type,
 );
-const parentType = computed(() => wf.getComponentById(parentId)?.type);
 
 const proxyDefinition = computed(() =>
 	proxyType.value ? wf.getComponentDefinition(proxyType.value) : null,
 );
-const parentDef = computed(() => wf.getComponentDefinition(parentType.value));
 
 function renderError(message: string, cls: string) {
 	shouldRender.value = props.contextSlot === "default";
@@ -58,20 +56,6 @@ function renderError(message: string, cls: string) {
 	);
 }
 
-function isAllowedChildType(type) {
-	return (
-		parentDef.value.allowedChildrenTypes?.includes(type) ||
-		parentDef.value.allowedChildrenTypes?.includes("*")
-	);
-}
-
-function isAllowedParentType(type) {
-	return (
-		!proxyDefinition.value.allowedParentTypes ||
-		proxyDefinition.value.allowedParentTypes?.includes(type)
-	);
-}
-
 function render() {
 	if (!fields.proxyId.value) {
 		return renderError("No component selected to reuse", "empty");
@@ -83,10 +67,7 @@ function render() {
 		);
 	}
 
-	if (
-		!isAllowedChildType(proxyType.value) ||
-		!isAllowedParentType(parentType.value)
-	) {
+	if (!wf.getContainableTypes(parentId).includes(proxyType.value)) {
 		return renderError(
 			`The component cannot be reused here.`,
 			"invalid-context",
diff --git a/src/ui/src/components/workflows/WorkflowsWorkflow.vue b/src/ui/src/components/workflows/WorkflowsWorkflow.vue
index d6f70444c..edcf51884 100644
--- a/src/ui/src/components/workflows/WorkflowsWorkflow.vue
+++ b/src/ui/src/components/workflows/WorkflowsWorkflow.vue
@@ -2,11 +2,13 @@
 	<div
 		ref="rootEl"
 		class="WorkflowsWorkflow"
+		:data-writer-unselectable="isUnselectable"
 		@click="handleClick"
 		@dragover="handleDragover"
 		@drop="handleDrop"
-		@drag="handleDrag"
-		@dragstart="handleDragstart"
+		@mousemove="handleMousemove"
+		@mousedown="handleMousedown"
+		@mouseup="handleMouseup"
 	>
 		<div ref="nodeContainerEl" class="nodeContainer">
 			<svg>
@@ -18,26 +20,36 @@
 					:is-engaged="
 						selectedArrow == arrowId ||
 						wfbm.getSelectedId() == arrow.fromNodeId ||
-						wfbm.getSelectedId() == arrow.out.toNodeId
+						wfbm.getSelectedId() == arrow.toNodeId
 					"
 					@click="handleArrowClick($event, arrowId)"
 					@delete="handleDeleteClick($event, arrow)"
 				></WorkflowArrow>
+				<WorkflowArrow
+					v-if="activeConnection?.liveArrow"
+					key="liveArrow"
+					:arrow="activeConnection.liveArrow"
+					:is-selected="false"
+					:is-engaged="true"
+				></WorkflowArrow>
 			</svg>
 			<template v-for="node in nodes" :key="node.id">
 				<component
-					:is="renderProxiedComponent(node.id)"
-					:data-writer-unselectable="isUnselectable"
+					:is="renderProxiedComponent(node.id, 0)"
 					:style="{
 						top: `${node.y - renderOffset.y}px`,
 						left: `${node.x - renderOffset.x}px`,
+						'border-color':
+							activeConnection?.liveArrow?.toNodeId == node.id
+								? activeConnection?.liveArrow?.color
+								: undefined,
 					}"
-					@drag="(ev: DragEvent) => handleNodeDrag(ev, node.id)"
-					@dragstart="(ev: DragEvent) => handleNodeDragStart(ev)"
-					@dragend="handleNodeDragend"
-					@click="(ev: MouseEvent) => handleNodeClick(ev, node.id)"
-					@out-select="
-						(outId: string) => handleNodeOutSelect(node.id, outId)
+					@mousedown.stop="
+						(ev: MouseEvent) => handleNodeMousedown(ev, node.id)
+					"
+					@out-mousedown="
+						(outId: string) =>
+							handleNodeOutMousedown(node.id, outId)
 					"
 				></component>
 			</template>
@@ -92,8 +104,9 @@ export type WorkflowArrowData = {
 	y2: number;
 	color: string;
 	fromNodeId: Component["id"];
-	out: Component["outs"][number];
-	isEngaged: boolean;
+	fromOutId: Component["outs"][number]["outId"];
+	toNodeId?: Component["id"];
+	isEngaged?: boolean;
 };
 </script>
 <script setup lang="ts">
@@ -123,49 +136,50 @@ const { createAndInsertComponent, addOut, removeOut, changeCoordinates } =
 	useComponentActions(wf, wfbm);
 const { getComponentInfoFromDrag } = useDragDropComponent(wf);
 
-const activeNodeOut: Ref<{
-	fromComponentId: string;
-	outId: string;
+const activeConnection: Ref<{
+	fromNodeId: Component["id"];
+	fromOutId: Component["outs"][number]["outId"];
+	liveArrow?: WorkflowArrowData;
 } | null> = ref(null);
 
-function refreshArrows() {
-	const a = [];
-	const canvasCBR = rootEl.value?.getBoundingClientRect();
-	if (!canvasCBR) {
-		return;
-	}
+const activeNodeMove: Ref<{
+	nodeId: Component["id"];
+	offset: { x: number; y: number };
+	isPerfected: boolean;
+} | null> = ref(null);
 
+const activeCanvasMove: Ref<{
+	offset: { x: number; y: number };
+	isPerfected: boolean;
+} | null> = ref(null);
+
+function refreshArrows() {
+	const newArrows = [];
 	nodes.value
 		.filter((node) => node.outs?.length > 0)
 		.forEach((node) => {
 			const fromNodeId = node.id;
 			node.outs.forEach((out) => {
-				const fromEl = document.querySelector(
-					`[data-writer-id="${fromNodeId}"] [data-writer-socket-id="${out.outId}"]`,
-				);
-				const toEl = document.querySelector(
-					`[data-writer-id="${out.toNodeId}"]`,
-				);
-				if (!fromEl || !toEl) return;
-				const fromCBR = fromEl.getBoundingClientRect();
-				const toCBR = toEl.getBoundingClientRect();
-
-				a.push({
-					x1: fromCBR.x - canvasCBR.x + fromCBR.width / 2,
-					y1: fromCBR.y - canvasCBR.y + fromCBR.height / 2,
-					x2: toCBR.x - canvasCBR.x,
-					y2: toCBR.y - canvasCBR.y + toCBR.height / 2,
-					color: getComputedStyle(fromEl).backgroundColor,
+				const arrow = calculateArrow(
 					fromNodeId,
-					out,
-				});
+					out.outId,
+					undefined,
+					out.toNodeId,
+				);
+				if (!arrow) return;
+				newArrows.push(arrow);
 			});
 		});
-	arrows.value = a;
+	arrows.value = newArrows;
 }
 
 const isUnselectable = computed(() => {
-	if (activeNodeOut.value === null) return null;
+	if (
+		activeConnection.value === null &&
+		!activeNodeMove.value?.isPerfected &&
+		!activeCanvasMove.value?.isPerfected
+	)
+		return null;
 	return true;
 });
 
@@ -189,10 +203,28 @@ async function handleRun() {
 	);
 }
 
-function handleNodeOutSelect(componentId: Component["id"], outId: string) {
-	activeNodeOut.value = {
-		fromComponentId: componentId,
-		outId,
+function handleNodeMousedown(ev: MouseEvent, nodeId: Component["id"]) {
+	clearActiveOperations();
+	const nodeEl = document.querySelector(`[data-writer-id="${nodeId}"]`);
+	const nodeCBR = nodeEl.getBoundingClientRect();
+
+	activeNodeMove.value = {
+		nodeId,
+		offset: {
+			x: ev.pageX - nodeCBR.x,
+			y: ev.pageY - nodeCBR.y,
+		},
+		isPerfected: false,
+	};
+}
+
+function handleNodeOutMousedown(
+	fromNodeId: Component["id"],
+	fromOutId: string,
+) {
+	activeConnection.value = {
+		fromNodeId,
+		fromOutId,
 	};
 }
 
@@ -228,7 +260,7 @@ function handleDragover(ev: DragEvent) {
 	ev.stopPropagation();
 }
 
-function getAdjustedCoordinates(ev: DragEvent) {
+function getAdjustedCoordinates(ev: MouseEvent) {
 	const canvasCBR = rootEl.value.getBoundingClientRect();
 	const x = ev.pageX - canvasCBR.x + renderOffset.value.x;
 	const y = ev.pageY - canvasCBR.y + renderOffset.value.y;
@@ -261,7 +293,12 @@ function handleArrowClick(ev: MouseEvent, arrowId: number) {
 }
 
 async function handleDeleteClick(ev: MouseEvent, arrow: WorkflowArrowData) {
-	removeOut(arrow.fromNodeId, arrow.out);
+	if (!arrow.toNodeId) return;
+	const out = {
+		outId: arrow.fromOutId,
+		toNodeId: arrow.toNodeId,
+	};
+	removeOut(arrow.fromNodeId, out);
 }
 
 function handleNodeDragStart(ev: DragEvent) {
@@ -297,20 +334,159 @@ function handleNodeDrag(ev: DragEvent, componentId: Component["id"]) {
 	}, 200);
 }
 
-function handleNodeDragend(ev: DragEvent) {
-	ev.preventDefault();
+function calculateArrow(
+	fromNodeId: Component["id"],
+	fromOutId: string,
+	toCoordinates?: { x: number; y: number },
+	toNodeId?: Component["id"],
+): WorkflowArrowData {
+	let x1: number, y1: number, x2: number, y2: number;
+	const canvasCBR = rootEl.value?.getBoundingClientRect();
+	if (!canvasCBR) {
+		return;
+	}
+	x2 = toCoordinates?.x - canvasCBR.x;
+	y2 = toCoordinates?.y - canvasCBR.y;
+	const fromEl = document.querySelector(
+		`[data-writer-id="${fromNodeId}"] [data-writer-socket-id="${fromOutId}"]`,
+	);
+	if (!fromEl) return;
+	const fromCBR = fromEl.getBoundingClientRect();
+	x1 = fromCBR.x - canvasCBR.x + fromCBR.width / 2;
+	y1 = fromCBR.y - canvasCBR.y + fromCBR.height / 2;
+	if (!fromEl) return;
+	if (typeof toNodeId !== "undefined") {
+		const toEl = document.querySelector(`[data-writer-id="${toNodeId}"]`);
+		const toCBR = toEl.getBoundingClientRect();
+		x2 = toCBR.x - canvasCBR.x;
+		y2 = toCBR.y - canvasCBR.y + toCBR.height / 2;
+	}
+
+	return {
+		x1,
+		y1,
+		x2,
+		y2,
+		color: getComputedStyle(fromEl).backgroundColor,
+		fromNodeId,
+		fromOutId,
+		toNodeId,
+	};
 }
 
-async function handleNodeClick(ev: MouseEvent, componentId: Component["id"]) {
-	if (!activeNodeOut.value) return;
-	if (activeNodeOut.value.fromComponentId == componentId) return;
+function getHoveredNodeId(ev: MouseEvent) {
+	const targetEl = ev.target as HTMLElement;
+	const toNodeEl = targetEl.closest(
+		".WorkflowsWorkflow [data-writer-id]",
+	) as HTMLElement;
+	return toNodeEl?.dataset.writerId;
+}
 
-	addOut(activeNodeOut.value.fromComponentId, {
-		toNodeId: componentId,
-		outId: activeNodeOut.value.outId,
-	});
+function refreshLiveArrow(ev: MouseEvent) {
+	let toCoordinates: { x: number; y: number }, toNodeId: Component["id"];
+
+	toNodeId = getHoveredNodeId(ev);
+	if (typeof toNodeId == "undefined") {
+		toCoordinates = { x: ev.pageX, y: ev.pageY };
+	}
+	const { fromNodeId, fromOutId } = activeConnection.value;
+	if (toNodeId == fromNodeId) return;
+
+	activeConnection.value.liveArrow = calculateArrow(
+		fromNodeId,
+		fromOutId,
+		toCoordinates,
+		toNodeId,
+	);
+}
 
-	activeNodeOut.value = null;
+function clearActiveOperations() {
+	activeCanvasMove.value = null;
+	activeConnection.value = null;
+	activeNodeMove.value = null;
+}
+
+function moveNode(ev: MouseEvent) {
+	const { nodeId, offset } = activeNodeMove.value;
+	activeNodeMove.value.isPerfected = true;
+	const component = wf.getComponentById(nodeId);
+	const { x, y } = getAdjustedCoordinates(ev);
+
+	const newX = x - offset.x;
+	const newY = y - offset.y;
+
+	if (component.x == newX && component.y == newY) return;
+
+	component.x = newX;
+	component.y = newY;
+}
+
+async function moveCanvas(ev: MouseEvent) {
+	const canvasCBR = rootEl.value.getBoundingClientRect();
+	const x = ev.pageX - canvasCBR.x;
+	const y = ev.pageY - canvasCBR.y;
+	const { x: prevX, y: prevY } = activeCanvasMove.value.offset;
+	activeCanvasMove.value.isPerfected = true;
+
+	renderOffset.value = {
+		x: Math.max(0, renderOffset.value.x + (prevX - x) * 1),
+		y: Math.max(0, renderOffset.value.y + (prevY - y) * 1),
+	};
+	activeCanvasMove.value.offset = { x, y };
+	await nextTick();
+	refreshArrows();
+}
+
+function handleMousemove(ev: MouseEvent) {
+	if (ev.buttons != 1) return;
+
+	if (activeConnection.value) {
+		refreshLiveArrow(ev);
+		return;
+	}
+	if (activeNodeMove.value) {
+		moveNode(ev);
+		return;
+	}
+	if (activeCanvasMove.value) {
+		moveCanvas(ev);
+		return;
+	}
+}
+
+function handleMousedown(ev: MouseEvent) {
+	clearActiveOperations();
+	if (ev.buttons != 1) return;
+
+	const canvasCBR = rootEl.value.getBoundingClientRect();
+	const x = ev.pageX - canvasCBR.x;
+	const y = ev.pageY - canvasCBR.y;
+
+	activeCanvasMove.value = {
+		offset: { x, y },
+		isPerfected: false,
+	};
+}
+
+async function handleMouseup(ev: MouseEvent) {
+	if (activeConnection.value === null) {
+		return;
+	}
+	const hoveredId = getHoveredNodeId(ev);
+	if (!hoveredId) {
+		activeConnection.value = null;
+		return;
+	}
+	const { fromNodeId, fromOutId } = activeConnection.value;
+	if (fromNodeId == hoveredId) {
+		activeConnection.value = null;
+		return;
+	}
+
+	addOut(activeConnection.value.fromNodeId, {
+		toNodeId: hoveredId,
+		outId: fromOutId,
+	});
 }
 
 async function createNode(type: string, x: number, y: number) {
diff --git a/src/ui/src/components/workflows/abstract/WorkflowsNode.vue b/src/ui/src/components/workflows/abstract/WorkflowsNode.vue
index 7142b638c..d7246e8b4 100644
--- a/src/ui/src/components/workflows/abstract/WorkflowsNode.vue
+++ b/src/ui/src/components/workflows/abstract/WorkflowsNode.vue
@@ -21,8 +21,9 @@
 					:class="out.style"
 					:data-writer-socket-id="outId"
 					:data-writer-unselectable="true"
-					@click.capture="
-						(ev: DragEvent) => handleOutClick(ev, outId)
+					@click.capture.stop
+					@mousedown.capture="
+						(ev: DragEvent) => handleOutMousedown(ev, outId)
 					"
 				></div>
 			</div>
@@ -47,7 +48,7 @@ export default {
 import { computed, inject, watch } from "vue";
 import injectionKeys from "@/injectionKeys";
 
-const emit = defineEmits(["outSelect", "engaged"]);
+const emit = defineEmits(["outMousedown", "engaged"]);
 const wf = inject(injectionKeys.core);
 const wfbm = inject(injectionKeys.builderManager);
 const componentId = inject(injectionKeys.componentId);
@@ -89,9 +90,14 @@ const dynamicOuts = computed(() => {
 	return processedOuts;
 });
 
-function handleOutClick(ev: DragEvent, outId: string) {
+function handleOutMousedown(ev: DragEvent, outId: string) {
 	ev.stopPropagation();
-	emit("outSelect", outId);
+	emit("outMousedown", outId);
+}
+
+function handleOutMouseup(ev: DragEvent, outId: string) {
+	ev.stopPropagation();
+	emit("outMouseup", outId);
 }
 
 watch(isEngaged, () => {
@@ -107,6 +113,11 @@ watch(isEngaged, () => {
 	width: 240px;
 	position: absolute;
 	box-shadow: 0px 2px 0px 0px #f3f3f3;
+	user-select: none;
+}
+
+.WorkflowsNode:not(.selected) {
+	transition: border-color 0.2s ease-in-out;
 }
 
 .WorkflowsNode:hover {
diff --git a/src/ui/src/components/workflows/base/WorkflowArrow.vue b/src/ui/src/components/workflows/base/WorkflowArrow.vue
index 63a65e2aa..eaa5f0333 100644
--- a/src/ui/src/components/workflows/base/WorkflowArrow.vue
+++ b/src/ui/src/components/workflows/base/WorkflowArrow.vue
@@ -105,8 +105,13 @@ function handleDeleteClick() {
 <style scoped>
 @import "@/renderer/sharedStyles.css";
 
+.WorkflowArrow {
+	filter: saturate(100%);
+	transition: 0.2s filter ease-in-out;
+}
+
 .WorkflowArrow:not(.engaged):not(:hover) {
-	filter: grayscale();
+	filter: saturate(0%);
 }
 
 g {
diff --git a/src/ui/src/injectionKeys.ts b/src/ui/src/injectionKeys.ts
index 2c3bb2437..532ff960f 100644
--- a/src/ui/src/injectionKeys.ts
+++ b/src/ui/src/injectionKeys.ts
@@ -20,7 +20,8 @@ export default {
 	renderProxiedComponent: Symbol() as InjectionKey<
 		(
 			componentId: Component["id"],
-			instanceNumber?: InstancePathItem["instanceNumber"],
+			instanceNumber: InstancePathItem["instanceNumber"],
+			ext?: { class?: string[]; contextSlot?: string },
 		) => VNode
 	>,
 	instancePath: Symbol() as InjectionKey<InstancePath>,
diff --git a/src/ui/src/renderer/ComponentProxy.vue b/src/ui/src/renderer/ComponentProxy.vue
index 5c56bd83f..f2bd4fdb4 100644
--- a/src/ui/src/renderer/ComponentProxy.vue
+++ b/src/ui/src/renderer/ComponentProxy.vue
@@ -37,7 +37,9 @@ export default {
 				isBeingEdited.value &&
 				!component.value.isCodeManaged &&
 				component.value.type !== "root" &&
-				component.value.type !== "workflows_root",
+				component.value.type !== "workflows_root" &&
+				wf.getComponentDefinition(component.value.type)?.toolkit !==
+					"workflows",
 		);
 
 		const isParentSuitable = (parentId, childType) => {
@@ -59,7 +61,7 @@ export default {
 		const renderProxiedComponent = (
 			componentId: Component["id"],
 			instanceNumber: InstancePathItem["instanceNumber"] = 0,
-			ext: { class?: string; contextSlot?: string } = {},
+			ext?: { class?: string[]; contextSlot?: string },
 		): VNode => {
 			const vnode = h(ComponentProxy, {
 				componentId,
@@ -72,7 +74,7 @@ export default {
 					},
 				],
 				instanceData: [...instanceData, ref(null)],
-				...ext,
+				...(ext ?? {}),
 			});
 			return vnode;
 		};
diff --git a/src/ui/src/renderer/useEvaluator.ts b/src/ui/src/renderer/useEvaluator.ts
index 21d9932bf..ec82916e3 100644
--- a/src/ui/src/renderer/useEvaluator.ts
+++ b/src/ui/src/renderer/useEvaluator.ts
@@ -173,7 +173,7 @@ export function useEvaluator(wf: Core) {
 			typeof evaluated == "undefined" ||
 			evaluated === null ||
 			evaluated === "";
-		if (fieldType == FieldType.Object || fieldType == FieldType.KeyValue) {
+		if (fieldType == FieldType.Object || fieldType == FieldType.KeyValue || fieldType == FieldType.Tools) {
 			if (!evaluated) {
 				return JSON.parse(defaultValue ?? null);
 			}
diff --git a/src/ui/src/writerTypes.ts b/src/ui/src/writerTypes.ts
index 242b5e739..8704f659d 100644
--- a/src/ui/src/writerTypes.ts
+++ b/src/ui/src/writerTypes.ts
@@ -125,11 +125,13 @@ export const enum FieldType {
 	HAlign = "Align (H)",
 	VAlign = "Align (V)",
 	Padding = "Padding",
+	Tools = "Tools",
 }
 
 export const enum FieldCategory {
 	General = "General",
 	Style = "Style",
+	Tools = "Tools",
 }
 
 /**
diff --git a/src/writer/workflows.py b/src/writer/workflows.py
index 510752673..5fdf5c548 100644
--- a/src/writer/workflows.py
+++ b/src/writer/workflows.py
@@ -1,5 +1,5 @@
-import logging
-from typing import Dict, List, Literal, Tuple
+import time
+from typing import Any, Dict, List, Literal, Optional, Tuple
 
 import writer.core
 import writer.workflows_blocks
@@ -22,37 +22,42 @@ def run_workflow_by_key(session, workflow_key: str, execution_env: Dict):
 
 def run_workflow(session, component_id: str, execution_env: Dict):
     execution: Dict[str, WorkflowBlock] = {}
+    nodes = _get_workflow_nodes(component_id)
+    return_value = None
     try:
-        for node in _get_terminal_nodes(component_id):
-            _run_node(node, execution, session, execution_env)
+        for node in get_terminal_nodes(nodes):
+            tool = run_node(node, nodes, execution, session, execution_env)
+        for component_id, tool in execution.items():
+            if tool and tool.return_value:
+                return_value = tool.return_value
     except BaseException as e:
         _generate_run_log(session, execution, "error")
         raise e
     else:
-        _generate_run_log(session, execution, "info")
+        _generate_run_log(session, execution, "info", return_value)
 
-def _generate_run_log(session: "writer.core.WriterSession", execution: Dict[str, WorkflowBlock], entry_type: Literal["info", "error"]):
-    msg = ""
+def _generate_run_log(session: "writer.core.WriterSession", execution: Dict[str, WorkflowBlock], entry_type: Literal["info", "error"], return_value: Optional[Any] = None):
     exec_log = []
     for component_id, tool in execution.items():
         exec_log.append({
             "componentId": component_id,
-            "outcome": tool.outcome
+            "outcome": tool.outcome,
+            # "outcome": tool.outcome + repr(tool.return_value) + repr(tool.result),
+            "executionTimeInSeconds": tool.execution_time_in_seconds 
         })
+    msg = f"Execution finished with value {repr(return_value)}"
     state = session.session_state
     state.add_log_entry(entry_type, "Workflow execution", msg, workflow_execution=exec_log)
 
 
-def _get_terminal_nodes(component_id):
-    nodes = _get_workflow_nodes(component_id)
+def get_terminal_nodes(nodes):
     return [node for node in nodes if not node.outs]
 
-def _get_node_dependencies(target_node: "Component"):
+def _get_node_dependencies(target_node: "Component", nodes: List["Component"]):
     dependencies:List[Tuple] = []
     parent_id = target_node.parentId
     if not parent_id:
-        return dependencies
-    nodes = _get_workflow_nodes(parent_id)
+        return []
     for node in nodes:
         if not node.outs:
             continue
@@ -64,6 +69,18 @@ def _get_node_dependencies(target_node: "Component"):
     return dependencies
     
 
+def get_branch_nodes(root_node_id: str):
+    root_node = writer.core.base_component_tree.get_component(root_node_id)
+    if not root_node:
+        return []
+    branch_nodes = [root_node]
+    if not root_node.outs:
+        return branch_nodes
+    for out in root_node.outs:
+        branch_nodes += get_branch_nodes(out.get("toNodeId"))
+    return branch_nodes
+
+
 def _is_outcome_managed(target_node: "Component", target_out_id: str):
     if not target_node.outs:
         return False
@@ -72,11 +89,12 @@ def _is_outcome_managed(target_node: "Component", target_out_id: str):
             return True
     return False
 
-def _run_node(target_node: "Component", execution: Dict, session: "writer.core.WriterSession", execution_env: Dict):
+
+def run_node(target_node: "Component", nodes: List["Component"], execution: Dict, session: "writer.core.WriterSession", 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}.")
-    dependencies = _get_node_dependencies(target_node)
+    dependencies = _get_node_dependencies(target_node, nodes)
 
     tool = execution.get(target_node.id)
     if tool:
@@ -85,7 +103,7 @@ def _run_node(target_node: "Component", execution: Dict, session: "writer.core.W
     result = None
     matched_dependencies = 0
     for node, out_id in dependencies:
-        tool = _run_node(node, execution, session, execution_env)
+        tool = run_node(node, nodes, execution, session, execution_env)
         if not tool:
             continue
         if tool.outcome == out_id:
@@ -98,7 +116,9 @@ def _run_node(target_node: "Component", execution: Dict, session: "writer.core.W
     tool = tool_class(target_node, execution, session, execution_env | {"result": result})
     
     try:
+        start_time = time.time()
         tool.run()
+        tool.execution_time_in_seconds = time.time() - start_time
     except BaseException as e:
         if tool and not tool.result:
             tool.result = repr(e)
diff --git a/src/writer/workflows_blocks/__init__.py b/src/writer/workflows_blocks/__init__.py
index 4a933d4bd..4d7a693a3 100644
--- a/src/writer/workflows_blocks/__init__.py
+++ b/src/writer/workflows_blocks/__init__.py
@@ -4,6 +4,7 @@
 from writer.workflows_blocks.httprequest import HTTPRequest
 from writer.workflows_blocks.logmessage import LogMessage
 from writer.workflows_blocks.parsejson import ParseJSON
+from writer.workflows_blocks.returnvalue import ReturnValue
 from writer.workflows_blocks.runworkflow import RunWorkflow
 from writer.workflows_blocks.setstate import SetState
 from writer.workflows_blocks.writeraddchatmessage import WriterAddChatMessage
@@ -24,4 +25,5 @@
 WriterAddChatMessage.register("workflows_writeraddchatmessage")
 ParseJSON.register("workflows_parsejson")
 CallEventHandler.register("workflows_calleventhandler")
-AddToStateList.register("workflows_addtostatelist")
\ No newline at end of file
+AddToStateList.register("workflows_addtostatelist")
+ReturnValue.register("workflows_returnvalue")
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/blocks.py b/src/writer/workflows_blocks/blocks.py
index b844532c8..3f7023d04 100644
--- a/src/writer/workflows_blocks/blocks.py
+++ b/src/writer/workflows_blocks/blocks.py
@@ -1,4 +1,4 @@
-from typing import Dict
+from typing import Dict, List
 
 import writer.core
 import writer.core_ui
@@ -17,12 +17,28 @@ def __init__(self, component: "writer.core_ui.Component", execution: Dict, sessi
         self.outcome = None
         self.component = component
         self.execution = execution
+        self.execution_time_in_seconds = -1.0
         self.session = session
         self.execution_env = execution_env
         self.result = None
+        self.return_value = 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_nodes_at_outcome(self, target_outcome: str):
+        outs = self.component.outs
+        nodes:List["writer.core_ui.Component"] = []
+        if not outs:
+            return nodes
+        for out in outs:
+            if out.get("outId") == target_outcome:
+                component_id = out.get("toNodeId")
+                component = writer.core.base_component_tree.get_component(component_id)
+                if not component:
+                    continue
+                nodes.append(component)
+        return nodes
+
     def _get_field(self, field_key: str, as_json=False, default_field_value=None):
         if default_field_value is None:
             if as_json:
diff --git a/src/writer/workflows_blocks/returnvalue.py b/src/writer/workflows_blocks/returnvalue.py
new file mode 100644
index 000000000..89a048cc8
--- /dev/null
+++ b/src/writer/workflows_blocks/returnvalue.py
@@ -0,0 +1,48 @@
+import writer.workflows
+from writer.abstract import register_abstract_template
+from writer.ss_types import AbstractTemplate
+from writer.workflows_blocks.blocks import WorkflowBlock
+
+
+class ReturnValue(WorkflowBlock):
+
+    @classmethod
+    def register(cls, type: str):
+        super(ReturnValue, cls).register(type)
+        register_abstract_template(type, AbstractTemplate(
+            baseType="workflows_node",
+            writer={
+                "name": "Return value",
+                "description": "Returns a value from a workflow or sub-workflow.",
+                "category": "Writer",
+                "fields": {
+                    "value": {
+                        "name": "Value",
+                        "type": "Text",
+                        "control": "Textarea"
+                    },
+                },
+                "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):
+        try:
+            value = self._get_field("value")
+            self.result = value
+            self.return_value = value
+            self.outcome = "success"
+        except BaseException as e:
+            self.outcome = "error"
+            raise e
\ No newline at end of file
diff --git a/src/writer/workflows_blocks/setstate.py b/src/writer/workflows_blocks/setstate.py
index f354ee4b8..389c8a224 100644
--- a/src/writer/workflows_blocks/setstate.py
+++ b/src/writer/workflows_blocks/setstate.py
@@ -45,6 +45,7 @@ def run(self):
             element = self._get_field("element")
             value = self._get_field("value")
             self.evaluator.set_state(element, self.instance_path, value, base_context=self.execution_env)
+            self.result = value
             self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
diff --git a/src/writer/workflows_blocks/writerchat.py b/src/writer/workflows_blocks/writerchat.py
index 7e8c8ff90..ac30703d7 100644
--- a/src/writer/workflows_blocks/writerchat.py
+++ b/src/writer/workflows_blocks/writerchat.py
@@ -1,3 +1,4 @@
+import writer.workflows
 from writer.abstract import register_abstract_template
 from writer.ss_types import AbstractTemplate
 from writer.workflows_blocks.blocks import WorkflowBlock
@@ -30,9 +31,18 @@ def register(cls, type: str):
                         "name": "Temperature",
                         "type": "Number",
                         "default": "0.7"
+                    },
+                    "tools": {
+                        "name": "Tools",
+                        "type": "Tools",
+                        "default": "{}",
+                        "category": "Tools"
                     }
                 },
                 "outs": {
+                    "$dynamic": {
+                        "field": "tools"
+                    },
                     "success": {
                         "name": "Success",
                         "description": "If the function doesn't raise an Exception.",
@@ -47,6 +57,26 @@ def register(cls, type: str):
             }
         ))
 
+    def run_branch(self, outcome: str, **args):
+        branch_root_nodes = self._get_nodes_at_outcome(outcome)
+        return_value = None
+        for branch_root_node in branch_root_nodes:
+            branch_nodes = writer.workflows.get_branch_nodes(branch_root_node.id)
+
+            terminal_nodes = writer.workflows.get_terminal_nodes(branch_nodes)
+
+            for terminal_node in terminal_nodes:
+                tool = writer.workflows.run_node(terminal_node, branch_nodes, self.execution, self.session, self.execution_env | args)
+                if tool and tool.return_value:
+                    return_value = tool.return_value
+
+        return repr(return_value)
+
+    def _make_callable(self, tool_name: str):
+        def callable(**args):
+            return self.run_branch(f"$dynamic_{tool_name}", **args)
+        return callable
+
     def run(self):
         try:
             import writer.ai
@@ -55,6 +85,28 @@ def run(self):
             temperature = float(self._get_field("temperature", False, "0.7"))
             model_id = self._get_field("modelId", False, default_field_value=DEFAULT_MODEL)
             config = { "temperature": temperature, "model": model_id}
+            tools_raw = self._get_field("tools", True)
+            tools = []
+
+            for tool_name, tool_raw in tools_raw.items():
+                tool_type = tool_raw.get("type")
+                tool = None
+                if tool_type == "function":
+                    tool = writer.ai.FunctionTool(
+                        type="function",
+                        name=tool_name,
+                        description=tool_raw.get("description"),
+                        callable=self._make_callable(tool_name),
+                        parameters=tool_raw.get("parameters")
+                    )
+                elif tool_type == "graph":
+                    tool = {
+                        "type": "graph",
+                        "graph_ids": tool_raw.get("graph_ids")
+                    }
+                else:
+                    continue
+                tools.append(tool)
 
             conversation = self.evaluator.evaluate_expression(conversation_state_element, self.instance_path, self.execution_env)
 
@@ -62,13 +114,26 @@ def run(self):
                 conversation = writer.ai.Conversation(config=config)
                 self.evaluator.set_state(conversation_state_element, self.instance_path, conversation, base_context=self.execution_env)
 
-            # for chunk in conversation.stream_complete():
+            # msg = ""
+            # for chunk in conversation.stream_complete(tools=tools):
             #     if chunk.get("content") is None:
             #         chunk["content"] = ""
+            #     msg += chunk.get("content")
             #     conversation += chunk
+            #     self.evaluator.set_state(conversation_state_element, self.instance_path, conversation, base_context=self.execution_env)
+
+            msg = None
+            try:
+                msg = conversation.complete(tools=tools)
+            except BaseException as e:
+                msg = {
+                    "role": "assistant",
+                    "content": "Couldn't process the request."
+                }
+                raise e
+            finally:
+                conversation += msg
 
-            msg = conversation.complete()
-            conversation += msg
             self.evaluator.set_state(conversation_state_element, self.instance_path, conversation, base_context=self.execution_env)            
             self.result = msg
             self.outcome = "success"