diff --git a/.htmltest.yml b/.htmltest.yml
index 33ff03f3c..a785b2beb 100644
--- a/.htmltest.yml
+++ b/.htmltest.yml
@@ -35,6 +35,7 @@ IgnoreURLs:
 - "https://www.rabbitmq.com/.*"
 - "https://letsencrypt.org/.*"
 - "https://support.microsoft.com/.*"
+- "https://www.iso.org/.*"
 IgnoreDirs:
 - "docs/?.*/_print/"
 - "docs/?.*/_shared/"
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/attributes.md b/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/attributes.md
index 47b4415a0..f8a9450fa 100644
--- a/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/attributes.md
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/attributes.md
@@ -1,41 +1,268 @@
 ---
 title: "Attributes"
 linkTitle: "Attributes"
-description: "Information regarding file and folder attributes."
+description: "File and folder attribute flags (read-only, hidden, archive, and related), how Get Information blocks expose them, and how they behave on copy, move, and rename."
+weight: 3
 ---
 
 # {{% param title %}}
 
-{{< workinprogress >}}
-
 ## Summary
 
-TODO:
+**Attributes** are flags the file system stores on a file or folder — for example read-only, hidden, or archive. In {{% ctx %}}, they map to the .NET [FileAttributes][] enumeration used by [System.IO][] on the **server that executes the flow**.
+
+[Get File Information][] and [Get Folder Information][] read attributes into boolean properties on [FileInformation][] and [FolderInformation][] (for example `IsReadOnly`, `IsHidden`, `IsArchive`). There are no dedicated blocks for **setting** attributes; change them with C# or PowerShell when required.
+
+Copy, move, and rename blocks document how attributes are preserved, copied, or left unchanged for existing destinations. For path formats and naming rules, see [Paths][].
+
+## Attributes exposed by Get Information blocks
+
+[FileInformation][] and [FolderInformation][] expose the following attribute flags as [Boolean][] properties. Each corresponds to a [FileAttributes][] value:
+
+| Property | [FileAttributes][] value | Meaning |
+| --- | --- | --- |
+| `IsReadOnly` | `ReadOnly` | The file or folder is read-only. |
+| `IsHidden` | `Hidden` | The item is hidden and is typically omitted from ordinary directory listings. |
+| `IsSystem` | `System` | The item is marked as a system file (part of, or used exclusively by, the operating system). |
+| `IsArchive` | `Archive` | The item is marked for inclusion in an incremental backup. Windows often sets this when the item is modified. |
+| `IsNormal` | `Normal` | The item has no other special attributes. In .NET, `Normal` is valid only when used alone. |
+| `IsTemporary` | `Temporary` | The item is temporary. Temporary files are often kept in memory when possible and should be deleted when no longer needed. |
+| `IsCompressed` | `Compressed` | The item is compressed. |
+| `IsEncrypted` | `Encrypted` | The file’s data is encrypted, or encryption is the default for new items created under the folder. |
+
+These are the same flags shown in the result examples for [Get File Information][] and [Get Folder Information][]. Other [FileAttributes][] values (for example `Directory`, `SparseFile`, `ReparsePoint`, `Offline`) exist in .NET but are **not** returned as separate properties on [FileInformation][] / [FolderInformation][]. File versus folder is indicated by which data type and block you use, not by an `IsDirectory` property.
+
+{{% alert title="Note" %}}
+**FileAttributes** is a flags enumeration: more than one attribute can apply at once (for example read-only and archive). `IsNormal` is `true` only when the item has no other special attributes.
+{{% /alert %}}
+
+## How attributes behave with copy, move, and rename
+
+Files & Folders blocks that copy or move content apply these rules (see each block’s remarks for full detail):
+
+| Operation | Behaviour |
+| --- | --- |
+| [Copy File][] / [Copy Files][] | Attributes of each copied file are copied to the destination. |
+| [Move File][] / [Move Files][] | Attributes move with the file. If the destination already exists and is not overwritten, existing destination attributes are left unchanged. |
+| [Copy Folder][] / [Copy Folders][] / [Duplicate Folder][] | File attributes under the folder are copied. For folders: if the destination folder already exists, its attributes remain unchanged; otherwise they are copied. |
+| [Move Folder][] / [Move Folders][] | File attributes move with files. For folders that already exist at the destination, folder attributes remain unchanged; otherwise they move with the folder. |
+| [Rename Folder][] | Folder attributes are left unchanged. |
+
+When multiple source paths contribute conflicting content to the same destination (for example [Copy Folders][] or [Move Folders][] with overwrite), the **attributes** of the item that remains typically come from the **first** path processed, while file **content** may come from the **last** — see those blocks’ *Conflicting Content* remarks.
+
+## Reading attributes in a flow
+
+1. Call [Get File Information][] or [Get Folder Information][] with the path of the item.
+2. Use the output [FileInformation][] or [FolderInformation][] variable. Attribute flags are booleans such as `IsReadOnly`, `IsHidden`, and `IsArchive`.
+
+In the [Expression Editor][], test a flag after getting information — for example:
+
+```csharp
+($)FileInformation.IsReadOnly
+```
+
+or combine checks:
+
+```csharp
+($)FileInformation.IsHidden || ($)FileInformation.IsSystem
+```
+
+## Setting attributes
+
+There are currently no dedicated {{% ctx %}} blocks for setting file or folder attributes. To change attributes, use C# (for example in the [Expression Editor][]) or [Execute PowerShell Script][] on a host that can reach the path.
+
+### C# examples
+
+Read attributes with [File.GetAttributes][], then write them with [File.SetAttributes][]. Paths are resolved on the execution server (or a share that server can access), the same as other Files & Folders operations.
+
+Check whether a file is read-only:
+
+```csharp
+(System.IO.File.GetAttributes(@"C:\Source\File.txt") & System.IO.FileAttributes.ReadOnly) == System.IO.FileAttributes.ReadOnly
+```
+
+Add the read-only flag (preserve other flags):
+
+```csharp
+new System.Func<Exception>(() => {
+    try {
+        var path = @"C:\Source\File.txt";
+        var attributes = System.IO.File.GetAttributes(path);
+        System.IO.File.SetAttributes(path, attributes | System.IO.FileAttributes.ReadOnly);
+        return null;
+    }
+    catch (Exception ex) {
+        return ex;
+    }
+}).Invoke()
+```
+
+Clear the read-only flag:
 
-- Supported file and folder attributes and examples of using them
-- https://learn.microsoft.com/en-us/dotnet/api/system.io.fileattributes?view=net-5.0
-- Currently there are no specific blocks for setting attributes of files and folders (setting can be done through c# or PowerShell)
+```csharp
+new System.Func<Exception>(() => {
+    try {
+        var path = @"C:\Source\File.txt";
+        var attributes = System.IO.File.GetAttributes(path);
+        System.IO.File.SetAttributes(path, attributes & ~System.IO.FileAttributes.ReadOnly);
+        return null;
+    }
+    catch (Exception ex) {
+        return ex;
+    }
+}).Invoke()
+```
+
+Hide a file (add the hidden flag):
+
+```csharp
+new System.Func<Exception>(() => {
+    try {
+        var path = @"C:\Source\File.txt";
+        var attributes = System.IO.File.GetAttributes(path);
+        System.IO.File.SetAttributes(path, attributes | System.IO.FileAttributes.Hidden);
+        return null;
+    }
+    catch (Exception ex) {
+        return ex;
+    }
+}).Invoke()
+```
+
+Clear the hidden flag:
+
+```csharp
+new System.Func<Exception>(() => {
+    try {
+        var path = @"C:\Source\File.txt";
+        var attributes = System.IO.File.GetAttributes(path);
+        System.IO.File.SetAttributes(path, attributes & ~System.IO.FileAttributes.Hidden);
+        return null;
+    }
+    catch (Exception ex) {
+        return ex;
+    }
+}).Invoke()
+```
+
+The same [File.GetAttributes][] / [File.SetAttributes][] APIs apply to folders when you pass a folder path.
+
+### PowerShell examples
+
+With [Execute PowerShell Script][], common patterns include:
+
+```powershell
+# Make a file read-only (replaces the Attributes value)
+Set-ItemProperty -Path 'C:\Source\File.txt' -Name Attributes -Value 'ReadOnly'
+
+# Combine flags
+Set-ItemProperty -Path 'C:\Source\File.txt' -Name Attributes -Value 'ReadOnly,Hidden'
+
+# Clear special attributes (Normal means no other flags)
+Set-ItemProperty -Path 'C:\Source\File.txt' -Name Attributes -Value 'Normal'
+```
+
+or:
+
+```powershell
+(Get-Item 'C:\Source\File.txt').IsReadOnly = $true
+```
+
+Ensure the account that runs the script has permission to change attributes on that path.
 
 ## Remarks
 
 ### Known Limitations
 
-TODO
+#### No dedicated set-attribute blocks
+
+Reading attributes is supported through [Get File Information][] and [Get Folder Information][]. Changing attributes requires C# or PowerShell (see [Setting attributes](#setting-attributes)).
+
+#### Compression cannot be toggled with SetAttributes
+
+Per .NET guidance, you cannot change compression status with [File.SetAttributes][] alone. Compress or decompress the item with a compression tool or APIs in `System.IO.Compression` (or equivalent tooling), not by setting the `Compressed` flag in isolation. See [FileAttributes][].
+
+#### Normal is only valid alone
+
+`FileAttributes.Normal` / `IsNormal` means the item has no other special attributes. Do not combine `Normal` with other flags when calling [File.SetAttributes][].
+
+#### Permissions and locks
+
+Setting or reading attributes can fail with access-denied or sharing violations if the execution identity lacks rights or another process locks the item. Failed Files & Folders operations often surface as [OperationFailedException][]; .NET may report [UnauthorizedAccessException][] or [IOException][] for the underlying failure.
 
 ## See Also
 
 ### Related Concepts
 
-TODO
+* [What are Files and Folders?][]
+* [Paths][]
+* [What is a Flow?][]
 
 ### Related Data Types
 
-TODO
+* [FileSystemInformation][]
+* [FileInformation][]
+* [FolderInformation][]
+* [Boolean][]
+* [String][]
 
 ### Related Blocks
 
-TODO
+* [Get File Information][] / [Get Folder Information][]
+* [Copy File][] / [Copy Files][]
+* [Copy Folder][] / [Copy Folders][] / [Duplicate Folder][]
+* [Move File][] / [Move Files][]
+* [Move Folder][] / [Move Folders][]
+* [Rename Folder][]
+* [Execute PowerShell Script][]
+
+### Related Exceptions
+
+* [OperationFailedException][]
 
 ### External Documentation
 
-TODO
+* [FileAttributes][]
+* [File.GetAttributes][]
+* [File.SetAttributes][]
+* [File and Stream I/O][System.IO]
+* [Common I/O Tasks][]
+* [Handling I/O errors in .NET][]
+* [UnauthorizedAccessException][]
+* [IOException][]
+
+[What are Files and Folders?]: {{< url path="Cortex.Reference.Concepts.WorkingWith.FilesAndFolders.WhatAreFilesAndFolders.MainDoc" >}}
+[Paths]: {{< url path="Cortex.Reference.Concepts.WorkingWith.FilesAndFolders.Paths.MainDoc" >}}
+[What is a Flow?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Flows.WhatIsAFlow.MainDoc" >}}
+[Expression Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.ExpressionEditor.MainDoc" >}}
+
+[FileSystemInformation]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FileSystemInformation.MainDoc" >}}
+[FileInformation]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FileInformation.MainDoc" >}}
+[FolderInformation]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FolderInformation.MainDoc" >}}
+[Boolean]: {{< url path="Cortex.Reference.DataTypes.ConditionalLogic.Boolean.MainDoc" >}}
+[String]: {{< url path="Cortex.Reference.DataTypes.Text.String.MainDoc" >}}
+
+[Get File Information]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.GetFileInformation.GetFileInformation.MainDoc" >}}
+[Get Folder Information]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.GetFolderInformation.GetFolderInformation.MainDoc" >}}
+[Copy File]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFile.CopyFile.MainDoc" >}}
+[Copy Files]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFile.CopyFiles.MainDoc" >}}
+[Copy Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFolder.CopyFolder.MainDoc" >}}
+[Copy Folders]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFolder.CopyFolders.MainDoc" >}}
+[Duplicate Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFolder.DuplicateFolder.MainDoc" >}}
+[Move File]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFile.MoveFile.MainDoc" >}}
+[Move Files]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFile.MoveFiles.MainDoc" >}}
+[Move Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFolder.MoveFolder.MainDoc" >}}
+[Move Folders]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFolder.MoveFolders.MainDoc" >}}
+[Rename Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.RenameFolder.RenameFolder.MainDoc" >}}
+[Execute PowerShell Script]: {{< url path="Cortex.Reference.Blocks.PowerShell.ExecutePowerShellScript.ExecutePowerShellScript.MainDoc" >}}
+
+[OperationFailedException]: {{< url path="Cortex.Reference.Exceptions.FilesAndFolders.OperationFailedException.MainDoc" >}}
+
+[System.IO]: https://learn.microsoft.com/en-us/dotnet/standard/io/
+[FileAttributes]: https://learn.microsoft.com/en-us/dotnet/api/system.io.fileattributes
+[File.GetAttributes]: https://learn.microsoft.com/en-us/dotnet/api/system.io.file.getattributes
+[File.SetAttributes]: https://learn.microsoft.com/en-us/dotnet/api/system.io.file.setattributes
+[Common I/O Tasks]: https://learn.microsoft.com/en-us/dotnet/standard/io/common-i-o-tasks
+[Handling I/O errors in .NET]: https://learn.microsoft.com/en-us/dotnet/standard/io/handling-io-errors
+[UnauthorizedAccessException]: https://learn.microsoft.com/en-us/dotnet/api/system.unauthorizedaccessexception
+[IOException]: https://learn.microsoft.com/en-us/dotnet/api/system.io.ioexception
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/paths.md b/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/paths.md
index 72b26c7bc..f64e23ad9 100644
--- a/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/paths.md
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/paths.md
@@ -1,53 +1,247 @@
 ---
 title: "Paths"
 linkTitle: "Paths"
-description: "Information regarding file and folder paths."
+description: "Supported file and folder path formats, how flows distinguish files from folders, and naming rules for path components."
+weight: 2
 ---
 
 # {{% param title %}}
 
-{{< workinprogress >}}
-
 ## Summary
 
-TODO:
+A **path** is a string that locates a file or folder on a disk or network share. In {{% ctx %}}, Files & Folders blocks, email attachments, and related features pass path strings to the underlying .NET [System.IO][] APIs on the **server that executes the flow**. The path must be reachable from that server (locally or via a share it can access), not only from the machine where the flow was designed.
+
+{{% ctx %}} accepts the same broad Windows path forms documented for .NET: absolute DOS paths, relative paths, UNC paths, and (where the API allows) DOS device paths. For the full Windows rules, see [File path formats on Windows systems][] and [Naming Files, Paths, and Namespaces][].
+
+## Where paths are resolved
+
+Path strings are interpreted on the **execution server** (or on a UNC share that server can reach). The same rule applies to [email attachments][What is Email?] and other features that take file paths: store inputs and outputs where the Execution Service account can read and write them.
+
+Prefer absolute or UNC paths for production flows so behaviour does not depend on the process working directory. Use relative paths only when that working directory is intentional and documented.
+
+## Supported path formats
+
+Most Files & Folders path properties and attachment paths accept:
+
+| Format | Typical shape | Notes |
+| --- | --- | --- |
+| Absolute (DOS) | `C:\Source\File.txt` | Fully qualified from a drive root. Preferred for production flows. |
+| Relative | `Reports\out.csv`, `..\shared\data.json`, `\Program Files\App\file.txt` | Resolved against the process current directory (or current drive root when the path starts with `\`). |
+| UNC | `\\Server\Share\Folder\File.txt` | Network share. Always fully qualified; the execution server account must have access. |
+
+Examples of absolute and relative DOS paths (adapted from .NET guidance):
+
+| Path | Description |
+| --- | --- |
+| `C:\Documents\Newsletters\Summer2018.pdf` | Absolute file path from the root of drive `C:` |
+| `\Program Files\Custom Utilities\StringFinder.exe` | Relative to the root of the current drive |
+| `2018\January.xlsx` | Relative to a subdirectory of the current directory |
+| `..\Publications\TravelBrochure.pdf` | Relative, starting from the current directory |
+| `C:Projects\apilibrary\apilibrary.sln` | Relative to the *current directory on* drive `C:` (not the same as `C:\Projects\...`) |
+
+{{% alert title="Note" %}}
+`C:\Folder\file.txt` is absolute from the root of `C:`. `C:Folder\file.txt` (no `\` after the drive letter) is relative to the current directory on `C:`. Mixing these forms is a common source of path bugs; see {{< ahref path="MSDocs.DotNet.Api.System.IO.FilePathFormat" title="File path formats on Windows systems" >}}.
+{{% /alert %}}
+
+Examples of UNC paths:
+
+| Path | Description |
+| --- | --- |
+| `\\system07\C$\` | Root of the `C:` drive on `system07` (administrative share) |
+| `\\Server2\Share\Test\Foo.txt` | File under the `\\Server2\Share` volume |
+
+### DOS device paths
+
+Windows also supports DOS device path syntax such as `\\.\C:\Test\Foo.txt` and `\\?\C:\Test\Foo.txt` (and volume-GUID forms). .NET documents these under [File path formats on Windows systems][].
+
+Some {{% ctx %}} operations reject Win32 device paths that start with `\\.\`. For example, [Rename Folder][], [Move Folder][], and [Move Folders][] throw when the folder path (or destination path, where applicable) is a win32 device path. Prefer ordinary DOS or UNC paths in flows unless you have a specific need and have verified the block supports the form.
+
+## How {{% ctx %}} distinguishes file paths from folder paths
+
+Several blocks (for example [Copy File][] destination paths) need to know whether a path string **points to a folder or a file**. {{% ctx %}} applies these rules to the path string:
+
+| Rule | Interpreted as | Examples |
+| --- | --- | --- |
+| Path ends with `\` or `/` | Folder | `C:\Source\`, `C:\Source\Reports\` |
+| Path does not end with a file extension | Folder | `C:\Source`, `C:\Source\Reports` |
+| Path ends with a file extension (a final `.` followed by an extension) | File | `C:\Source\File.txt`, `Reports\out.csv` |
+| Path contains a `.` in a segment but still ends with `\` or `/` | Folder | `C:\Source.folder\`, `C:\Archive.2024\` |
+
+In short:
+
+* A terminating directory separator always means **folder**.
+* Otherwise, a trailing extension means **file**; no trailing extension means **folder**.
+
+File blocks treat a path that points to a folder as invalid (or, for [Check File Exists][], as non-existent). Folder blocks treat a path that points to a file as invalid (or, for [Check Folder Exists][], as non-existent). Invalid syntax or illegal characters typically surface as [InvalidPathException][] or [OperationFailedException][].
 
-- Supported file and folder path formats and examples of using them
-- How we determine is a path is a folder or a file
-  - path\ = folder (path with terminating \ or /)
-  - path = folder (path not ending in extension)
-  - path.extension = file (path ending in extension)
-  - path.anotherpartofpath\ = folder (as it ends in a \ or /)
-- Valid file and folder names
+## Rules that apply to path properties
 
-Links:
+Across Files & Folders blocks, path properties typically:
 
-- https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
-- https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
-- https://learn.microsoft.com/en-us/windows/wsl/filesystems
-- https://learn.microsoft.com/en-us/dotnet/standard/io/
-- https://learn.microsoft.com/en-us/dotnet/api/system.io.file?view=net-5.0
+* Are **case-insensitive** on Windows.
+* Must **not** contain wildcard characters (`*` and `?` belong in search patterns, not in the path itself).
+* Have **trailing spaces removed** automatically.
+* Do **not** strip **leading spaces** — leading spaces usually cause [InvalidPathException][] or [OperationFailedException][].
+* Must not be `null` or empty (`""`); empty or null values throw [PropertyEmptyException][] or [PropertyNullException][] on most blocks.
+* Must not contain only whitespace or the NUL character (`\0`).
+* Must not exceed the system-defined maximum length (typically **32,767** characters). Longer paths raise path-too-long failures (often wrapped in [OperationFailedException][] or reported as [PathTooLongException][] by .NET).
+
+### Escaping backslashes
+
+Path string literals require `\` to be escaped; otherwise each unescaped `\` is reported as an `Invalid property value` when debugging the flow. Escape by either:
+
+* Doubling the separator: `"C:\\Source\\File.txt"`
+* Using a verbatim string: `@"C:\Source\File.txt"`
+
+## Valid file and folder names
+
+Each component of a path (each folder name, and the final file name) must follow Windows naming rules. {{% ctx %}} rejects names that contain illegal characters; block documentation lists them as:
+
+`"`, `*`, `?`, `|`, `<`, `>`, `:`, `\`, `/`
+
+(colon is allowed only as the drive designator in a DOS path, for example `C:\...`, not inside a file or folder name).
+
+From Windows naming conventions ([Naming Files, Paths, and Namespaces][]):
+
+* Use `\` to separate path components; do not put `\` or `/` inside a name.
+* Do not assume case sensitivity (`Report.txt` and `report.txt` refer to the same name on typical Windows volumes).
+* Do not use reserved device names for a file or folder: `CON`, `PRN`, `AUX`, `NUL`, `COM1`–`COM9`, `LPT1`–`LPT9`, and related forms (including those names followed by an extension, such as `NUL.txt`).
+* Do not end a file or directory name with a space or a period. A leading period (for example `.temp`) is allowed.
+* Avoid characters whose integer values are 0–31 (including NUL).
+
+When renaming a folder, [Rename Folder][] validates the new name against the same character and length rules; invalid names throw [InvalidFolderNameException][].
+
+For the full Microsoft wording and namespace notes (`\\?\`, Win32 device namespace, and so on), see [Naming Files, Paths, and Namespaces][].
+
+## Building and expanding paths in expressions
+
+Files & Folders path properties expect a **resolved** path string. They do not expand `%ProgramData%`-style tokens inline the way some platform settings do. In the [Expression Editor][], expand paths with .NET — for example:
+
+```csharp
+Environment.ExpandEnvironmentVariables(@"%ProgramData%\MyOrg\FlowData\output.txt")
+```
+or:
+
+```csharp
+System.IO.Path.Combine(Environment.GetEnvironmentVariable("TEMP"), "flow-work", "scratch.txt")
+```
+
+`Path.Combine` joins segments using the platform directory separator. Prefer it over concatenating `"\\"` manually so relative segments compose correctly. See [What are Files and Folders?][] for common environment variables and [Environment.ExpandEnvironmentVariables][] for expansion behaviour.
 
 ## Remarks
 
 ### Known Limitations
 
-TODO
+#### Win32 device paths
+
+Paths that start with `\\.\` (Win32 device path syntax) are not accepted by some folder operations, including [Rename Folder][], [Move Folder][], and [Move Folders][]. Use absolute DOS or UNC paths instead.
+
+#### Relative paths and working directory
+
+Relative paths depend on the current directory of the execution process. That directory is not always obvious from the flow designer. Prefer absolute or UNC paths unless the working directory is controlled and documented.
+
+#### Leading spaces
+
+Trailing spaces are trimmed from path properties; leading spaces are not. A path with leading spaces is typically treated as invalid.
 
 ## See Also
 
 ### Related Concepts
 
-TODO
+* [What are Files and Folders?][]
+* [Attributes][]
+* [What is Email?][]
+* [What is a Flow?][]
 
 ### Related Data Types
 
-TODO
+* [FileSystemInformation][]
+* [FileInformation][]
+* [FolderInformation][]
+* [String][]
 
 ### Related Blocks
 
-TODO
+* [Check File Exists][] / [Check Folder Exists][]
+* [Create Folder][] / [Create Folders][]
+* [Copy File][] / [Copy Files][]
+* [Move File][] / [Move Files][]
+* [Move Folder][] / [Move Folders][]
+* [Rename Folder][]
+* [Get File Information][] / [Get Folder Information][]
+* [Get Folder Content][]
+* [Read All Text][] / [Write All Text][]
+* [Delete File][] / [Delete Folder][]
+
+### Related Exceptions
+
+* [InvalidPathException][]
+* [InvalidFolderNameException][]
+* [OperationFailedException][]
+* [PropertyEmptyException][]
+* [PropertyNullException][]
 
 ### External Documentation
 
-TODO
+* [File path formats on Windows systems][]
+* [Naming Files, Paths, and Namespaces][]
+* [File and Stream I/O][System.IO]
+* [Common I/O Tasks][]
+* [Handling I/O errors in .NET][]
+* [Path.Combine][]
+* [Path.IsPathFullyQualified][]
+* [Environment.ExpandEnvironmentVariables][]
+* [FileNotFoundException][]
+* [IOException][]
+* [PathTooLongException][]
+* [UnauthorizedAccessException][]
+
+[What are Files and Folders?]: {{< url path="Cortex.Reference.Concepts.WorkingWith.FilesAndFolders.WhatAreFilesAndFolders.MainDoc" >}}
+[Attributes]: {{< url path="Cortex.Reference.Concepts.WorkingWith.FilesAndFolders.Attributes.MainDoc" >}}
+[What is Email?]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Email.WhatIsEmail.MainDoc" >}}
+[What is a Flow?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Flows.WhatIsAFlow.MainDoc" >}}
+[Expression Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.ExpressionEditor.MainDoc" >}}
+
+[FileSystemInformation]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FileSystemInformation.MainDoc" >}}
+[FileInformation]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FileInformation.MainDoc" >}}
+[FolderInformation]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FolderInformation.MainDoc" >}}
+[String]: {{< url path="Cortex.Reference.DataTypes.Text.String.MainDoc" >}}
+
+[Check File Exists]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CheckFile.CheckFileExists.MainDoc" >}}
+[Check Folder Exists]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CheckFolder.CheckFolderExists.MainDoc" >}}
+[Create Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CreateFolder.CreateFolder.MainDoc" >}}
+[Create Folders]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CreateFolder.CreateFolders.MainDoc" >}}
+[Copy File]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFile.CopyFile.MainDoc" >}}
+[Copy Files]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFile.CopyFiles.MainDoc" >}}
+[Move File]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFile.MoveFile.MainDoc" >}}
+[Move Files]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFile.MoveFiles.MainDoc" >}}
+[Move Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFolder.MoveFolder.MainDoc" >}}
+[Move Folders]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFolder.MoveFolders.MainDoc" >}}
+[Rename Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.RenameFolder.RenameFolder.MainDoc" >}}
+[Get File Information]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.GetFileInformation.GetFileInformation.MainDoc" >}}
+[Get Folder Information]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.GetFolderInformation.GetFolderInformation.MainDoc" >}}
+[Get Folder Content]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.GetFolderContent.GetFolderContent.MainDoc" >}}
+[Read All Text]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.ReadFile.ReadAllText.MainDoc" >}}
+[Write All Text]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.WriteFile.WriteAllText.MainDoc" >}}
+[Delete File]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.DeleteFile.DeleteFile.MainDoc" >}}
+[Delete Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.DeleteFolder.DeleteFolder.MainDoc" >}}
+
+[InvalidPathException]: {{< url path="Cortex.Reference.Exceptions.FilesAndFolders.InvalidPathException.MainDoc" >}}
+[InvalidFolderNameException]: {{< url path="Cortex.Reference.Exceptions.FilesAndFolders.InvalidFolderNameException.MainDoc" >}}
+[OperationFailedException]: {{< url path="Cortex.Reference.Exceptions.FilesAndFolders.OperationFailedException.MainDoc" >}}
+[PropertyEmptyException]: {{< url path="Cortex.Reference.Exceptions.Common.Property.PropertyEmptyException.MainDoc" >}}
+[PropertyNullException]: {{< url path="Cortex.Reference.Exceptions.Common.Property.PropertyNullException.MainDoc" >}}
+
+[Naming Files, Paths, and Namespaces]: {{< url path="MSDocs.Windows.Apps.Win32.DesktopTechnologies.DataAccessAndStorage.LocalFileSystems.NamingFilesPathsAndNamespaces.MainDoc" >}}
+[FileNotFoundException]: {{< url path="MSDocs.DotNet.Api.System.IO.FileNotFoundException" >}}
+[IOException]: {{< url path="MSDocs.DotNet.Api.System.IO.IOException" >}}
+[PathTooLongException]: {{< url path="MSDocs.DotNet.Api.System.IO.PathTooLongException" >}}
+[UnauthorizedAccessException]: {{< url path="MSDocs.DotNet.Api.System.UnauthorizedAccessException" >}}
+
+[System.IO]: https://learn.microsoft.com/en-us/dotnet/standard/io/
+[File path formats on Windows systems]: {{< url path="MSDocs.DotNet.Api.System.IO.FilePathFormat" >}}
+[Common I/O Tasks]: https://learn.microsoft.com/en-us/dotnet/standard/io/common-i-o-tasks
+[Handling I/O errors in .NET]: https://learn.microsoft.com/en-us/dotnet/standard/io/handling-io-errors
+[Path.Combine]: https://learn.microsoft.com/en-us/dotnet/api/system.io.path.combine
+[Path.IsPathFullyQualified]: https://learn.microsoft.com/en-us/dotnet/api/system.io.path.ispathfullyqualified
+[Environment.ExpandEnvironmentVariables]: https://learn.microsoft.com/en-us/dotnet/api/system.environment.expandenvironmentvariables
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/what-are-files-and-folders.md b/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/what-are-files-and-folders.md
index 529943f59..ae8cf42ee 100644
--- a/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/what-are-files-and-folders.md
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/files-and-folders/what-are-files-and-folders.md
@@ -1,46 +1,249 @@
 ---
 title: "What are Files and Folders?"
 linkTitle: "What are Files and Folders?"
-description: "Information regarding what files and folders are."
+description: "How flows work with files and folders, including paths, common operations, encodings, environment variables, and best practices."
 weight: 1
 ---
 
 # {{% param title %}}
 
-{{< workinprogress >}}
-
 ## Summary
 
-TODO:
+In {{% ctx %}}, a **file** is a named collection of bytes stored on disk (or a network share), and a **folder** (also called a directory) is a container that holds files and other folders. Files & Folders blocks resolve [paths][] and perform I/O on the **server that executes the flow**.
+
+{{% ctx %}} wraps common tasks in blocks and data types so flows can check, create, copy, move, delete, read, write, and search files and folders consistently.
+
+| Term | Meaning |
+| --- | --- |
+| File | Named content on disk (for example `report.csv` or `log.txt`) |
+| Folder | Container for files and subfolders (for example `C:\Source\Folder`) |
+| [Path][paths] | String that locates a file or folder (absolute, relative, or UNC) |
+| [FileInformation][] / [FolderInformation][] | Metadata returned by Get Information blocks (attributes, size, timestamps, and path parts) |
+| [Attributes][] | Flags such as read-only, hidden, or archive on a file or folder |
+
+For path formats, naming rules, and how {{% ctx %}} distinguishes file paths from folder paths, see [Paths][paths]. For attribute flags, see [Attributes][].
+
+## Working with files and folders in a flow
+
+Flows use Files & Folders blocks. Typical tasks map to the categories below.
+
+| Task | Typical blocks |
+| --- | --- |
+| Check existence | [Check File Exists][], [Check Folder Exists][] |
+| Create folders | [Create Folder][], [Create Folders][] |
+| Read content | [Read All Text][], [Read All Lines][] |
+| Write content | [Write All Text][], [Write All Lines][] |
+| Search within files | [Search File][], [Search Files][] |
+| List folder contents | [Get Folder Content][] |
+| Inspect metadata | [Get File Information][], [Get Folder Information][] |
+| Copy | [Copy File][], [Copy Files][], [Copy Folder][], [Copy Folders][], [Duplicate Folder][] |
+| Move / rename | [Move File][], [Move Files][], [Move Folder][], [Move Folders][], [Rename Folder][] |
+| Delete | [Delete File][], [Delete Files][], [Delete Folder][], [Delete Folders][] |
+
+Most path properties:
+
+* Are case-insensitive on Windows.
+* Must not contain wildcard characters (wildcards belong in search patterns, not in the path itself).
+* Have trailing spaces removed automatically.
+* Require `\` characters to be escaped in string literals (`"C:\\Source\\File.txt"` or `@"C:\Source\File.txt"`).
+
+[Write All Text][] and [Write All Lines][] create the target file if it does not exist, and create any missing parent folders. [Delete Folder][] requires its Recursive property to be `true` before a folder that still contains files or subfolders can be deleted.
+
+Failed operations often surface as [OperationFailedException][], with per-path details in `PathExceptions`. Invalid syntax or illegal characters typically throw [InvalidPathException][]. Invalid rename or duplicate names throw [InvalidFolderNameException][]. For underlying .NET behaviour when the operating system reports I/O failures, see [Handling I/O errors in .NET][].
+
+## Paths and where files are resolved
+
+Path strings are interpreted on the **execution server** (or on a UNC share that server can reach), not necessarily on the machine where the flow was designed. Absolute, relative, and UNC forms are supported; see [Paths][paths] for formats and examples.
+
+This is the same rule used for email attachments and other features that take file paths: store inputs and outputs where the Execution Service account can read and write them. See [What is Email?][] for attachment path guidance.
+
+## Encoding
+
+Text read, write, and search blocks accept an optional [Encoding][]:
 
-- https://learn.microsoft.com/en-us/dotnet/standard/io/
-- https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
-- https://learn.microsoft.com/en-us/dotnet/standard/io/handling-io-errors
-- https://learn.microsoft.com/en-us/dotnet/standard/io/common-i-o-tasks
-- list of common extensions
-- list of common environment variables (`%PROGRAMDATA%` check this works)
-- Best Practices (how to work with files, where to save them when working with files and folders in a flow)
+* **Read** and **search** — leave [Encoding][] as `null` to let the block detect encoding from byte order marks when possible; set it explicitly when auto-detection is wrong.
+* **Write** — leave [Encoding][] as `null` to write UTF-8 without a byte order mark.
+
+For available encodings and examples, see [Encoding][Working with Text - Encoding].
+
+## Common file extensions
+
+The extension is the suffix after the final `.` in a file name (for example `.txt` on `File.txt`). {{% ctx %}} does not restrict you to a fixed list of extensions; the file system and the application that consumes the file determine meaning. Extensions commonly used in automation and documentation include:
+
+| Extension | Typical content |
+| --- | --- |
+| `.txt`, `.log` | Plain text or log output |
+| `.csv` | Delimited tabular data |
+| `.json`, `.xml` | Structured data or configuration |
+| `.pdf`, `.docx`, `.xlsx` | Documents and spreadsheets (often as attachments or outputs from other systems) |
+| `.zip` | Compressed archives |
+| `.exe` | Windows executables (for existence checks or process-related paths) |
+
+[Get File Information][] returns the extension as part of [FileInformation][]. Prefer clear, conventional extensions so downstream tools and operators can identify file types reliably.
+
+## Common environment variables
+
+Windows exposes well-known directories through environment variables. Use them so flows do not hard-code machine-specific roots. Values below are typical defaults; the actual path depends on the execution host and the account running the flow.
+
+| Variable | Typical use |
+| --- | --- |
+| `%ProgramData%` | Data shared by all users on the machine ({{% ctx %}} install and logging paths often use this root) |
+| `%TEMP%` / `%TMP%` | Short-lived working files for the current user or process |
+| `%USERPROFILE%` | Profile root for the user the flow runs as |
+| `%APPDATA%` | Roaming per-user application data |
+| `%LOCALAPPDATA%` | Non-roaming per-user application data |
+| `%SystemRoot%` / `%WINDIR%` | Windows installation directory |
+| `%ProgramFiles%` / `%ProgramFiles(x86)%` | Installed programs |
+
+Some platform settings (for example the [Log Event][] block default log `path`) accept `%ProgramData%` inline and expand it. Files & Folders block path properties expect a resolved path string. In the [Expression Editor][], expand variables with .NET before passing the path to a block — for example:
+
+```csharp
+Environment.ExpandEnvironmentVariables(@"%ProgramData%\\MyOrg\\output.txt")
+```
+
+or:
+
+```csharp
+System.IO.Path.Combine(Environment.GetEnvironmentVariable("TEMP"), "flow-work", "scratch.txt")
+```
+
+For expansion behaviour, see [Environment.ExpandEnvironmentVariables][].
+
+## Best practices
+
+* Resolve paths on the **execution server**. Design-time paths on a workstation will fail at runtime unless the same location exists on the server or you use a UNC share the server can access.
+* Prefer absolute or UNC paths for production flows so behaviour does not depend on the process working directory. Use relative paths only when that working directory is intentional and documented.
+* Escape backslashes in path literals (`@"C:\Folder\file.txt"` or `"C:\\Folder\\file.txt"`).
+* Choose a durable location for outputs. Use `%ProgramData%` (or an agreed share) for shared or retained artefacts; use `%TEMP%` only for disposable intermediate files, and delete them when the flow finishes.
+* Avoid writing into system directories such as `%SystemRoot%` or `%ProgramFiles%` unless the process identity is meant to manage software there.
+* Check before destructive work. Use [Check File Exists][] / [Check Folder Exists][], and set overwrite or recursive options deliberately on copy, move, and delete blocks.
+* Handle failures. Catch or handle [OperationFailedException][] and related path exceptions when I/O may fail because of permissions, locks, missing paths, or invalid names.
+* Set encoding when needed. Specify [Encoding][] for non-UTF-8 files or when auto-detection is unreliable.
+* Attributes: use [Get File Information][] / [Get Folder Information][] to read attributes. There are no dedicated blocks today for setting attributes; change them with C# or PowerShell when required. See [Attributes][].
 
 ## Remarks
 
 ### Known Limitations
 
-TODO
+#### Setting attributes
+
+There are currently no dedicated blocks for setting file or folder attributes. Reading attributes is supported through [Get File Information][] and [Get Folder Information][]. To change attributes, use C# or PowerShell.
 
 ## See Also
 
 ### Related Concepts
 
-TODO
+* [Files and Folders][]
+* [Paths][paths]
+* [Attributes][]
+* [Encoding][Working with Text - Encoding]
+* [What is a Flow?][]
+* [What is Email?][]
 
 ### Related Data Types
 
-TODO
+* [FileSystemInformation][]
+* [FileInformation][]
+* [FolderInformation][]
+* [FileMatch][]
+* [ContentOptions][]
+* [Encoding][]
+* [String][]
 
 ### Related Blocks
 
-TODO
+* [Check File Exists][]
+* [Check Folder Exists][]
+* [Create Folder][] / [Create Folders][]
+* [Read All Text][] / [Read All Lines][]
+* [Write All Text][] / [Write All Lines][]
+* [Search File][] / [Search Files][]
+* [Get Folder Content][]
+* [Get File Information][] / [Get Folder Information][]
+* [Copy File][] / [Copy Files][]
+* [Copy Folder][] / [Copy Folders][] / [Duplicate Folder][]
+* [Move File][] / [Move Files][]
+* [Move Folder][] / [Move Folders][]
+* [Rename Folder][]
+* [Delete File][] / [Delete Files][]
+* [Delete Folder][] / [Delete Folders][]
+
+### Related Exceptions
+
+* [InvalidPathException][]
+* [InvalidFolderNameException][]
+* [OperationFailedException][]
 
 ### External Documentation
 
-TODO
+* [File and Stream I/O][System.IO]
+* [File path formats on Windows systems][]
+* [Handling I/O errors in .NET][]
+* [Common I/O Tasks][]
+* [Naming Files, Paths, and Namespaces][]
+* [Environment.ExpandEnvironmentVariables][]
+* [FileNotFoundException][]
+* [IOException][]
+* [PathTooLongException][]
+* [UnauthorizedAccessException][]
+
+[paths]: {{< url path="Cortex.Reference.Concepts.WorkingWith.FilesAndFolders.Paths.MainDoc" >}}
+[Attributes]: {{< url path="Cortex.Reference.Concepts.WorkingWith.FilesAndFolders.Attributes.MainDoc" >}}
+[Files and Folders]: {{< url path="Cortex.Reference.Concepts.WorkingWith.FilesAndFolders.MainDoc" >}}
+[What is a Flow?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Flows.WhatIsAFlow.MainDoc" >}}
+[What is Email?]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Email.WhatIsEmail.MainDoc" >}}
+[Working with Text - Encoding]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Text.Encoding.MainDoc" >}}
+[Expression Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.ExpressionEditor.MainDoc" >}}
+
+[FileSystemInformation]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FileSystemInformation.MainDoc" >}}
+[FileInformation]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FileInformation.MainDoc" >}}
+[FolderInformation]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FolderInformation.MainDoc" >}}
+[FileMatch]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.FileMatch.MainDoc" >}}
+[ContentOptions]: {{< url path="Cortex.Reference.DataTypes.FilesAndFolders.ContentOptions.MainDoc" >}}
+[Encoding]: {{< url path="Cortex.Reference.DataTypes.Text.Encoding.MainDoc" >}}
+[String]: {{< url path="Cortex.Reference.DataTypes.Text.String.MainDoc" >}}
+
+[Check File Exists]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CheckFile.CheckFileExists.MainDoc" >}}
+[Check Folder Exists]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CheckFolder.CheckFolderExists.MainDoc" >}}
+[Create Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CreateFolder.CreateFolder.MainDoc" >}}
+[Create Folders]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CreateFolder.CreateFolders.MainDoc" >}}
+[Read All Text]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.ReadFile.ReadAllText.MainDoc" >}}
+[Read All Lines]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.ReadFile.ReadAllLines.MainDoc" >}}
+[Write All Text]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.WriteFile.WriteAllText.MainDoc" >}}
+[Write All Lines]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.WriteFile.WriteAllLines.MainDoc" >}}
+[Search File]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.SearchFile.SearchFile.MainDoc" >}}
+[Search Files]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.SearchFile.SearchFiles.MainDoc" >}}
+[Get Folder Content]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.GetFolderContent.GetFolderContent.MainDoc" >}}
+[Get File Information]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.GetFileInformation.GetFileInformation.MainDoc" >}}
+[Get Folder Information]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.GetFolderInformation.GetFolderInformation.MainDoc" >}}
+[Copy File]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFile.CopyFile.MainDoc" >}}
+[Copy Files]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFile.CopyFiles.MainDoc" >}}
+[Copy Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFolder.CopyFolder.MainDoc" >}}
+[Copy Folders]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFolder.CopyFolders.MainDoc" >}}
+[Duplicate Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.CopyFolder.DuplicateFolder.MainDoc" >}}
+[Move File]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFile.MoveFile.MainDoc" >}}
+[Move Files]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFile.MoveFiles.MainDoc" >}}
+[Move Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFolder.MoveFolder.MainDoc" >}}
+[Move Folders]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.MoveFolder.MoveFolders.MainDoc" >}}
+[Rename Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.RenameFolder.RenameFolder.MainDoc" >}}
+[Delete File]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.DeleteFile.DeleteFile.MainDoc" >}}
+[Delete Files]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.DeleteFile.DeleteFiles.MainDoc" >}}
+[Delete Folder]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.DeleteFolder.DeleteFolder.MainDoc" >}}
+[Delete Folders]: {{< url path="Cortex.Reference.Blocks.FilesAndFolders.DeleteFolder.DeleteFolders.MainDoc" >}}
+[Log Event]: {{< url path="Cortex.Reference.Blocks.Logs.LogEvent.LogEvent.MainDoc" >}}
+
+[InvalidPathException]: {{< url path="Cortex.Reference.Exceptions.FilesAndFolders.InvalidPathException.MainDoc" >}}
+[InvalidFolderNameException]: {{< url path="Cortex.Reference.Exceptions.FilesAndFolders.InvalidFolderNameException.MainDoc" >}}
+[OperationFailedException]: {{< url path="Cortex.Reference.Exceptions.FilesAndFolders.OperationFailedException.MainDoc" >}}
+
+[Naming Files, Paths, and Namespaces]: {{< url path="MSDocs.Windows.Apps.Win32.DesktopTechnologies.DataAccessAndStorage.LocalFileSystems.NamingFilesPathsAndNamespaces.MainDoc" >}}
+[FileNotFoundException]: {{< url path="MSDocs.DotNet.Api.System.IO.FileNotFoundException" >}}
+[IOException]: {{< url path="MSDocs.DotNet.Api.System.IO.IOException" >}}
+[PathTooLongException]: {{< url path="MSDocs.DotNet.Api.System.IO.PathTooLongException" >}}
+[UnauthorizedAccessException]: {{< url path="MSDocs.DotNet.Api.System.UnauthorizedAccessException" >}}
+
+[System.IO]: https://learn.microsoft.com/en-us/dotnet/standard/io/
+[File path formats on Windows systems]: https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
+[Handling I/O errors in .NET]: https://learn.microsoft.com/en-us/dotnet/standard/io/handling-io-errors
+[Common I/O Tasks]: https://learn.microsoft.com/en-us/dotnet/standard/io/common-i-o-tasks
+[Environment.ExpandEnvironmentVariables]: https://learn.microsoft.com/en-us/dotnet/api/system.environment.expandenvironmentvariables
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/loops/what-is-a-loop.md b/content/en/docs/2026.3/Reference/Concepts/working-with/loops/what-is-a-loop.md
index 5cbe0aec5..74f511227 100644
--- a/content/en/docs/2026.3/Reference/Concepts/working-with/loops/what-is-a-loop.md
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/loops/what-is-a-loop.md
@@ -1,74 +1,174 @@
 ---
 title: "What is a Loop?"
 linkTitle: "What is a Loop?"
-description: "Information regarding what a loop is."
+description: "Overview of loops in CORTEX, including for and for each blocks, while and do-while patterns with decision blocks, nested loops, and infinite-loop protection."
 weight: 1
 ---
 
 # {{% param title %}}
 
-{{< workinprogress >}}
-
 ## Summary
 
-TODO:
-
-- Introduce concept of loop
-  - Why are they used
-- Types of Loops (pros and cons)
-  - For loop
-    - Can move forwards or backwards
-    - Can move by single or multiple increments
-    - Can modify a collection while iterating over it
-    - Have to manually manage the bounds of the loop
-    - Index can be adjusted to break a loop
-    - Decision blocks can be used to break a loop
-  - For each
-    - Cannot modify the collection during a for each loop (use a for loop if the collection needs to be modified during the loop)
-    - Decision blocks can be used to break a loop
-  - While
-    - No blocks, can be done using decision blocks looping back into the flow (order of decision block determines while or do while loop)
-    - Condition can be adjusted to break a loop early
-    - Decision blocks can be used to break a loop early
-  - Do while
-    - No blocks, can be done using decision blocks looping back into the flow (order of decision block determines while or do while loop)
-    - Condition can be adjusted to break a loop early
-    - Decision blocks can be used to break a loop early
-- Nested loops
-  - Why they are used
-  - How nested loops affect performance
-- Infinite loops
-  - Why they are bad, how to avoid
-  - for loop block protects against infinite loops
-  - for each loop block cannot have infinite loops as the collection cannot be modified
-  - while/ do while does not have any protection against infinite loops (must be managed within the flow)
-
-Links:
-
-- [Overview: the four different loops of the C# programming language][What is a loop]
+A **loop** repeats a set of blocks until a stopping condition is met. In {{% ctx %}}, loops are used to process each item in a [collection][], run logic a fixed number of times, or keep running until a condition becomes false — without duplicating the same blocks on the canvas.
+
+{{% ctx %}} provides two dedicated loop blocks — [For Loop][] and [For Each Loop][] — that expose a right port (blue loop icon) for the body of the loop and a bottom port (green tick) when looping finishes. Condition-driven loops equivalent to C# `while` and `do`/`while` are built with [Decision][Decision Blocks] blocks and links that return into earlier steps of the flow.
+
+These patterns mirror the four C# iteration statements (`for`, `foreach`, `while`, and `do`): see [Overview: the four different loops of the C# programming language][Kodify What is a loop] and the [C# language documentation][MS CSharp Main].
+
+| Loop type | How it is implemented | Typical use | Bounded automatically? |
+| --- | --- | --- | --- |
+| [For][For Loop] | [For Loop][] block | Known range of [indexes][]; step size or direction matters | Yes — invalid ranges throw [InfiniteLoopException][] |
+| [For each][For Each Loop] | [For Each Loop][] block | Every item in a [collection][] | Yes — iteration count follows the collection size |
+| [While][While and do while] | [Decision][Decision Blocks] blocks + flow links | Repeat while a condition is true (may run zero times) | No — you must ensure the condition eventually fails |
+| [Do while][While and do while] | [Decision][Decision Blocks] blocks + flow links | Run the body at least once, then continue while a condition is true | No — you must ensure the condition eventually fails |
+
+## Types of Loops
+
+### For Loop
+
+The [For Loop][] block repeats its body based on a [Start Index][], [End Index][], and [Increment][]. [Start Index][] and [End Index][] are inclusive. [Current Index][] is set to [Start Index][] on the first iteration and then changed by [Increment][] on each subsequent iteration. While looping continues, the flow exits via the block's right port (blue loop icon); when finished, it exits via the bottom port (green tick) and [Current Index][] is reset to `0`.
+
+Compared with the other loop types:
+
+* **Forward or backward** — Use a positive [Increment][] when [Start Index][] is less than or equal to [End Index][], and a negative [Increment][] when looping from a higher start to a lower end.
+* **Step size** — [Increment][] can be `1`, `-1`, or any other non-zero step (for example `5` or `-5`).
+* **Index control** — You manage the start, end, and step yourself. You can also change [Current Index][] inside the loop body to skip iterations or end the loop early (for example by moving the index past the end of the range).
+* **Collection changes** — Because the loop is driven by indexes rather than an enumerator, you can change a [collection][] while iterating over it by index (prefer this when items must be added or removed during the loop).
+* **Early exit** — Use a [Decision][Decision Blocks] block inside the loop body to route the execution out of the loop path when a condition is met.
+
+If [Increment][] is `0`, or its sign cannot reach [End Index][] from [Start Index][], the block throws [InfiniteLoopException][] the first time it runs. See [InfiniteLoopException][] for [error codes][InfiniteLoopErrorCode] and how to fix them.
+
+[Current Index][] must already hold an [Int32][] value before the block runs; otherwise [InvalidPropertyValueException][] is thrown. See the [For Loop][] known limitations.
+
+### For Each Loop
+
+The [For Each Loop][] block enumerates every item in a [Collection][collection] ([List][], [Dictionary][], [Structure][], or any [IEnumerable][]). On each iteration, [Current Iteration][] is a [Structure][] with `"Index"` (zero-based) and `"Value"` (the item; for dictionaries and structures, `"Value"` is itself a key/value pair). The flow exits via the right port while items remain, then via the bottom port when finished; [Current Iteration][] is then cleared.
+
+Compared with the other loop types:
+
+* **No manual bounds** — You do not set start, end, or increment; the number of iterations matches the number of items.
+* **Empty collections** — If [Collection][collection] is empty, the body does not run.
+* **Index is restored** — If you change `"Index"` on [Current Iteration][] during an iteration, it is set back before the next iteration, so you cannot end the loop early by editing the index.
+* **Do not modify the collection** — Do not add, remove, or replace items in the [collection][] while a for each loop is running over it. If the collection must change during iteration, use a [For Loop][] over indexes instead (the same guidance applies to C# `foreach`).
+* **Early exit** — Use a [Decision][Decision Blocks] block in the loop body to leave the loop path when needed.
+
+If [Collection][collection] is `null`, the block throws [PropertyNullException][].
+
+### While and do while
+
+{{% ctx %}} has no dedicated while or do-while blocks. Build these patterns with [Decision][Decision Blocks] blocks (for example [If True Exit Right][] or [If True Exit Bottom][]) and links that return to earlier blocks:
+
+* **While** — Evaluate the condition **before** the body. If the condition is false on the first check, the body never runs (zero or more iterations), matching C# `while`.
+* **Do while** — Run the body **first**, then evaluate the condition and link back only when it is still true (one or more iterations), matching C# `do`.
+
+Which pattern you get depends on where the decision sits relative to the repeated blocks. You can change the condition (or route with another decision) to stop early. Unlike [For Loop][], there is no built-in protection against a condition that never becomes false — see [Infinite loops][].
+
+## Nested Loops
+
+A **nested loop** is a loop whose body contains another loop. Use nesting when each iteration of an outer loop must run an inner loop — for example pairing every item in one [list][List] with every item in another, or walking rows and columns of structured data.
+
+Nesting multiplies work: if the outer loop runs *m* times and the inner loop runs *n* times per outer iteration, the inner body runs roughly *m* × *n* times. Deep nesting or large collections can slow [flow executions][] significantly; keep nesting shallow when possible, or filter collections before looping.
+
+You can nest [For Loop][] and [For Each Loop][] blocks with each other, and nest either inside while/do-while patterns built with [Decision][Decision Blocks] blocks.
+
+## Infinite Loops
+
+An **infinite loop** repeats without ever satisfying its stop condition. That can hang a [flow execution][], consume CPU, and block other work. Avoid them by ensuring every loop has a reachable exit.
+
+| Pattern | Infinite-loop behaviour |
+| --- | --- |
+| [For Loop][] | Protected — mismatched or zero [Increment][] throws [InfiniteLoopException][] before unbounded spinning |
+| [For Each Loop][] | Bounded by the [collection][] size. Changing `"Index"` does not extend the loop; do not grow the collection during iteration |
+| While / do while | **Not** protected — you must update variables so the decision condition eventually fails, or provide another exit path |
 
 ## Remarks
 
+### Choosing a loop type
+
+| Goal | Prefer |
+| --- | --- |
+| Fixed numeric range, custom step, or reverse order | [For Loop][] |
+| Process every item in a [collection][] without changing it | [For Each Loop][] |
+| Change a [collection][] while iterating | [For Loop][] over [indexes][] |
+| Repeat until an external or calculated condition flips | While or do while with [Decision][Decision Blocks] blocks |
+| Guarantee the body runs at least once | Do while arrangement of decision after the body |
+
 ### Known Limitations
 
-TODO
+* [For Loop][] — The variable used for [Current Index][] must have an [Int32][] value assigned before the block executes.
+* [For Each Loop][] — Modifications to [Current Iteration][] `"Index"` are discarded before the next iteration.
+* While and do while — There are no dedicated blocks and no automatic infinite-loop detection; you must design a terminating condition in the flow.
 
 ## See Also
 
 ### Related Concepts
 
-TODO
+* [What is a Collection?][]
+* [Indexes][indexes]
+* [Items][]
+* [What is a Flow?][]
+* [What is an Exception?][]
 
 ### Related Data Types
 
-TODO
+* [Int32][]
+* [IEnumerable][]
+* [List][]
+* [Dictionary][]
+* [Structure][]
+* [InfiniteLoopErrorCode][]
 
 ### Related Blocks
 
-TODO
+* [For Loop][]
+* [For Each Loop][]
+* [Decision][Decision Blocks] blocks (for example [If True Exit Right][], [If True Exit Bottom][])
 
-### External Documentation
+### Related Exceptions
 
-TODO
+* [InfiniteLoopException][]
+* [InvalidPropertyValueException][]
+* [PropertyNullException][]
+
+### External Documentation
 
-[What is a loop]: {{< url path="Kodify.WhatIsALoop" >}}
\ No newline at end of file
+* [Overview: the four different loops of the C# programming language][Kodify What is a loop]
+* [C# documentation][MS CSharp Main]
+
+[Infinite loops]: {{< ref "#infinite-loops" >}}
+[While and do while]: {{< ref "#while-and-do-while" >}}
+
+[For Loop]: {{< url path="Cortex.Reference.Blocks.Loops.For.ForLoop.MainDoc" >}}
+[For Each Loop]: {{< ref "../../../Blocks/loops/for-each/for-each-loop-block.md" >}}
+[Decision Blocks]: {{< url path="Cortex.Reference.Blocks.Decisions.MainDoc" >}}
+[If True Exit Right]: {{< ref "../../../Blocks/decisions/if/if-true-exit-right-block.md" >}}
+[If True Exit Bottom]: {{< ref "../../../Blocks/decisions/if/if-true-exit-bottom-block.md" >}}
+
+[Start Index]: {{< ref "../../../Blocks/loops/for/for-loop-block.md#start-index" >}}
+[End Index]: {{< ref "../../../Blocks/loops/for/for-loop-block.md#end-index" >}}
+[Increment]: {{< ref "../../../Blocks/loops/for/for-loop-block.md#increment" >}}
+[Current Index]: {{< ref "../../../Blocks/loops/for/for-loop-block.md#current-index" >}}
+[collection]: {{< ref "../../../Blocks/loops/for-each/for-each-loop-block.md#collection" >}}
+[Current Iteration]: {{< ref "../../../Blocks/loops/for-each/for-each-loop-block.md#current-iteration" >}}
+
+[InfiniteLoopException]: {{< url path="Cortex.Reference.Exceptions.Loops.InfiniteLoopException.MainDoc" >}}
+[InvalidPropertyValueException]: {{< url path="Cortex.Reference.Exceptions.Flows.Blocks.InvalidPropertyValueException.MainDoc" >}}
+[PropertyNullException]: {{< url path="Cortex.Reference.Exceptions.Common.Property.PropertyNullException.MainDoc" >}}
+[InfiniteLoopErrorCode]: {{< url path="Cortex.Reference.DataTypes.Loops.InfiniteLoopErrorCode.MainDoc" >}}
+
+[What is a Collection?]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Collections.WhatIsACollection.MainDoc" >}}
+[indexes]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Collections.Indexes.MainDoc" >}}
+[Items]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Collections.Items.MainDoc" >}}
+[What is a Flow?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Flows.WhatIsAFlow.MainDoc" >}}
+[What is an Exception?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Exceptions.WhatIsAnException.MainDoc" >}}
+[flow execution]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Executions.WhatIsAnExecution.MainDoc" >}}
+[flow executions]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Executions.WhatIsAnExecution.MainDoc" >}}
+
+[Int32]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int32.MainDoc" >}}
+[IEnumerable]: {{< url path="Cortex.Reference.DataTypes.Collections.IEnumerable_TItem.MainDoc" >}}
+[List]: {{< url path="Cortex.Reference.DataTypes.Collections.List.MainDoc" >}}
+[Dictionary]: {{< url path="Cortex.Reference.DataTypes.Collections.Dictionary.MainDoc" >}}
+[Structure]: {{< url path="Cortex.Reference.DataTypes.Collections.Structure.MainDoc" >}}
+
+[Kodify What is a loop]: {{< url path="Kodify.WhatIsALoop" >}}
+[MS CSharp Main]: {{< url path="MSDocs.CSharp.MainDoc" >}}
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/_index.md b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/_index.md
index 8626ac69a..8f52b1803 100644
--- a/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/_index.md
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/_index.md
@@ -1,5 +1,5 @@
 ---
 title: "Numbers"
 linkTitle: "Numbers"
-description: "Information related to working with Numbers."
----
\ No newline at end of file
+description: "Information related to working with numbers, including numeric types, operators, conversions, parsing, and formatting."
+---
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/converting-numbers-and-text.md b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/converting-numbers-and-text.md
new file mode 100644
index 000000000..d47287259
--- /dev/null
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/converting-numbers-and-text.md
@@ -0,0 +1,163 @@
+---
+title: "Converting Numbers and Text"
+linkTitle: "Converting Numbers and Text"
+description: "How to convert numeric values to text and parse text to numbers in CORTEX using expressions, Convert methods, and blocks."
+weight: 4
+---
+
+# {{% param title %}}
+
+## Summary
+
+Flows often need to turn a number into text (logging, messages, composite formats) or turn text into a number (user input, files, external systems). In {{% ctx %}} and .NET those operations are:
+
+* **Formatting** — number → [String][] (`ToString`, `Convert.ToString`, format templates)
+* **Parsing** — [String][] → number (`Parse`, `TryParse`, `Convert.ToInt32`, and similar)
+
+Both depend on a [format provider][Number Formatting] ([CultureInfo][] / [IFormatProvider][]) when culture-sensitive decimal separators, group separators, or currency symbols matter. For patterns such as `"N2"` or `"C"`, see [Number Formatting][].
+
+For conversions **between** numeric types (not text), see [Numeric Conversions][].
+
+## Converting numbers to text
+
+### Expressions
+
+| Method | Example | Typical result | Notes |
+| --- | --- | --- | --- |
+| `ToString()` | `1.ToString()` | `"1"` | Uses [Current Culture][] when no provider is passed |
+| `ToString(format)` | `(1234.5).ToString("N2")` | Culture-dependent (for example `"1,234.50"` for `en-US`) | See [Number Formatting][] |
+| `ToString(format, provider)` | `(1234.5).ToString("N2", CultureInfo.InvariantCulture)` | `"1,234.50"` with invariant separators | Preferred for persistence |
+| `Convert.ToString` | `Convert.ToString(1)` | `"1"` | See [Convert.ToString][] |
+| String interpolation | `$"Count: {($)Count}"` | `"Count: 42"` | Implicit conversion to text; optional format: `{($)Count:N0}` |
+
+Each Numbers data type page documents `ToString` and `Convert.ToString` examples (for example [Int32][], [Double][]).
+
+### Blocks
+
+| Block | Use |
+| --- | --- |
+| [Convert Object To Text][] | Formats an object (including numbers) with an optional format template and **Format Provider** (defaults often follow [Invariant Culture][]) |
+| [Convert Object To Json][] | JSON representation of the value (numeric JSON tokens, not culture-formatted display strings) |
+| [Format Text With Values][] / [Format Text With Value][] | Composite format templates that embed numbers among other values |
+
+When **Format Provider** is omitted on these blocks, behaviour typically follows [Invariant Culture][]—not [Current Culture][]. Set the provider explicitly when you need the server locale or a [Specific Culture][].
+
+## Parsing text to numbers
+
+### Expressions
+
+| Method | Example | Notes |
+| --- | --- | --- |
+| `Int32.Parse` | `Int32.Parse("1")` | Throws if the text is invalid; culture-sensitive overloads available |
+| `Double.Parse` | `Double.Parse("1.5")` | Decimal separator must match the provider/culture |
+| `TryParse` | `Int32.TryParse("1", out result)` | Returns `false` instead of throwing on failure |
+| `Convert.ToInt32` / `Convert.ToDouble` | `Convert.ToInt32("1")` | Converts from many source types including [String][] |
+
+Without an [IFormatProvider][], many `Parse` overloads use [Current Culture][]. Text that uses `.` as the decimal separator may fail to parse under a culture that expects `,`, and the reverse. Prefer:
+
+* `Parse` / `TryParse` overloads that take [CultureInfo.InvariantCulture][Invariant Culture] for machine-readable text, or
+* An explicit [Specific Culture][] that matches the input source.
+
+For detailed .NET guidance, see [Parsing numeric strings in .NET][].
+
+### Invalid input
+
+Failed parses typically throw [FormatException][], [OverflowException][] (value outside the target range), or related exceptions. Use `TryParse` when input may be malformed and you want to branch without exception handling.
+
+## Culture and round-tripping
+
+| Scenario | Recommendation |
+| --- | --- |
+| Store or exchange numeric text between servers | [Invariant Culture][] or a fixed format (for example general `"G"` / round-trip guidance for floating point) |
+| Display to users | [Current Culture][] or [Specific Culture][] matching the audience |
+| JSON interchange | Prefer [Convert Object To Json][] / JSON parsers rather than culture-formatted display strings |
+
+Floating-point round-trip: for [Double][], Microsoft recommends `"G17"` (and `"G9"` for [Single][]) rather than relying on `"R"` in modern .NET. See [standard numeric format strings][].
+
+## Remarks
+
+### ToString() Without a Provider
+
+Expression `ToString()` without a provider follows [Current Culture][]; many formatting blocks default to [Invariant Culture][]. Mixing them can produce different decimal separators for the same value.
+
+### Parsing
+
+Parsing must use a culture consistent with how the text was produced.
+
+### Casting Text
+
+Casting text is not valid—`"(Int32)"abc""` does not parse; use `Parse` / `Convert` / blocks.
+
+### Known Limitations
+
+None
+
+## See Also
+
+### Related Concepts
+
+* [What is a Number?][] — numeric types overview
+* [Number Formatting][] — format providers, templates, and specifiers
+* [Numeric Conversions][] — converting between numeric types
+* [Culture][] — invariant, current, and specific cultures
+* [Converting Objects To Text][] — general object-to-text patterns
+* [Formatting][] — composite text formatting
+
+### Related Data Types
+
+* [Int16][]
+* [Int32][]
+* [Int64][]
+* [Single][]
+* [Double][]
+* [String][]
+* [CultureInfo][]
+* [IFormatProvider][]
+
+### Related Blocks
+
+* [Convert Object To Text][]
+* [Convert Object To Json][]
+* [Format Text With Values][]
+* [Format Text With Value][]
+
+### External Documentation
+
+* [Parsing numeric strings in .NET][]
+* [Standard numeric format strings][standard numeric format strings]
+* [Convert.ToString][]
+* [Int32.ToString][]
+* [Int32.Parse][]
+
+[What is a Number?]: {{< ref "what-is-a-number.md" >}}
+[Number Formatting]: {{< ref "number-formatting.md" >}}
+[Numeric Conversions]: {{< ref "numeric-conversions.md" >}}
+
+[Culture]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.MainDoc" >}}
+[Invariant Culture]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.InvariantCulture.MainDoc" >}}
+[Current Culture]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.CurrentCulture.MainDoc" >}}
+[Specific Culture]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.SpecificCultures.MainDoc" >}}
+[Converting Objects To Text]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Text.ConvertingObjectsToText.MainDoc" >}}
+[Formatting]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Text.Formatting.MainDoc" >}}
+
+[Int16]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int16.MainDoc" >}}
+[Int32]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int32.MainDoc" >}}
+[Int64]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int64.MainDoc" >}}
+[Single]: {{< url path="Cortex.Reference.DataTypes.Numbers.Single.MainDoc" >}}
+[Double]: {{< url path="Cortex.Reference.DataTypes.Numbers.Double.MainDoc" >}}
+[String]: {{< url path="Cortex.Reference.DataTypes.Text.String.MainDoc" >}}
+[CultureInfo]: {{< url path="Cortex.Reference.DataTypes.Text.CultureInfo.MainDoc" >}}
+[IFormatProvider]: {{< url path="Cortex.Reference.DataTypes.Text.IFormatProvider.MainDoc" >}}
+
+[Convert Object To Text]: {{< url path="Cortex.Reference.Blocks.Objects.ConvertObject.ConvertObjectToText.MainDoc" >}}
+[Convert Object To Json]: {{< url path="Cortex.Reference.Blocks.Json.ConvertJson.ConvertObjectToJson.MainDoc" >}}
+[Format Text With Values]: {{< url path="Cortex.Reference.Blocks.Text.FormatText.FormatTextWithValues.MainDoc" >}}
+[Format Text With Value]: {{< url path="Cortex.Reference.Blocks.Text.FormatText.FormatTextWithValue.MainDoc" >}}
+
+[Convert.ToString]: {{< url path="MSDocs.DotNet.Api.System.Convert.ToString" >}}
+[Int32.ToString]: {{< url path="MSDocs.DotNet.Api.System.Int32.ToString" >}}
+[Int32.Parse]: {{< url path="MSDocs.DotNet.Api.System.Int32.Parse" >}}
+[FormatException]: {{< url path="MSDocs.DotNet.Api.System.FormatException" >}}
+[OverflowException]: https://learn.microsoft.com/en-us/dotnet/api/system.overflowexception
+[Parsing numeric strings in .NET]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/parsing-numeric
+[standard numeric format strings]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/number-formatting.md b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/number-formatting.md
new file mode 100644
index 000000000..89adc82e1
--- /dev/null
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/number-formatting.md
@@ -0,0 +1,225 @@
+---
+title: "Number Formatting"
+linkTitle: "Number Formatting"
+description: "How format providers, format templates, and format specifiers control the text representation of numeric values in CORTEX flows."
+weight: 5
+---
+
+# {{% param title %}}
+
+## Summary
+
+Numeric values are often converted to and from text—for example when displaying amounts, writing logs, or reading input. In .NET and {{% ctx %}}, that conversion is controlled by:
+
+* A **format provider** — supplies culture-specific decimal separators, group sizes, and currency symbols (via [CultureInfo][] and [IFormatProvider][])
+* A **format template** — a standard or custom string that defines how the number appears
+* **Format specifiers** — the characters inside a format template (for example `N`, `C`, `0.00`)
+
+Expressions use `ToString`, `String.Format`, and interpolation. Blocks such as [Convert Object To Text][], [Format Text With Values][], and [Format Text With Value][] expose **Format Provider** (and format template) properties for explicit control.
+
+For parsing and `ToString` overview, see [Converting Numbers and Text][]. For culture types in general, see [Culture][].
+
+| Topic | Typical choice |
+| --- | --- |
+| Cross-server persistence and block defaults | [Invariant Culture][] |
+| Server-local presentation in expressions | [Current Culture][] |
+| Fixed regional format for users | [Specific Culture][] (for example `new CultureInfo("en-GB")`) |
+| Fixed decimal places without culture surprises | Explicit standard specifier with an explicit provider (for example `"F2"` + invariant) |
+
+## Format providers
+
+A **format provider** implements [IFormatProvider][] and supplies the cultural rules used when a number is formatted or parsed. In practice the provider is almost always a [CultureInfo][] whose `NumberFormat` property defines decimal and group separators, currency symbols, and percent patterns.
+
+Pass a format provider to:
+
+* Block properties named **Format Provider** on [Convert Object To Text][], [Format Text With Values][], and [Format Text With Value][]
+* .NET methods such as `ToString(string, IFormatProvider)`, `Int32.Parse(string, IFormatProvider)`, and `String.Format(IFormatProvider, string, object[])`
+
+### Obtaining a format provider
+
+| Approach | Expression | Notes |
+| --- | --- | --- |
+| Invariant culture | `CultureInfo.InvariantCulture` | Culture-insensitive; fixed patterns. See [Invariant Culture][] |
+| Empty culture name | `new CultureInfo("")` | Equivalent to the invariant culture |
+| Current culture | `CultureInfo.CurrentCulture` | Reflects the server's regional settings. See [Current Culture][] |
+| Specific culture | `new CultureInfo("en-GB")` | Fixed locale regardless of server settings. See [Specific Cultures][] |
+
+### Invariant Culture
+
+When [Invariant Culture][] is used as the format provider:
+
+* Decimal separator is `.` and group separator is `,` for standard number patterns.
+* Currency and percent symbols follow invariant `NumberFormatInfo` rules, not the server's locale.
+* Many {{% ctx %}} formatting blocks default **Format Provider** to `CultureInfo.InvariantCulture` when the property is omitted or `null`.
+
+Use invariant formatting when numeric text must parse the same on every server.
+
+### Current Culture
+
+[Current Culture][] (`CultureInfo.CurrentCulture`) supplies number patterns from the **server's configured locale**. Expression calls such as `1234.5.ToString("N")` without a provider use these rules. On Windows, patterns can reflect **Control Panel** regional customizations when they apply to `CurrentCulture`.
+
+{{% ctx %}} blocks do **not** automatically use the current culture when **Format Provider** is omitted; they typically default to [Invariant Culture][]. To format using the server's locale in a block, set **Format Provider** explicitly to `CultureInfo.CurrentCulture`.
+
+## Format templates
+
+**Format templates** define how numeric values become text. There are two kinds:
+
+* [Standard format templates](#standard-format-templates) — a **single** alphabetic format specifier, optionally followed by a precision digit string (for example `"N"`, `"N2"`, `"C"`)
+* [Custom format templates](#custom-format-templates) — patterns with placeholders such as `0`, `#`, `.`, `,` (for example `"0.00"`, `"#,##0.00"`)
+
+A format template is always interpreted together with a format provider. The provider determines which separators and symbols appear.
+
+| Scenario | Format template | Format provider | Behaviour |
+| --- | --- | --- | --- |
+| Expression `ToString()` | none | [Current Culture][] | Culture's general number pattern |
+| Expression with explicit format | `"N2"` | `CultureInfo.InvariantCulture` | Fixed 2 decimal places, invariant separators |
+| [Convert Object To Text][] / format text blocks | template in property | Often invariant when null | See each block's remarks |
+
+### Standard format templates
+
+A standard numeric format string has the form `[specifier][precision]`, where precision is optional. Examples below use value `1234.567` and culture `en-GB` unless noted.
+
+| Specifier | Name | Example (`en-GB`) | Notes |
+| --- | --- | --- | --- |
+| `C` or `c` | Currency | `£1,234.57` | Precision = decimal digits; symbols from culture |
+| `D` or `d` | Decimal | Integrals only — `1234` → `1234`; `D6` → `001234` | Not valid for [Single][] / [Double][] |
+| `E` or `e` | Exponential | `1.234567E+003` | Precision = digits after decimal in mantissa |
+| `F` or `f` | Fixed-point | `1234.57` | Precision = decimal places |
+| `G` or `g` | General | Compact fixed or scientific | Default precision depends on type |
+| `N` or `n` | Number | `1,234.57` | Group separators + decimal places |
+| `P` or `p` | Percent | Multiplies by 100 and adds `%` | For example `1` → `100.00%` in `en-US` |
+| `X` or `x` | Hexadecimal | Integrals only — `255` → `FF` | Case selects `A–F` vs `a–f` |
+| `R` or `r` | Round-trip | Round-trippable text for floating point | Prefer `"G17"` / `"G9"` for [Double][] / [Single][] in modern .NET |
+| `B` or `b` | Binary | Integrals only (.NET 8+) | Binary digit string |
+
+An unknown single-character specifier throws [FormatException][]. Full details and more examples: [standard numeric format strings][].
+
+### Custom format templates
+
+Custom templates use digit placeholders and separators:
+
+| Character | Meaning |
+| --- | --- |
+| `0` | Mandatory digit (pads with zeros) |
+| `#` | Optional digit |
+| `.` | Decimal separator (replaced by the culture's decimal separator) |
+| `,` | Group separator or scaling (culture-sensitive) |
+| `%` | Multiplies by 100 and inserts a percent symbol |
+| `\` or quoted literals | Escape a character so it appears as literal text |
+
+Examples with invariant culture and value `1234.5`:
+
+| Template | Result |
+| --- | --- |
+| `0.00` | `1234.50` |
+| `#,##0.00` | `1,234.50` |
+| `0` | `1235` (rounded to integer digits per formatting rules) |
+
+For the full custom syntax, see [custom numeric format strings][].
+
+## Format specifiers in composite formatting
+
+In `String.Format`, [Format Text With Values][], and interpolated strings, a format item can include a numeric format string after a colon:
+
+| Expression or template | Example meaning |
+| --- | --- |
+| `{0:N2}` | First argument as number with 2 decimal places |
+| `{($)Amount:C}` | Interpolated currency format |
+| `{0,10:F2}` | Width 10, right-aligned, fixed 2 decimals |
+
+Composite formatting also controls alignment and spacing. See [Formatting][] (text) and [composite formatting][] in .NET documentation.
+
+## Operating system and culture effects
+
+Standard specifiers such as `N` and `C` resolve against the format provider's `NumberFormatInfo`. Changing the server's region or Control Panel number settings can change results for [Current Culture][]. For consistent output across nodes, use [Invariant Culture][] or an explicit [Specific Culture][]. See [Current Culture][] and [Invariant Culture][].
+
+## Remarks
+
+### Culture Dependency
+
+Formatting and parsing depend on cultures installed on the server. An invalid culture name throws [CultureInfoNotFoundException][].
+
+### Invalid Specifiers Cause Exceptions
+
+Specifiers valid only for integrals (`D`, `X`, `B`) throw if used with [Single][] or [Double][].
+
+### Floating-Point Rounding
+
+Floating-point display can show rounding relative to the infinite-precision value; precision specifiers control the **string**, not a separate stored rounded value.
+
+### Block Defaults for Format Provider
+
+Block defaults for **Format Provider** may differ from expression `ToString()` defaults; align them deliberately. See [Converting Numbers and Text][].
+
+### Known Limitations
+
+None
+
+## See Also
+
+### Related Concepts
+
+* [What is a Number?][] — numeric types overview
+* [Converting Numbers and Text][] — `ToString`, `Parse`, and blocks
+* [Culture][] — culture types and when to use each
+* [Invariant Culture][] — culture-insensitive formatting defaults
+* [Current Culture][] — server regional settings
+* [Specific Cultures][] — fixed locale formatting
+* [Formatting][] — composite text formatting with format providers
+* [Date and Time Formatting][] — parallel concepts for dates and times
+
+### Related Data Types
+
+* [Int16][]
+* [Int32][]
+* [Int64][]
+* [Single][]
+* [Double][]
+* [CultureInfo][]
+* [IFormatProvider][]
+
+### Related Blocks
+
+* [Convert Object To Text][]
+* [Format Text With Values][]
+* [Format Text With Value][]
+* [Convert Object To Json][]
+
+### External Documentation
+
+* [Standard numeric format strings][]
+* [Custom numeric format strings][]
+* [Parsing numeric strings in .NET][]
+* [Composite formatting][]
+* [NumberFormatInfo](https://learn.microsoft.com/en-us/dotnet/api/system.globalization.numberformatinfo)
+
+[What is a Number?]: {{< ref "what-is-a-number.md" >}}
+[Converting Numbers and Text]: {{< ref "converting-numbers-and-text.md" >}}
+
+[Culture]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.MainDoc" >}}
+[Invariant Culture]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.InvariantCulture.MainDoc" >}}
+[Current Culture]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.CurrentCulture.MainDoc" >}}
+[Specific Cultures]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.SpecificCultures.MainDoc" >}}
+[Specific Culture]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.SpecificCultures.MainDoc" >}}
+[Formatting]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Text.Formatting.MainDoc" >}}
+[Date and Time Formatting]: {{< url path="Cortex.Reference.Concepts.WorkingWith.DateAndTime.DateAndTimeFormatting.MainDoc" >}}
+
+[Int16]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int16.MainDoc" >}}
+[Int32]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int32.MainDoc" >}}
+[Int64]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int64.MainDoc" >}}
+[Single]: {{< url path="Cortex.Reference.DataTypes.Numbers.Single.MainDoc" >}}
+[Double]: {{< url path="Cortex.Reference.DataTypes.Numbers.Double.MainDoc" >}}
+[CultureInfo]: {{< url path="Cortex.Reference.DataTypes.Text.CultureInfo.MainDoc" >}}
+[IFormatProvider]: {{< url path="Cortex.Reference.DataTypes.Text.IFormatProvider.MainDoc" >}}
+[CultureInfoNotFoundException]: {{< url path="MSDocs.DotNet.Api.System.Globalization.CultureInfoNotFoundException" >}}
+[FormatException]: {{< url path="MSDocs.DotNet.Api.System.FormatException" >}}
+
+[Convert Object To Text]: {{< url path="Cortex.Reference.Blocks.Objects.ConvertObject.ConvertObjectToText.MainDoc" >}}
+[Convert Object To Json]: {{< url path="Cortex.Reference.Blocks.Json.ConvertJson.ConvertObjectToJson.MainDoc" >}}
+[Format Text With Values]: {{< url path="Cortex.Reference.Blocks.Text.FormatText.FormatTextWithValues.MainDoc" >}}
+[Format Text With Value]: {{< url path="Cortex.Reference.Blocks.Text.FormatText.FormatTextWithValue.MainDoc" >}}
+
+[standard numeric format strings]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings
+[custom numeric format strings]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/custom-numeric-format-strings
+[Parsing numeric strings in .NET]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/parsing-numeric
+[composite formatting]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/composite-formatting
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/numeric-conversions.md b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/numeric-conversions.md
new file mode 100644
index 000000000..aedd4a715
--- /dev/null
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/numeric-conversions.md
@@ -0,0 +1,138 @@
+---
+title: "Numeric Conversions"
+linkTitle: "Numeric Conversions"
+description: "How to convert between numeric types in CORTEX using implicit casts, explicit casts, and Convert methods, including data loss when narrowing."
+weight: 3
+---
+
+# {{% param title %}}
+
+## Summary
+
+Numeric values often move between types—for example using an [Int32][] where a [Double][] is expected, or truncating a [Double][] to an [Int32][]. In {{% ctx %}}, those conversions use the same rules as C# [built-in numeric conversions][]:
+
+* **Implicit** conversions widen a value when the target type can represent every value of the source type (no cast syntax required).
+* **Explicit** conversions narrow or otherwise risk data loss and require cast syntax `(TargetType)expression`.
+
+Each Numbers data type page lists **Can be used as** (implicit) and **Can be cast to** (explicit, with range limits). For the general casting model in flows, see [Object Casting][].
+
+Converting to or from **text** is different (parsing and formatting). See [Converting Numbers and Text][] and [Number Formatting][].
+
+## Implicit conversions
+
+An [implicit cast][] happens automatically when no information is lost. Typical **widening** paths among documented types include:
+
+| From | To (examples) |
+| --- | --- |
+| [Int16][] | [Int32][], [Int64][], [Single][], [Double][] |
+| [Int32][] | [Int64][], [Single][], [Double][] |
+| [Int64][] | [Single][], [Double][] |
+| [Single][] | [Double][] |
+
+Example: an [Int32][] variable can be passed to a [block property][] of type [Double][] without writing a cast. In expressions, integrals mixed with [Double][] are promoted according to C# conversion rules before arithmetic runs.
+
+```csharp
+// ($)Int is Int32 with value 6
+// Result is Double 6.0 when used where Double is expected
+($)Int
+```
+
+See [Implicit Conversions][].
+
+## Explicit conversions
+
+An [explicit cast][] uses `(TargetType)expression` when the conversion may lose magnitude, precision, or fractional digits, or when recovering a specific type from [Object][].
+
+| Expression | Result | Notes |
+| --- | --- | --- |
+| `(Int16)($)Int` where `($)Int` is `6` | `6` | Valid when the value is in the [Int16][] range |
+| `(Int32)1.9` | `1` | Fractional part truncated toward zero |
+| `(Int32)2147483648.0` | `0` if `unchecked` / overflow if `checked` | Value outside [Int32][] range |
+| `(Single)($)DoubleVariable` | May lose precision | [Double][] to [Single][] narrows precision |
+
+### Data loss when converting floating point to integer
+
+Casting [Single][] or [Double][] to an integral type:
+
+* Discards the **fractional** part (truncates toward zero)—`(Int32)3.9` is `3`, `(Int32)(-3.9)` is `-3`.
+* Can overflow if the integral part is outside the target type's range; behaviour follows [checked and unchecked][] rules for the conversion.
+
+Do not rely on floating-point-to-integer casts for financial rounding; use `Math.Round`, `Math.Floor`, or `Math.Ceiling` when you need a defined rounding mode, then cast if required.
+
+### Converting with Convert
+
+`System.Convert` methods (`Convert.ToInt32`, `Convert.ToDouble`, and so on) convert between many types, including from [String][]. They apply their own rounding and overflow rules. Prefer documenting the specific overload you use; see [Convert Class][].
+
+Casting and `Convert` are not identical—for fractional doubles, `(Int32)value` truncates, while `Convert.ToInt32(value)` rounds.
+
+## Choosing a conversion approach
+
+| Goal | Approach |
+| --- | --- |
+| Widen safely (for example [Int32][] → [Double][]) | Implicit cast / assign or pass without syntax |
+| Narrow or truncate (for example [Double][] → [Int32][]) | Explicit cast `(Int32)value` |
+| Convert via .NET conversion rules including from text | `Convert.To…` methods |
+| Parse text that represents a number | `Int32.Parse`, `Double.TryParse`, and so on — see [Converting Numbers and Text][] |
+
+## Remarks
+
+### Known Limitations
+
+* Floating-point widening ([Single][] → [Double][]) preserves the value but does not create more precision than the original [Single][] had.
+* Recovering a number stored as [Object][] requires an explicit cast to the concrete numeric type. Values typed as [dynamic][] usually do not need a cast for member access. See [Object Casting][].
+
+## See Also
+
+### Related Concepts
+
+* [What is a Number?][] — numeric types overview
+* [Object Casting][] — implicit vs explicit casting in flows
+* [Operators and Comparisons][] — how conversions interact with arithmetic
+* [Converting Numbers and Text][] — text parsing and formatting
+
+### Related Data Types
+
+* [Int16][]
+* [Int32][]
+* [Int64][]
+* [Single][]
+* [Double][]
+* [Object][]
+* [dynamic][]
+
+### Related Blocks
+
+* None specific — conversions are performed in expressions or when binding variables to [block properties][block property]
+
+### External Documentation
+
+* [Built-in numeric conversions (C# reference)][built-in numeric conversions]
+* [Casting and type conversions (C# Programming Guide)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/types/casting-and-type-conversions)
+* [Implicit conversions][Implicit Conversions]
+* [Explicit conversions][Explicit Conversions]
+* [Convert Class][]
+
+[What is a Number?]: {{< ref "what-is-a-number.md" >}}
+[Operators and Comparisons]: {{< ref "operators-and-comparisons.md" >}}
+[Converting Numbers and Text]: {{< ref "converting-numbers-and-text.md" >}}
+[Number Formatting]: {{< ref "number-formatting.md" >}}
+
+[Object Casting]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Objects.ObjectCasting.MainDoc" >}}
+[implicit cast]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Objects.ObjectCasting.ImplicitCast" >}}
+[explicit cast]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Objects.ObjectCasting.ExplicitCast" >}}
+[block property]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.WhatIsABlockProperty.MainDoc" >}}
+
+[Int16]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int16.MainDoc" >}}
+[Int32]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int32.MainDoc" >}}
+[Int64]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int64.MainDoc" >}}
+[Single]: {{< url path="Cortex.Reference.DataTypes.Numbers.Single.MainDoc" >}}
+[Double]: {{< url path="Cortex.Reference.DataTypes.Numbers.Double.MainDoc" >}}
+[Object]: {{< url path="Cortex.Reference.DataTypes.All.Object.MainDoc" >}}
+[dynamic]: {{< url path="Cortex.Reference.DataTypes.All.dynamic.MainDoc" >}}
+[String]: {{< url path="Cortex.Reference.DataTypes.Text.String.MainDoc" >}}
+
+[Implicit Conversions]: {{< url path="MSDocs.CSharp.ImplicitConversions" >}}
+[Explicit Conversions]: {{< url path="MSDocs.CSharp.ExplicitConversions" >}}
+[built-in numeric conversions]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/numeric-conversions
+[checked and unchecked]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/checked-and-unchecked
+[Convert Class]: https://learn.microsoft.com/en-us/dotnet/api/system.convert
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/operators-and-comparisons.md b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/operators-and-comparisons.md
new file mode 100644
index 000000000..774534720
--- /dev/null
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/operators-and-comparisons.md
@@ -0,0 +1,154 @@
+---
+title: "Operators and Comparisons"
+linkTitle: "Operators and Comparisons"
+description: "How arithmetic and comparison operators behave for numeric types in CORTEX expressions, including integer division, overflow, and floating-point caveats."
+weight: 2
+---
+
+# {{% param title %}}
+
+## Summary
+
+Numeric values in {{% ctx %}} are combined and compared in the [Expression Editor][] using C# [operators][]. Arithmetic operators (`+`, `-`, `*`, `/`, `%`) produce a new numeric value. Comparison and equality operators (`==`, `!=`, `<`, `>`, `<=`, `>=`) produce a [Boolean][] result.
+
+Operator evaluation follows C# rules for precedence and associativity. Use parentheses to make order explicit—for example `(a + b) * c` versus `a + b * c`.
+
+For an overview of numeric types, see [What is a Number?][]. For casting between types during arithmetic, see [Numeric Conversions][].
+
+## Arithmetic operators
+
+| Operator | Name | Example | Result when `($)Int1` is `6` and `($)Int2` is `3` |
+| --- | --- | --- | --- |
+| `+` | Addition | `($)Int1 + ($)Int2` | `9` |
+| `-` | Subtraction | `($)Int1 - ($)Int2` | `3` |
+| `*` | Multiplication | `($)Int1 * ($)Int2` | `18` |
+| `/` | Division | `($)Int1 / ($)Int2` | `2` |
+| `%` | Remainder | `($)Int1 % ($)Int2` | `0` |
+
+Unary `-` negates a value (for example `-($)Int1`). For full language details, see [Arithmetic Operators][].
+
+### Integer division
+
+When **both** operands of `/` are integer types ([Int16][], [Int32][], [Int64][], and so on), the result is an **integer**. The fractional part is discarded toward zero.
+
+| Expression | Result | Notes |
+| --- | --- | --- |
+| `3 / 2` | `1` | Both operands are integers |
+| `3.0 / 2` | `1.5` | At least one operand is floating point |
+| `3 / 2.0` | `1.5` | At least one operand is floating point |
+| `(double)3 / 2` | `1.5` | Explicit cast widens before division |
+
+If you need a fractional quotient, ensure at least one operand is [Single][] or [Double][] (by literal suffix, cast, or variable type).
+
+### Division by zero
+
+* **Integer** (and `decimal`) division by zero throws [DivideByZeroException][].
+* **Floating-point** division by zero does not throw; IEEE 754 rules produce positive infinity, negative infinity, or NaN depending on the numerator.
+
+### Order of operations
+
+C# evaluates arithmetic with standard precedence: multiplicative operators (`*`, `/`, `%`) bind more tightly than additive operators (`+`, `-`). Operators with the same precedence usually associate left to right.
+
+| Expression | Evaluates as | Result |
+| --- | --- | --- |
+| `2 + 3 * 4` | `2 + (3 * 4)` | `14` |
+| `(2 + 3) * 4` | parentheses first | `20` |
+| `10 - 4 - 2` | `(10 - 4) - 2` | `4` |
+
+For the complete precedence table, see [C# operators and expressions — operator precedence][Operator precedence].
+
+## Overflow and underflow
+
+Integral arithmetic can produce a result that does not fit in the destination type (for example `Int32.MaxValue + 1`). Behaviour depends on the C# **checked** or **unchecked** context:
+
+| Context | On overflow |
+| --- | --- |
+| Unchecked | High-order bits discarded; the value wraps (for example past `MaxValue` toward `MinValue`) |
+| Checked (default behaviour in {{% ctx %}}) | [OverflowException][] is thrown at run time (or a compile-time error for overflowing constant expressions) |
+
+You can force a context with the `checked(...)` and `unchecked(...)` operators or statements. See [checked and unchecked][].
+
+Floating-point overflow produces infinity rather than wrapping; underflow can produce denormalized values or zero. Those cases do not throw in ordinary arithmetic.
+
+## Comparison and equality operators
+
+| Operator | Meaning | Example result (`1` vs `2`) |
+| --- | --- | --- |
+| `==` | Equal | `false` |
+| `!=` | Not equal | `true` |
+| `<` | Less than | `true` |
+| `>` | Greater than | `false` |
+| `<=` | Less than or equal | `true` |
+| `>=` | Greater than or equal | `false` |
+
+Integral comparisons are exact within the type's range. For mixed numeric types, C# applies [built-in numeric conversions][] before comparing.
+
+For how value equality relates to objects and collections, see [Object Equality][].
+
+### Floating-point comparisons
+
+[Single][] and [Double][] values can disagree because of rounding. Prefer an epsilon (tolerance) check when comparing calculated reals, or compare formatted text only when you intentionally want culture-sensitive string equality.
+
+Special values:
+
+* `NaN == NaN` is `false`. Use `Double.IsNaN` / `Single.IsNaN` to test.
+* Comparisons involving NaN are unordered (`>` / `<` are `false`).
+
+## Remarks
+
+### Known Limitations
+
+* Default overflow behaviour in {{% ctx %}} is **checked** and an [OverflowException][] is thrown unless you use `unchecked`.
+
+## See Also
+
+### Related Concepts
+
+* [What is a Number?][] — numeric types and literals
+* [Numeric Conversions][] — widening, narrowing, and casts during arithmetic
+* [Object Equality][] — equality beyond numeric operators
+* [Expression Editor][] — arithmetic and comparison expression examples
+
+### Related Data Types
+
+* [Int16][]
+* [Int32][]
+* [Int64][]
+* [Single][]
+* [Double][]
+* [Boolean][]
+
+### Related Blocks
+
+* None specific — numeric operators are used in expressions on block properties
+
+### External Documentation
+
+* [Arithmetic operators (C# reference)][Arithmetic Operators]
+* [Comparison operators (C# reference)][Comparison Operators]
+* [Equality operators (C# reference)][Equality Operators]
+* [checked and unchecked statements (C# reference)][checked and unchecked]
+* [Operator precedence][Operator precedence]
+
+[What is a Number?]: {{< ref "what-is-a-number.md" >}}
+[Numeric Conversions]: {{< ref "numeric-conversions.md" >}}
+
+[Expression Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.ExpressionEditor.MainDoc" >}}
+[Object Equality]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Objects.ObjectEquality.MainDoc" >}}
+
+[Int16]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int16.MainDoc" >}}
+[Int32]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int32.MainDoc" >}}
+[Int64]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int64.MainDoc" >}}
+[Single]: {{< url path="Cortex.Reference.DataTypes.Numbers.Single.MainDoc" >}}
+[Double]: {{< url path="Cortex.Reference.DataTypes.Numbers.Double.MainDoc" >}}
+[Boolean]: {{< url path="Cortex.Reference.DataTypes.ConditionalLogic.Boolean.MainDoc" >}}
+
+[operators]: {{< url path="Cortex.Reference.Glossary.K-O.Operator" >}}
+[Arithmetic Operators]: {{< url path="MSDocs.CSharp.ArithmeticOperators" >}}
+[Comparison Operators]: {{< url path="MSDocs.CSharp.ComparisonOperators" >}}
+[Equality Operators]: {{< url path="MSDocs.CSharp.EqualityOperators" >}}
+[DivideByZeroException]: https://learn.microsoft.com/en-us/dotnet/api/system.dividebyzeroexception
+[OverflowException]: https://learn.microsoft.com/en-us/dotnet/api/system.overflowexception
+[checked and unchecked]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/checked-and-unchecked
+[Operator precedence]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/#operator-precedence
+[built-in numeric conversions]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/numeric-conversions
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/what-is-a-number.md b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/what-is-a-number.md
index 606454bad..4e562e178 100644
--- a/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/what-is-a-number.md
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/numbers/what-is-a-number.md
@@ -1,68 +1,144 @@
 ---
 title: "What is a Number?"
 linkTitle: "What is a Number?"
-description: "Information regarding what a number is."
+description: "Overview of numeric data types in CORTEX, including integer and floating-point types, literals, and how to work with numbers in flows and expressions."
 weight: 1
 ---
 
 # {{% param title %}}
 
-{{< workinprogress >}}
-
 ## Summary
 
-TODO:
-
-- What is a number
-- Types of numbers
-  - Integer Types
-    - int, long, etc
-    - unsigned numbers
-    - suffixes
-  - Floating Point Types
-    - float, double, decimal
-    - suffixes
-- Operators and Comparisons
-  - Order of operation
-  - Integer division will result in an integer, not a Floating Point number (e.g. `3 / 2` results in `1`)
-  - Underflow/Overflow conditions
-- Converting numbers to text
-  - using blocks
-  - ToString()
-  - https://learn.microsoft.com/en-us/dotnet/standard/base-types/parsing-numeric
-- Converting Integer Types to Floating Types (and reverse)
-  - Built in numeric conversion - https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/numeric-conversions
-  - https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/conversions#1023-implicit-numeric-conversions
-  - Data loss when converting from Floating Types to Integer Types
-- Numeric Formatting
-  - Format providers
-    - Invariant Culture
-    - Current Culture
-  - Format Templates
-    - Standard Format Templates - https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings
-    - Custom Format Templates - https://learn.microsoft.com/en-us/dotnet/standard/base-types/custom-numeric-format-strings
-  - Format specifiers
+Numbers in {{% ctx %}} are represented by .NET numeric [data types][]. The documented **Numbers** types are signed integers ([Int16][], [Int32][], [Int64][]) and floating-point values ([Single][], [Double][]). They are [value types][]: each has a default of `0`, and values are copied when assigned or passed.
+
+Most flow examples and block properties that need a whole number use [Int32][]. Use [Int64][] for values outside the 32-bit range, [Single][] or [Double][] for fractional values, and [Int16][] when a smaller integral range is required.
+
+How numbers are formatted and parsed as text depends on [culture][Culture] settings. For format patterns and providers, see [Number Formatting][]. For arithmetic and comparison behaviour, see [Operators and Comparisons][]. For casting between numeric types, see [Numeric Conversions][].
+
+| Data type | Alias | Purpose | Size | Range (approximate) |
+| --- | --- | --- | --- | --- |
+| [Int16][] | `short` | Small whole number | 2 bytes | `-32,768` through `32,767` |
+| [Int32][] | `int` | Typical whole number | 4 bytes | `-2,147,483,648` through `2,147,483,647` |
+| [Int64][] | `long` | Large whole number | 8 bytes | `-9,223,372,036,854,775,808` through `9,223,372,036,854,775,807` |
+| [Single][] | `float` | Single-precision floating point | 4 bytes | About `±3.4 × 10³⁸` (~6–9 digits of precision) |
+| [Double][] | `double` | Double-precision floating point | 8 bytes | About `±1.7 × 10³⁰⁸` (~15–17 digits of precision) |
+
+## Integer types
+
+[Int16][], [Int32][], and [Int64][] store **whole numbers** (no fractional part). Each type has `MinValue` and `MaxValue` constants. Unsigned integrals (`byte`, `uint`, `ulong`, and so on) exist in C# and .NET but are not the primary documented Numbers types in {{% ctx %}}; prefer the signed types listed above unless an expression or API specifically requires an unsigned type.
+
+### Literals and suffixes
+
+In the [Expression Editor][]:
+
+* An integer literal within the [Int32][] range is typed as `Int32` (for example `1234`).
+* A literal outside that range, or one with the `L` / `l` suffix, is typed as [Int64][] (for example `2147483648` or `1234L`). Prefer `L` over `l` to avoid confusion with the digit `1`.
+* [Int16][] values are typically created by casting or parsing (for example `(Int16)100` or `Int16.Parse("100")`).
+
+For full C# rules on decimal, hexadecimal (`0x`), and binary (`0b`) integer literals, see [Integer numeric types][] and [Integer Literals][].
+
+## Floating-point types
+
+[Single][] (`float`) and [Double][] (`double`) store **real numbers**, including fractional values. They follow IEEE 754 binary floating-point rules: not every decimal fraction has an exact representation, and special values such as NaN and infinity exist for [Double][] and [Single][].
+
+C# also defines `decimal` (`System.Decimal`) for high-precision decimal arithmetic (often used for currency). It is a .NET type available in expressions where supported, but it is not listed among the {{% ctx %}} Numbers data type reference pages. Prefer [Double][] for general fractional work in flows unless you specifically need `decimal` precision.
+
+### Literals and suffixes
+
+In the [Expression Editor][]:
+
+* A real literal without a suffix (or with `d` / `D`) is typed as [Double][] (for example `1234.456` or `1234.456d`).
+* A real literal with the `f` / `F` suffix is typed as [Single][] (for example `1234.456f`).
+
+Scientific notation such as `0.42e2` is supported for real literals. See [Floating-point numeric types][] and [Real Literals][].
+
+## Choosing a numeric type
+
+| Need | Typical choice |
+| --- | --- |
+| Counts, indexes, loop counters, whole quantities | [Int32][] |
+| Values that may exceed ±2,147,483,647 | [Int64][] |
+| Compact whole numbers in a small range | [Int16][] |
+| General fractional values or mixed arithmetic with reals | [Double][] |
+| Memory-sensitive single-precision values | [Single][] |
+
+Check each type's **Can be used as** and **Can be cast to** rows for widening and narrowing rules. See [Numeric Conversions][] and [Object Casting][].
+
+## Working with numbers in flows
+
+Numbers appear throughout flows:
+
+* As [variable][] values and [block property][] inputs and outputs (for example list indexes of type [Int32][]).
+* In [expressions][] using arithmetic (`+`, `-`, `*`, `/`, `%`) and comparison operators. See [Operators and Comparisons][] and the [Expression Editor][].
+* When converting to or from text with `ToString`, `Parse`, `Convert`, or blocks such as [Convert Object To Text][]. See [Converting Numbers and Text][] and [Number Formatting][].
 
 ## Remarks
 
 ### Known Limitations
 
-TODO
+None
 
 ## See Also
 
 ### Related Concepts
 
-TODO
+* [Operators and Comparisons][] — arithmetic, integer division, overflow, and comparisons
+* [Numeric Conversions][] — casting and converting between numeric types
+* [Converting Numbers and Text][] — parsing and string conversion
+* [Number Formatting][] — format providers, templates, and specifiers
+* [Object Casting][] — implicit and explicit casts
+* [Culture][] — how regional settings affect numeric format and parse patterns
 
 ### Related Data Types
 
-TODO
+* [Int16][]
+* [Int32][]
+* [Int64][]
+* [Single][]
+* [Double][]
 
 ### Related Blocks
 
-TODO
+* [Convert Object To Text][]
+* [Convert Object To Json][]
+* [Format Text With Values][]
+* [Format Text With Value][]
 
 ### External Documentation
 
-TODO
+* [Integer numeric types (C# reference)][Integer numeric types]
+* [Floating-point numeric types (C# reference)][Floating-point numeric types]
+* [Built-in numeric conversions (C# reference)](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/numeric-conversions)
+* [Standard numeric format strings](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings)
+* [Parsing numeric strings in .NET](https://learn.microsoft.com/en-us/dotnet/standard/base-types/parsing-numeric)
+
+[Operators and Comparisons]: {{< ref "operators-and-comparisons.md" >}}
+[Numeric Conversions]: {{< ref "numeric-conversions.md" >}}
+[Converting Numbers and Text]: {{< ref "converting-numbers-and-text.md" >}}
+[Number Formatting]: {{< ref "number-formatting.md" >}}
+
+[data types]: {{< url path="Cortex.Reference.Concepts.Fundamentals.DataTypes.MainDoc" >}}
+[value types]: {{< url path="Cortex.Reference.Concepts.Fundamentals.DataTypes.WhatIsADataType.ValueTypes" >}}
+[variable]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.WhatIsAVariable.MainDoc" >}}
+[block property]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.WhatIsABlockProperty.MainDoc" >}}
+[expressions]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.ExpressionEditor.MainDoc" >}}
+[Expression Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.ExpressionEditor.MainDoc" >}}
+
+[Object Casting]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Objects.ObjectCasting.MainDoc" >}}
+[Culture]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Culture.MainDoc" >}}
+
+[Int16]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int16.MainDoc" >}}
+[Int32]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int32.MainDoc" >}}
+[Int64]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int64.MainDoc" >}}
+[Single]: {{< url path="Cortex.Reference.DataTypes.Numbers.Single.MainDoc" >}}
+[Double]: {{< url path="Cortex.Reference.DataTypes.Numbers.Double.MainDoc" >}}
+
+[Convert Object To Text]: {{< url path="Cortex.Reference.Blocks.Objects.ConvertObject.ConvertObjectToText.MainDoc" >}}
+[Convert Object To Json]: {{< url path="Cortex.Reference.Blocks.Json.ConvertJson.ConvertObjectToJson.MainDoc" >}}
+[Format Text With Values]: {{< url path="Cortex.Reference.Blocks.Text.FormatText.FormatTextWithValues.MainDoc" >}}
+[Format Text With Value]: {{< url path="Cortex.Reference.Blocks.Text.FormatText.FormatTextWithValue.MainDoc" >}}
+
+[Integer Literals]: {{< url path="MSDocs.CSharp.IntegerLiterals" >}}
+[Real Literals]: {{< url path="MSDocs.CSharp.RealLiterals" >}}
+[Integer numeric types]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/integral-numeric-types
+[Floating-point numeric types]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/floating-point-numeric-types
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/_index.md b/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/_index.md
index 9a6db7afd..f3998a17b 100644
--- a/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/_index.md
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/_index.md
@@ -1,5 +1,5 @@
 ---
 title: "Scopes"
 linkTitle: "Scopes"
-description: "Information related to working with Scopes."
+description: "Information related to working with scopes, including resource scopes and variable scopes."
 ---
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/resource-scopes.md b/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/resource-scopes.md
new file mode 100644
index 000000000..591194547
--- /dev/null
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/resource-scopes.md
@@ -0,0 +1,205 @@
+---
+title: "Resource Scopes"
+linkTitle: "Resource Scopes"
+description: "How ScopeDefinition, ScopeOption, and Scope isolate shared CORTEX resources such as data storage collections and semaphores by Tenant, System, Package, and Flow."
+weight: 2
+---
+
+# {{% param title %}}
+
+## Summary
+
+A **resource scope** defines which area of the platform shares a named resource. You declare the intended sharing with a [ScopeDefinition][]; at runtime that definition resolves to a [Scope][] whose properties are the concrete Tenant, System, Package, and Flow string values an action is restricted to.
+
+Resource scopes are a {{% ctx %}} platform concept. They are represented by the [ScopeDefinition][], [ScopeOption][], and [Scope][] data types — not by a single .NET type. Use them when configuring shared resources such as [data storage collections][] ([Collection Scope][]) and [semaphores][] ([Scope][Semaphore Scope] on [SemaphoreSettings][]).
+
+For how this differs from [variable scopes][], see [What is a Scope?][].
+
+| Term | Role |
+| --- | --- |
+| [ScopeDefinition][] | Intent: for each level, use [ScopeOption.Current][ScopeOption] or [ScopeOption.All][ScopeOption] |
+| [ScopeOption][] | Per-level choice: `All` (`0`) or `Current` (`1`) |
+| [Scope][] | Resolved identity: Tenant, System, Package, and Flow as strings |
+
+## Scope levels
+
+A [ScopeDefinition][] and the resolved [Scope][] use these levels:
+
+| Level | Meaning |
+| --- | --- |
+| Tenant | Restricts (or shares across) the tenant |
+| System | Restricts (or shares across) the system |
+| Package | Restricts (or shares across) the [package][] |
+| Flow | Restricts (or shares across) the [flow][] |
+
+Additional levels — Environment and PackageVersion — are planned for future releases.
+
+On [ScopeDefinition][], each level is a [ScopeOption][]. On [Scope][], each level is a [String][].
+
+## ScopeOption.Current and ScopeOption.All
+
+| Value | Int32 | Effect on a level |
+| --- | --- | --- |
+| `ScopeOption.All` | `0` | Restricts that level to a unique "All" value so the resource can be shared across every value at that level |
+| `ScopeOption.Current` | `1` | Restricts that level to its current value (for example the current tenant) |
+
+### Examples
+
+| Definition (Tenant / System / Package / Flow) | Typical sharing |
+| --- | --- |
+| `Current` / `Current` / `Current` / `All` | Shared across flows in the current tenant, system, and package (default for collection and semaphore scope properties) |
+| `Current` / `Current` / `All` / `All` | Shared across packages and flows in the current tenant and system (see the [Create Collection][] example) |
+| `Current` / `Current` / `Current` / `Current` | Limited to the current flow only |
+
+When several blocks use the same resolved [Scope][] and the same resource name, they share one instance. Different scopes or names produce separate instances — even in the same flow.
+
+## Default ScopeDefinition
+
+A [ScopeDefinition][] variable defaults to `null` until you set it. When data storage [Collection Scope][] or semaphore [Scope][Semaphore Scope] use a built-in default (including the default [semaphore property][Semaphore Property] in [Common Properties][]), that default is:
+
+| Level | Default |
+| --- | --- |
+| Tenant | `ScopeOption.Current` |
+| System | `ScopeOption.Current` |
+| Package | `ScopeOption.Current` |
+| Flow | `ScopeOption.All` |
+
+```json
+{
+    "Tenant": "ScopeOption.Current",
+    "System": "ScopeOption.Current",
+    "Package": "ScopeOption.Current",
+    "Flow": "ScopeOption.All"
+}
+```
+
+Those same per-level defaults appear on the [ScopeDefinition][] data type properties (Tenant, System, and Package default to `Current`; Flow defaults to `All`).
+
+## Creating a ScopeDefinition
+
+See [ScopeDefinition][] and [Scope][] for property-editor support and conversion examples.
+
+### In the Expression Editor
+
+```csharp
+new ScopeDefinition(
+    tenant: ScopeOption.Current,
+    system: ScopeOption.Current,
+    package: ScopeOption.Current,
+    flow: ScopeOption.All)
+```
+
+Positional form (as used with [SemaphoreSettings][]):
+
+```csharp
+new ScopeDefinition(ScopeOption.Current, ScopeOption.Current, ScopeOption.Current, ScopeOption.All)
+```
+
+Example that shares a collection across packages within the current tenant and system:
+
+```csharp
+new ScopeDefinition(
+    tenant: ScopeOption.Current,
+    system: ScopeOption.Current,
+    package: ScopeOption.All,
+    flow: ScopeOption.All)
+```
+
+### In the Literal Editor
+
+Set each of Tenant, System, Package, and Flow to `ScopeOption.Current` or `ScopeOption.All`.
+
+## How scopes identify shared instances
+
+| Resource | Identity | Notes |
+| --- | --- | --- |
+| [Semaphore][semaphores] | [Scope][Semaphore Scope] + [Name][Semaphore Name] | Blocks with the same scope and name share one semaphore |
+| [Data Storage Collection][data storage collections] | [Collection Scope][] + [Collection Name][] | Names are case insensitive within a scope; keys inside a collection are case sensitive |
+
+### Semaphore path format
+
+When a semaphore cannot be acquired, [SemaphoreCouldNotBeAcquiredException][] messages use a path built from the resolved scope and name:
+
+```text
+"/<tenant>/<system>/*/<package>/*/<flow>/<semaphore-name>"
+```
+
+where `<tenant>`, `<system>`, `<package>`, and `<flow>` come from the [Scope][], and `<semaphore-name>` is the semaphore [Name][Semaphore Name]. `*` represents future placeholders for `<environment>` and `<package-version>`.
+
+If a data storage collection is missing for the resolved scope, [DataStorageCollectionNotFoundException][] reports the collection name and includes the [Scope][] on the exception.
+
+## Choosing a scope
+
+| Prefer | When |
+| --- | --- |
+| Narrower sharing (more `Current`, especially Flow = `Current`) | The resource must not be visible to other flows, packages, or systems |
+| Wider sharing (more `All`, for example Package and Flow = `All`) | Several flows or packages must share one collection or semaphore |
+| Default (`Current` / `Current` / `Current` / `All`) | Share within the current package across its flows, without crossing packages |
+
+Mismatching scope between create and later read/write or acquire operations looks like a missing resource (for collections) or a separate semaphore instance — even when the name matches.
+
+## Remarks
+
+### Known Limitations
+
+* Environment and PackageVersion levels are not available yet.
+* Only [ScopeOption.All][ScopeOption] (`0`) and [ScopeOption.Current][ScopeOption] (`1`) are defined. Supplying an undefined [ScopeOption][] value (for example `(ScopeOption)100`) can cause an [ArgumentException][] on blocks such as [Create Collection][].
+
+## See Also
+
+### Related Concepts
+
+* [What is a Scope?][]
+* [Variable Scopes][]
+* [What is a Semaphore?][semaphores]
+* [What is a Collection?][]
+* [Common Properties][]
+* [What is a Package?][package]
+* [What is a Flow?][flow]
+
+### Related Data Types
+
+* [ScopeDefinition][]
+* [ScopeOption][]
+* [Scope][]
+* [SemaphoreSettings][]
+
+### Related Blocks
+
+* [Create Collection][]
+* [Semaphore Property][] (most blocks; see [Common Properties][])
+
+### Related Exceptions
+
+* [SemaphoreCouldNotBeAcquiredException][]
+* [DataStorageCollectionNotFoundException][]
+
+### External Documentation
+
+None — resource scopes are a {{% ctx %}} platform concept rather than a direct .NET type mapping. For variable lifetime and C# comparisons, see [Variable Scopes][] and [What is a Scope?][].
+
+[What is a Scope?]: {{< ref "what-is-a-scope.md" >}}
+[Variable Scopes]: {{< ref "variable-scopes.md" >}}
+
+[ScopeDefinition]: {{< url path="Cortex.Reference.DataTypes.Scopes.ScopeDefinition.MainDoc" >}}
+[ScopeOption]: {{< url path="Cortex.Reference.DataTypes.Scopes.ScopeOption.MainDoc" >}}
+[Scope]: {{< url path="Cortex.Reference.DataTypes.Scopes.Scope.MainDoc" >}}
+[SemaphoreSettings]: {{< url path="Cortex.Reference.DataTypes.Concurrency.Semaphores.SemaphoreSettings.MainDoc" >}}
+[Semaphore Scope]: {{< url path="Cortex.Reference.DataTypes.Concurrency.Semaphores.SemaphoreSettings.Scope" >}}
+[Semaphore Name]: {{< url path="Cortex.Reference.DataTypes.Concurrency.Semaphores.SemaphoreSettings.Name" >}}
+[String]: {{< url path="Cortex.Reference.DataTypes.Text.String.MainDoc" >}}
+
+[data storage collections]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Collections.WhatIsACollection.DataStorage" >}}
+[What is a Collection?]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Collections.WhatIsACollection.MainDoc" >}}
+[Collection Scope]: {{< url path="Cortex.Reference.Blocks.DataStorage.CreateCollection.CreateCollectionBlock.MainDoc" >}}
+[Collection Name]: {{< url path="Cortex.Reference.Blocks.DataStorage.CreateCollection.CreateCollectionBlock.MainDoc" >}}
+[Create Collection]: {{< url path="Cortex.Reference.Blocks.DataStorage.CreateCollection.CreateCollectionBlock.MainDoc" >}}
+[semaphores]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Concurrency.Semaphores.WhatIsASemaphore.MainDoc" >}}
+[Common Properties]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.CommonProperties.MainDoc" >}}
+[Semaphore Property]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.CommonProperties.SemaphoreProperty" >}}
+[package]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Packages.WhatIsAPackage.MainDoc" >}}
+[flow]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Flows.WhatIsAFlow.MainDoc" >}}
+
+[SemaphoreCouldNotBeAcquiredException]: {{< url path="Cortex.Reference.Exceptions.Concurrency.Semaphores.SemaphoreCouldNotBeAcquiredException.MainDoc" >}}
+[DataStorageCollectionNotFoundException]: {{< url path="Cortex.Reference.Exceptions.DataStorage.DataStorageCollectionNotFoundException.MainDoc" >}}
+[ArgumentException]: {{< url path="MSDocs.DotNet.Api.System.ArgumentException" >}}
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/variable-scopes.md b/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/variable-scopes.md
new file mode 100644
index 000000000..91ab5ccea
--- /dev/null
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/variable-scopes.md
@@ -0,0 +1,148 @@
+---
+title: "Variable Scopes"
+linkTitle: "Variable Scopes"
+description: "How variable scopes follow workspaces in CORTEX: where variables can be used, how to change scope, name collisions, and what happens when a variable goes out of scope."
+weight: 3
+---
+
+# {{% param title %}}
+
+## Summary
+
+A **variable scope** is the [workspace][] where a [variable][] is defined. It controls where that variable can be used and when it is deleted during [flow execution][].
+
+Variables can only be used in the workspace of the scope they are defined in and any descendant workspaces. Only variables in scope appear in the [Variable Editor][] or as [snippets][] in the [Expression Editor][]. When execution exits a workspace, local-scope variables declared in that workspace are deleted and their values are lost.
+
+This is conceptually similar to [local variable / block scope][MS C# Scopes] in C#: a name is visible inside a region of code, and leaving that region ends the variable's lifetime. When a variable held a connection or session that stayed open, leaving scope closes that resource — similar in spirit to disposing at the end of a [`using`][MS using] statement.
+
+Variable scopes are separate from [resource scopes][Resource Scopes] ([ScopeDefinition][] / [Scope][] used by collections and semaphores). For both meanings, see [What is a Scope?][].
+
+Detailed fundamentals — including the full workspace hierarchy example — are in [Variable Scopes (fundamentals)][Fundamentals Variable Scopes]. This page summarises the same model for the Working With Scopes section and links out for procedures.
+
+## Hierarchy and inheritance
+
+{{% ctx %}} uses inherited scope: a block can use variables from its own workspace and from ancestor workspaces.
+
+| Workspace | Parent | Defined variables (example) | Accessible variables |
+| --- | --- | --- | --- |
+| Top-Level Workspace | — | GlobalVarA, GlobalVarB | GlobalVarA, GlobalVarB |
+| ChildWorkspace1 | Top-Level | ChildVarA, ChildVarB | GlobalVarA, GlobalVarB, ChildVarA, ChildVarB |
+| ChildWorkspace2 | Top-Level | ChildVarC, ChildVarD | GlobalVarA, GlobalVarB, ChildVarC, ChildVarD |
+| GrandChildWorkspace1 | ChildWorkspace1 | GrandChildVarA, GrandChildVarB | Globals + ChildWorkspace1 vars + its own |
+| GrandChildWorkspace2 | ChildWorkspace2 | GrandChildVarC, GrandChildVarD | Globals + ChildWorkspace2 vars + its own |
+
+Sibling workspaces do not see each other's local variables. See [Accessing Variables from Other Scopes][] on the fundamentals page for the complete table.
+
+## Creating and changing variable scope
+
+| Action | Where |
+| --- | --- |
+| Create a variable in the current workspace | [Variables Grid][] or [Variable Editor][] (creating a variable scopes it to the currently selected workspace) |
+| Change a variable's scope | [Variables Grid][] — [change scope][Grid: Changing a Variable's Scope] |
+
+The [Variable Editor][] lists only variables in scope for the selected block. Filtering matches name or scope text. Creating a new name from the editor scopes the new variable to the current workspace. See [Scoped Variables][] and [Creating Variables][] in the Variable Editor documentation.
+
+## Name collisions
+
+You can declare the same variable name in more than one workspace. When a block uses that name, the variable with the **closest** scope to the executing block is used.
+
+Example:
+
+* Top-Level workspace defines `($)Variable`
+* Child-Level workspace also defines `($)Variable`
+
+A block in Child-Level that uses `($)Variable` receives the Child-Level variable. The [Variable Editor][] dropdown likewise shows only the closest same-name variable.
+
+This may change in future so developers can select which same-name variable to use. See [Known Limitations](#known-limitations).
+
+## Going out of scope
+
+When [flow execution][] leaves a workspace:
+
+1. Local-scope variables declared in that workspace are **deleted**.
+2. Their values are **lost**.
+
+### Connections and sessions held in variables
+
+Some resources stay open only while a variable remains in scope:
+
+| Resource | Behaviour when Close is `false` and details are in a variable |
+| --- | --- |
+| Email session | Session stays open until the variable goes out of scope or the flow ends, whichever comes first |
+| PowerShell session | Session stays open until the variable goes out of scope or the flow ends, whichever comes first |
+| Ssh session | Session stays open until the variable goes out of scope or the flow ends, whichever comes first |
+| Telnet session | Session stays open until the variable goes out of scope or the flow ends, whichever comes first |
+| Data source connection | Connection stays open until the variable goes out of scope or the flow ends, whichever comes first |
+
+If session or connection details are supplied as a literal or expression instead of a variable, the connection is closed after the block finishes and cannot be shared with later blocks the way a variable-backed resource can.
+
+In C# terms, treat that lifetime like a resource that is disposed when execution leaves the declaring scope ([`using`][MS using] / [IDisposable][MS IDisposable]), not like a resource-scope identity for platform collections or semaphores.
+
+## Comparison with C#
+
+| Behaviour | C# analogue |
+| --- | --- |
+| Variable visible in declaring workspace and descendants | Local / block scope — see [scopes in the C# specification][MS C# Scopes] |
+| Variable deleted when execution leaves the workspace | End of the declaring block; locals are no longer accessible |
+| Connection or session closed when the holding variable leaves scope | Disposal at end of [`using`][MS using] when the resource implements [IDisposable][MS IDisposable] |
+
+[Resource scopes][Resource Scopes] (Tenant / System / Package / Flow) do **not** map to C# variable scope; they are platform identity for shared resources. See [Resource Scopes][].
+
+## Remarks
+
+### Known Limitations
+
+* When multiple variables share a name across workspaces, only the closest scope is used and shown in the [Variable Editor][]. Explicit selection of a farther same-name variable is not supported today and may be added in future. See [Fundamentals: Variable Scopes][Fundamentals Variable Scopes].
+
+## See Also
+
+### Related Concepts
+
+* [What is a Scope?][]
+* [Resource Scopes][]
+* [Variable Scopes (fundamentals)][Fundamentals Variable Scopes]
+* [What is a Variable?][]
+* [What is a Workspace?][workspace]
+* [Variable Editor][]
+
+### Related Data Types
+
+None specific to variable scopes — variable scope is a workspace concept, not [ScopeDefinition][] / [Scope][].
+
+### Related Blocks
+
+* [All Blocks][] (variable use is scoped by the block's workspace)
+
+### External Documentation
+
+* [Basic concepts — Scopes (C# language specification)][MS C# Scopes]
+* [using statement (C#)][MS using]
+* [IDisposable interface][MS IDisposable]
+
+[What is a Scope?]: {{< ref "what-is-a-scope.md" >}}
+[Resource Scopes]: {{< ref "resource-scopes.md" >}}
+
+[Fundamentals Variable Scopes]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.VariableScopes.MainDoc" >}}
+[Accessing Variables from Other Scopes]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.VariableScopes.MainDoc" >}}#accessing-variables-from-other-scopes
+[What is a Variable?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.WhatIsAVariable.MainDoc" >}}
+[variable]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.WhatIsAVariable.MainDoc" >}}
+[workspace]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Workspaces.WhatIsAWorkspace.MainDoc" >}}
+[flow execution]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Executions.WhatIsAnExecution.MainDoc" >}}
+[Variable Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.VariableEditor.MainDoc" >}}
+[Scoped Variables]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.VariableEditor.MainDoc" >}}
+[Creating Variables]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.VariableEditor.CreatingVariables" >}}
+[Expression Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.ExpressionEditor.MainDoc" >}}
+[snippets]: {{< url path="Cortex.Reference.Glossary.P-T.Snippets" >}}
+[Variables Grid]: {{< url path="Cortex.Guides.UserGuides.UserInterfaces.Gateway.Dev.FlowEditor.BottomPanel.VariablesGrid.MainDoc" >}}
+[Grid: Changing a Variable's Scope]: {{< url path="Cortex.Guides.UserGuides.UserInterfaces.Gateway.Dev.FlowEditor.BottomPanel.VariablesGrid.ModifyScope" >}}
+
+[Email]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Email.WhatIsEmail.MainDoc" >}}
+[Data source]: {{< url path="Cortex.Reference.Concepts.WorkingWith.DataSources.WhatIsADataSource.MainDoc" >}}
+
+[ScopeDefinition]: {{< url path="Cortex.Reference.DataTypes.Scopes.ScopeDefinition.MainDoc" >}}
+[Scope]: {{< url path="Cortex.Reference.DataTypes.Scopes.Scope.MainDoc" >}}
+[All Blocks]: {{< url path="Cortex.Reference.Blocks.MainDoc" >}}
+
+[MS C# Scopes]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/basic-concepts#77-scopes
+[MS using]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/using
+[MS IDisposable]: https://learn.microsoft.com/en-us/dotnet/api/system.idisposable
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/what-is-a-scope.md b/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/what-is-a-scope.md
index 22a853071..01ba00d9a 100644
--- a/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/what-is-a-scope.md
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/scopes/what-is-a-scope.md
@@ -1,38 +1,123 @@
 ---
 title: "What is a Scope?"
 linkTitle: "What is a Scope?"
-description: "Information regarding what a scope is."
+description: "Overview of scopes in CORTEX: resource scopes that isolate shared platform resources, and variable scopes that control where variables can be used and when they go out of scope."
 weight: 1
 ---
 
 # {{% param title %}}
 
-{{< workinprogress >}}
-
 ## Summary
 
-TODO:
+In {{% ctx %}}, **scope** means more than one thing. The same word appears when you configure shared platform resources (such as [data storage collections][] and [semaphores][]) and when you work with [variables][] in [workspaces][]. Both uses control *where* something is visible or shared — but they apply to different parts of the platform.
+
+| Kind of scope | What it controls | Typical use |
+| --- | --- | --- |
+| [Resource scopes][Resource Scopes] | Which tenant, system, package, and flow share a named platform resource | [Collection Scope][] on data storage blocks; [Scope][Semaphore Scope] on [SemaphoreSettings][] |
+| [Variable scopes][Variable Scopes] | Which [workspace][] a [variable][] belongs to, where it can be used, and when it is deleted | Variables Grid, [Variable Editor][]; connections and sessions that close when a variable goes out of scope |
+
+## Types of Scopes
+
+### Resource scopes
+
+A **resource scope** isolates shared platform resources so that the same name in a different scope refers to a different instance. You define the intended sharing with a [ScopeDefinition][]; at runtime that definition resolves to a [Scope][] with string values for Tenant, System, Package, and Flow.
+
+Common examples:
+
+* [Data Storage Collections][data storage collections] — identified by [collection scope][Resource Scopes] plus [collection name][]
+* [Semaphores][semaphores] — identified by [Scope][Semaphore Scope] plus [Name][Semaphore Name]
+
+Levels today are Tenant, System, Package, and Flow. Environment and PackageVersion levels are planned for future releases. See [Resource Scopes][].
+
+### Variable scopes
+
+A **variable scope** is the [workspace][] where a [variable][] is defined. Variables are available in that workspace and in descendant workspaces. When [flow execution][] leaves a workspace, local-scope variables declared there are deleted.
+
+Resources held in variables — for example [email][] sessions or [data source][] connections that stay open while [Close Session][] / [Close Connection][] is `false` — close when the variable goes out of scope or the flow ends, whichever comes first. See [Variable Scopes][].
+
+## Working with Scopes
+
+| Goal | Prefer |
+| --- | --- |
+| Choose how widely a data storage collection or semaphore is shared | [Resource Scopes][] |
+| Define or inspect a [ScopeDefinition][] / [Scope][] / [ScopeOption][] | [Resource Scopes][] and the related data type pages |
+| Understand where a variable can be used, or change its workspace | [Variable Scopes][] (and fundamentals [Variable Scopes][Fundamentals Variable Scopes]) |
+| Understand when a session or connection closes because a variable left scope | [Variable Scopes][] — also [What is Email?][email] and [What is a Data Source?][data source] |
 
 ## Remarks
 
 ### Known Limitations
 
-TODO
+* Resource scope levels Environment and PackageVersion are not available yet; only Tenant, System, Package, and Flow are defined today.
+* When several [variables][] share the same name in different workspaces, the variable with the closest scope to the executing block is used. This may change in future so developers can select a specific same-name variable explicitly. See [Variable Scopes][].
 
 ## See Also
 
 ### Related Concepts
 
-TODO
+* [Resource Scopes][]
+* [Variable Scopes][]
+* [Fundamentals: Variable Scopes][Fundamentals Variable Scopes]
+* [What is a Semaphore?][semaphores]
+* [What is a Collection?][]
+* [What is Email?][email]
+* [What is a Data Source?][data source]
+* [What is a Workspace?][workspaces]
+* [What is a Variable?][variables]
 
 ### Related Data Types
 
-TODO
+* [ScopeDefinition][]
+* [ScopeOption][]
+* [Scope][]
+* [SemaphoreSettings][]
 
 ### Related Blocks
 
-TODO
+* [Create Collection][]
+* Blocks that use the [semaphore property][Semaphore Property] (see [Common Properties][])
+
+### Related Exceptions
+
+* [SemaphoreCouldNotBeAcquiredException][]
+* [DataStorageCollectionNotFoundException][]
 
 ### External Documentation
 
-TODO
+* [Basic concepts — Scopes (C# language specification)][MS C# Scopes]
+
+[Resource Scopes]: {{< ref "resource-scopes.md" >}}
+[Variable Scopes]: {{< ref "variable-scopes.md" >}}
+
+[Fundamentals Variable Scopes]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.VariableScopes.MainDoc" >}}
+[variables]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.WhatIsAVariable.MainDoc" >}}
+[variable]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.WhatIsAVariable.MainDoc" >}}
+[workspaces]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Workspaces.WhatIsAWorkspace.MainDoc" >}}
+[workspace]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Workspaces.WhatIsAWorkspace.MainDoc" >}}
+[flow execution]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Executions.WhatIsAnExecution.MainDoc" >}}
+[Variable Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.VariableEditor.MainDoc" >}}
+[Common Properties]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.CommonProperties.MainDoc" >}}
+[Semaphore Property]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.CommonProperties.SemaphoreProperty" >}}
+
+[ScopeDefinition]: {{< url path="Cortex.Reference.DataTypes.Scopes.ScopeDefinition.MainDoc" >}}
+[ScopeOption]: {{< url path="Cortex.Reference.DataTypes.Scopes.ScopeOption.MainDoc" >}}
+[Scope]: {{< url path="Cortex.Reference.DataTypes.Scopes.Scope.MainDoc" >}}
+[SemaphoreSettings]: {{< url path="Cortex.Reference.DataTypes.Concurrency.Semaphores.SemaphoreSettings.MainDoc" >}}
+[Semaphore Scope]: {{< url path="Cortex.Reference.DataTypes.Concurrency.Semaphores.SemaphoreSettings.Scope" >}}
+[Semaphore Name]: {{< url path="Cortex.Reference.DataTypes.Concurrency.Semaphores.SemaphoreSettings.Name" >}}
+
+[data storage collections]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Collections.WhatIsACollection.DataStorage" >}}
+[What is a Collection?]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Collections.WhatIsACollection.MainDoc" >}}
+[Collection Scope]: {{< url path="Cortex.Reference.Blocks.DataStorage.CreateCollection.CreateCollectionBlock.MainDoc" >}}
+[collection name]: {{< url path="Cortex.Reference.Blocks.DataStorage.CreateCollection.CreateCollectionBlock.MainDoc" >}}
+[Create Collection]: {{< url path="Cortex.Reference.Blocks.DataStorage.CreateCollection.CreateCollectionBlock.MainDoc" >}}
+[semaphores]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Concurrency.Semaphores.WhatIsASemaphore.MainDoc" >}}
+[email]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Email.WhatIsEmail.MainDoc" >}}
+[data source]: {{< url path="Cortex.Reference.Concepts.WorkingWith.DataSources.WhatIsADataSource.MainDoc" >}}
+[Close Session]: {{< url path="Cortex.Reference.Blocks.Email.SendEmail.SendEmailUsingSmtpServer.CloseSessionProperty" >}}
+[Close Connection]: {{< url path="Cortex.Reference.Blocks.Data.ExecuteDataCommand.ExecuteDataCommand.CloseConnectionProperty" >}}
+
+[SemaphoreCouldNotBeAcquiredException]: {{< url path="Cortex.Reference.Exceptions.Concurrency.Semaphores.SemaphoreCouldNotBeAcquiredException.MainDoc" >}}
+[DataStorageCollectionNotFoundException]: {{< url path="Cortex.Reference.Exceptions.DataStorage.DataStorageCollectionNotFoundException.MainDoc" >}}
+
+[MS C# Scopes]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/basic-concepts#77-scopes
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/_index.md b/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/_index.md
index 3db070199..b1327b870 100644
--- a/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/_index.md
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/_index.md
@@ -3,5 +3,3 @@ title: "Tasks"
 linkTitle: "Tasks"
 description: "Information related to working with Tasks."
 ---
-
-{{< workinprogress >}}
\ No newline at end of file
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/cancelling-tasks.md b/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/cancelling-tasks.md
new file mode 100644
index 000000000..f665699e1
--- /dev/null
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/cancelling-tasks.md
@@ -0,0 +1,156 @@
+---
+title: "Cancelling Tasks"
+linkTitle: "Cancelling Tasks"
+description: "How to cancel one or more running tasks in CORTEX, what happens to task status, and how cancellation compares to cooperative cancellation in C#."
+weight: 3
+---
+
+# {{% param title %}}
+
+## Summary
+
+**Cancelling** a task requests that its asynchronous work stop. In {{% ctx %}}, use [Cancel Task][] or [Cancel All Tasks][] on [ITask&lt;TResult&gt;][ITask] values — typically [IExecutionTask][] / [ExecutionTask][] instances from [Run Flow Async][].
+
+In C#, [Task][MS Task] cancellation is cooperative and built around [CancellationToken][MS Cancellation] (see [Task cancellation][MS Task Cancellation]). {{% ctx %}} exposes cancellation through dedicated blocks rather than tokens in the Expression Editor: the platform stops the underlying [flow execution][] when cancellation is accepted.
+
+| Goal | Block | Notes |
+| --- | --- | --- |
+| Cancel one task | [Cancel Task][] | No-op if already completed, faulted, or cancelled |
+| Cancel every task in a list | [Cancel All Tasks][] | Same per-task rules; list must be non-null, non-empty, and contain no `null` items |
+
+## Cancelling a Single Task
+
+[Cancel Task][] takes an [ITask&lt;TResult&gt;][ITask] and attempts to cancel it.
+
+When cancellation applies to a running [IExecutionTask][]:
+
+* [IsCancelled][] becomes `true`
+* [IsCompleted][] becomes `true`
+* [IsCompletedSuccessfully][] remains `false`
+* [IsFaulted][] becomes `true`
+* [Status][] becomes `"Cancelled"`
+* [Exception][] is set to the stopped-execution exception (Cancel Task examples show `FlowExecutionStoppedException` with message `"Flow execution has been stopped!"`)
+
+Example task state after a successful cancel:
+
+```json
+{
+  "ExecutionId": "00000000-0000-0000-0000-000000000000",
+  "Id": "00000000-0000-0000-0000-000000000000",
+  "IsCancelled": true,
+  "IsCompleted": true,
+  "IsCompletedSuccessfully": false,
+  "IsFaulted": true,
+  "Status": "Cancelled",
+  "Exception": {
+    "Exception Type": "FlowExecutionStoppedException",
+    "Message": "Flow execution has been stopped!"
+  }
+}
+```
+
+After cancellation, [Wait For Task][] re-throws that cancellation exception if you wait on the same task. [Wait For All Tasks][] includes it in [AggregateTaskException][] / [TaskExceptions][] when waiting on a list. See [Waiting for Tasks][].
+
+## Cancelling Multiple Tasks
+
+[Cancel All Tasks][] cancels every task in an [IList][]&lt;[ITask&lt;TResult&gt;][ITask]&gt;. Each item follows the same rules as [Cancel Task][].
+
+Use this when several [Run Flow Async][] children should be stopped together — for example after a timeout path, a failed sibling, or a user-driven abort in the parent flow.
+
+## When Cancellation Has No Effect
+
+Cancellation is ignored (the task's status is left unchanged) when the task has already:
+
+| Current status | Effect of cancel |
+| --- | --- |
+| `"RanToCompletion"` | None — work already finished successfully |
+| `"Faulted"` | None — work already ended with an exception |
+| `"Cancelled"` | None — already cancelled |
+
+Only a task that is still `"Running"` (or otherwise not yet completed) can transition to `"Cancelled"` via these blocks.
+
+## Cancellation and Waiting
+
+| Pattern | Behaviour |
+| --- | --- |
+| Cancel, then [Wait For Task][] | Wait re-throws the cancellation exception |
+| Cancel some tasks in a list, then [Wait For All Tasks][] | Wait finishes after all tasks complete, then throws [AggregateTaskException][] with entries for cancelled (and any faulted) indexes |
+| Cancel and do not wait | Child executions stop when cancellation is accepted; the parent continues without observing the exception unless it waits or inspects [Exception][] / [Status][] |
+
+## Remarks
+
+### Known Limitations
+
+None
+
+## See Also
+
+### Related Concepts
+
+* [What is a Task?][]
+* [Waiting for Tasks][]
+* [Handling Exceptions][]
+* [What is an Execution?][]
+
+### Related Data Types
+
+* [ITask&lt;TResult&gt;][ITask]
+* [IExecutionTask][]
+* [ExecutionTask][]
+* [IList][]
+
+### Related Blocks
+
+* [Cancel Task][]
+* [Cancel All Tasks][]
+* [Wait For Task][]
+* [Wait For All Tasks][]
+* [Run Flow Async][]
+
+### Related Exceptions
+
+* [AggregateTaskException][]
+* [PropertyNullException][]
+* [PropertyEmptyException][]
+* [PropertyContainsNullItemException][]
+
+### External Documentation
+
+* [Task cancellation][MS Task Cancellation]
+* [Cancellation in Managed Threads][MS Cancellation]
+* [How to: Cancel a Task and Its Children][MS Cancel Task Children]
+
+[What is a Task?]: {{< ref "what-is-a-task.md" >}}
+[Waiting for Tasks]: {{< ref "waiting-for-tasks.md" >}}
+
+[ITask]: {{< url path="Cortex.Reference.DataTypes.Tasks.ITask.MainDoc" >}}
+[IExecutionTask]: {{< url path="Cortex.Reference.DataTypes.Tasks.IExecutionTask.MainDoc" >}}
+[ExecutionTask]: {{< url path="Cortex.Reference.DataTypes.Tasks.ExecutionTask.MainDoc" >}}
+[IList]: {{< url path="Cortex.Reference.DataTypes.Collections.IList.MainDoc" >}}
+[IsCancelled]: {{< url path="Cortex.Reference.DataTypes.Tasks.ITask.MainDoc" >}}
+[IsCompleted]: {{< url path="Cortex.Reference.DataTypes.Tasks.ITask.MainDoc" >}}
+[IsCompletedSuccessfully]: {{< url path="Cortex.Reference.DataTypes.Tasks.ITask.MainDoc" >}}
+[IsFaulted]: {{< url path="Cortex.Reference.DataTypes.Tasks.ITask.MainDoc" >}}
+[Status]: {{< url path="Cortex.Reference.DataTypes.Tasks.ITask.MainDoc" >}}
+[Exception]: {{< url path="Cortex.Reference.DataTypes.Tasks.ITask.MainDoc" >}}
+
+[Cancel Task]: {{< url path="Cortex.Reference.Blocks.Tasks.CancelTask.CancelTaskBlock.MainDoc" >}}
+[Cancel All Tasks]: {{< url path="Cortex.Reference.Blocks.Tasks.CancelTask.CancelAllTasksBlock.MainDoc" >}}
+[Wait For Task]: {{< url path="Cortex.Reference.Blocks.Tasks.WaitForTask.WaitForTask.MainDoc" >}}
+[Wait For All Tasks]: {{< url path="Cortex.Reference.Blocks.Tasks.WaitForTask.WaitForAllTasksBlock.MainDoc" >}}
+[Run Flow Async]: {{< url path="Cortex.Reference.Blocks.Flows.RunFlow.RunFlowAsync.MainDoc" >}}
+
+[AggregateTaskException]: {{< url path="Cortex.Reference.Exceptions.Tasks.AggregateTaskException.MainDoc" >}}
+[TaskExceptions]: {{< url path="Cortex.Reference.Exceptions.Tasks.AggregateTaskException.TaskExceptions" >}}
+[PropertyNullException]: {{< url path="Cortex.Reference.Exceptions.Common.Property.PropertyNullException.MainDoc" >}}
+[PropertyEmptyException]: {{< url path="Cortex.Reference.Exceptions.Common.Property.PropertyEmptyException.MainDoc" >}}
+[PropertyContainsNullItemException]: {{< url path="Cortex.Reference.Exceptions.Common.Property.PropertyContainsNullItemException.MainDoc" >}}
+
+[flow execution]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Executions.WhatIsAnExecution.MainDoc" >}}
+[What is an Execution?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Executions.WhatIsAnExecution.MainDoc" >}}
+[Handling Exceptions]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Exceptions.HandlingExceptions.MainDoc" >}}
+
+[MS Task]: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task
+[MS Task Cancellation]: https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-cancellation
+[MS Cancellation]: https://learn.microsoft.com/en-us/dotnet/standard/threading/cancellation-in-managed-threads
+[MS Cancel Task Children]: https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/how-to-cancel-a-task-and-its-children
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/waiting-for-tasks.md b/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/waiting-for-tasks.md
new file mode 100644
index 000000000..e47ccc054
--- /dev/null
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/waiting-for-tasks.md
@@ -0,0 +1,166 @@
+---
+title: "Waiting for Tasks"
+linkTitle: "Waiting for Tasks"
+description: "How to wait for one or more tasks to complete in CORTEX, retrieve results, and handle faults and cancellations — comparable to Task.Wait and Task.WaitAll in C#."
+weight: 2
+---
+
+# {{% param title %}}
+
+## Summary
+
+**Waiting** pauses the current [flow execution][] until one or more [tasks][What is a Task?] finish, then returns their results. Use it when you started work with [Run Flow Async][] (or hold any [ITask&lt;TResult&gt;][ITask]) and need the outcome before continuing.
+
+This matches waiting on [Task][MS Task] / [Task&lt;TResult&gt;][MS Task TResult] in C# with instance [Wait][MS Task Wait] methods, or waiting on many tasks with [Task.WaitAll][MS Task WaitAll]. In {{% ctx %}}:
+
+| Goal | Block | C# analogue |
+| --- | --- | --- |
+| Wait for one task and get its result | [Wait For Task][] | Reading `Result` after the task completes (blocks until available) |
+| Wait for every task in a list and get all results | [Wait For All Tasks][] | `Task.WaitAll(tasks)` |
+
+If a task has already completed when the wait begins, the block does not delay — it returns the result immediately.
+
+## Waiting for a Single Task
+
+[Wait For Task][] takes an [ITask&lt;TResult&gt;][ITask] and outputs the task's result as `TResult`.
+
+For an [IExecutionTask][] / [ExecutionTask][], `TResult` is a [Structure][] of the child flow's [output variables][]. Example outcome after a successful wait:
+
+```json
+{
+  "ResultVariable": "ResultValue"
+}
+```
+
+### Faulted or cancelled tasks
+
+If the task faults or is cancelled before or during the wait, [Wait For Task][] **re-throws** that exception into the waiting flow. Handle it with [Handle Block Exception][] (or related exception-handling blocks) if the parent should continue.
+
+Unhandled exceptions from a child started with [Run Flow Async][] are stored on the task and do not affect the parent until a wait observes them. See the Remarks on [Run Flow Async][] (Exceptions Thrown by a Child Flow).
+
+## Waiting for Multiple Tasks
+
+[Wait For All Tasks][] takes an [IList][] of [ITask&lt;TResult&gt;][ITask] values and outputs an [IList][] of results. Result order matches task order (index `0` with index `0`, and so on).
+
+The block waits until **every** task has finished — including those that faulted or were cancelled — before it returns or throws.
+
+### AggregateTaskException
+
+If one or more tasks fault or are cancelled, [Wait For All Tasks][] throws [AggregateTaskException][] after all tasks complete. That exception's [TaskExceptions][] property is an [IDictionary][]&lt;[Int32][], [Exception][]&gt; mapping each failing task's index to its exception — similar in role to [AggregateException][MS AggregateException] when waiting on multiple .NET tasks.
+
+Example after the first and third tasks throw:
+
+```json
+{
+  "0": {
+    "Exception Type": "FlowException",
+    "Message": "This flow threw an exception."
+  },
+  "2": {
+    "Exception Type": "FlowException",
+    "Message": "This flow threw an exception."
+  }
+}
+```
+
+### Getting results from successful tasks only
+
+[AggregateTaskException][] means the wait block does not return a partial results list. To collect results from tasks that succeeded:
+
+1. Catch [AggregateTaskException][] with [Handle Block Exception][].
+2. Remove the failed tasks from the list (for example with [Remove Items At Indexes][], using `TaskExceptions.Keys` as the indexes).
+3. Run [Wait For All Tasks][] again on the remaining tasks (they are already complete, so this returns immediately).
+
+See [Waiting for a Task that has thrown an exception][] on the [Wait For All Tasks][] block page for a worked example.
+
+## Choosing How to Wait
+
+| Situation | Prefer |
+| --- | --- |
+| One asynchronous flow; need its outputs | [Wait For Task][] |
+| Several asynchronous flows; need all outputs together | [Wait For All Tasks][] |
+| Fire-and-forget; no result needed | Do not wait — let the child finish on its own ([Run Flow Async][] child continues even if the parent ends) |
+| Need to stop work instead of waiting | [Cancelling Tasks][] |
+
+## Remarks
+
+### Known Limitations
+
+* There is no dedicated "wait for any" block equivalent to `Task.WaitAny`. To proceed when the first of several tasks finishes, use separate wait paths, polling of task status properties, or redesign so a single task represents the work you care about first.
+
+## See Also
+
+### Related Concepts
+
+* [What is a Task?][]
+* [Cancelling Tasks][]
+* [Handling Exceptions][]
+* [What is an Exception?][]
+
+### Related Data Types
+
+* [ITask&lt;TResult&gt;][ITask]
+* [IExecutionTask][]
+* [ExecutionTask][]
+* [IList][]
+* [Structure][]
+
+### Related Blocks
+
+* [Wait For Task][]
+* [Wait For All Tasks][]
+* [Run Flow Async][]
+* [Handle Block Exception][]
+* [Remove Items At Indexes][]
+
+### Related Exceptions
+
+* [AggregateTaskException][]
+* [PropertyNullException][]
+* [PropertyEmptyException][]
+* [PropertyContainsNullItemException][]
+
+### External Documentation
+
+* [Task-based asynchronous programming][MS TAP]
+* [Task.Wait Method][MS Task Wait]
+* [Task.WaitAll Method][MS Task WaitAll]
+* [AggregateException Class][MS AggregateException]
+
+[What is a Task?]: {{< ref "what-is-a-task.md" >}}
+[Cancelling Tasks]: {{< ref "cancelling-tasks.md" >}}
+
+[ITask]: {{< url path="Cortex.Reference.DataTypes.Tasks.ITask.MainDoc" >}}
+[IExecutionTask]: {{< url path="Cortex.Reference.DataTypes.Tasks.IExecutionTask.MainDoc" >}}
+[ExecutionTask]: {{< url path="Cortex.Reference.DataTypes.Tasks.ExecutionTask.MainDoc" >}}
+[IList]: {{< url path="Cortex.Reference.DataTypes.Collections.IList.MainDoc" >}}
+[Structure]: {{< url path="Cortex.Reference.DataTypes.Collections.Structure.MainDoc" >}}
+[IDictionary]: {{< url path="Cortex.Reference.DataTypes.Collections.IDictionary.MainDoc" >}}
+[Int32]: {{< url path="Cortex.Reference.DataTypes.Numbers.Int32.MainDoc" >}}
+[Exception]: {{< url path="Cortex.Reference.DataTypes.Exceptions.Exception.MainDoc" >}}
+
+[Wait For Task]: {{< url path="Cortex.Reference.Blocks.Tasks.WaitForTask.WaitForTask.MainDoc" >}}
+[Wait For All Tasks]: {{< url path="Cortex.Reference.Blocks.Tasks.WaitForTask.WaitForAllTasksBlock.MainDoc" >}}
+[Waiting for a Task that has thrown an exception]: {{< url path="Cortex.Reference.Blocks.Tasks.WaitForTask.WaitForAllTasksBlock.GetSuccessfulResults" >}}
+[Task]: {{< url path="Cortex.Reference.Blocks.Tasks.WaitForTask.WaitForTask.MainDoc" >}}
+[Run Flow Async]: {{< url path="Cortex.Reference.Blocks.Flows.RunFlow.RunFlowAsync.MainDoc" >}}
+[Handle Block Exception]: {{< url path="Cortex.Reference.Blocks.Exceptions.HandleBlock.HandleBlockException.MainDoc" >}}
+[Remove Items At Indexes]: {{< url path="Cortex.Reference.Blocks.Lists.RemoveItem.RemoveItemsAtIndexes.MainDoc" >}}
+
+[AggregateTaskException]: {{< url path="Cortex.Reference.Exceptions.Tasks.AggregateTaskException.MainDoc" >}}
+[TaskExceptions]: {{< url path="Cortex.Reference.Exceptions.Tasks.AggregateTaskException.TaskExceptions" >}}
+[PropertyNullException]: {{< url path="Cortex.Reference.Exceptions.Common.Property.PropertyNullException.MainDoc" >}}
+[PropertyEmptyException]: {{< url path="Cortex.Reference.Exceptions.Common.Property.PropertyEmptyException.MainDoc" >}}
+[PropertyContainsNullItemException]: {{< url path="Cortex.Reference.Exceptions.Common.Property.PropertyContainsNullItemException.MainDoc" >}}
+
+[flow execution]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Executions.WhatIsAnExecution.MainDoc" >}}
+[Handling Exceptions]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Exceptions.HandlingExceptions.MainDoc" >}}
+[What is an Exception?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Exceptions.WhatIsAnException.MainDoc" >}}
+[output variables]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.WhatIsAVariable.OutputVariablesStructure" >}}
+
+[MS TAP]: https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-based-asynchronous-programming
+[MS Task]: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task
+[MS Task TResult]: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task-1
+[MS Task Wait]: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.wait
+[MS Task WaitAll]: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.waitall
+[MS AggregateException]: https://learn.microsoft.com/en-us/dotnet/api/system.aggregateexception
diff --git a/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/what-is-a-task.md b/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/what-is-a-task.md
new file mode 100644
index 000000000..a1fb91410
--- /dev/null
+++ b/content/en/docs/2026.3/Reference/Concepts/working-with/tasks/what-is-a-task.md
@@ -0,0 +1,178 @@
+---
+title: "What is a Task?"
+linkTitle: "What is a Task?"
+description: "Overview of tasks in CORTEX, including task types, status, creating tasks with Run Flow Async, and how they relate to C# Task and Task<TResult>."
+weight: 1
+---
+
+# {{% param title %}}
+
+## Summary
+
+A **task** represents asynchronous work that can run independently of the flow that started it. In {{% ctx %}}, the most common task is an [ExecutionTask][] returned by [Run Flow Async][]: it tracks a separate [flow execution][] while the parent flow continues.
+
+Tasks are conceptually similar to [Task][MS Task] and [Task&lt;TResult&gt;][MS Task TResult] in C# (`System.Threading.Tasks`). Those types expose status, completion flags, and a result; {{% ctx %}} mirrors that model with [ITask&lt;TResult&gt;][ITask] and specialised types for flow executions. You start work asynchronously, optionally wait for results later, and can cancel work that is still running — see [Waiting for Tasks][] and [Cancelling Tasks][].
+
+| Term | Meaning |
+| --- | --- |
+| [ITask&lt;TResult&gt;][ITask] | Any asynchronous task that can produce a result of type `TResult` |
+| [IExecutionTask][] | A task that represents an asynchronous [flow execution][] (`ITask<Structure>`) |
+| [ExecutionTask][] | The concrete task created by [Run Flow Async][] |
+| Result | The value produced when the task completes successfully (for execution tasks, a [Structure][] of [output variables][]) |
+
+## Types of Tasks
+
+### ITask&lt;TResult&gt;
+
+[ITask&lt;TResult&gt;][ITask] is the common interface for asynchronous tasks. `TResult` is the data type of the value returned when the task completes successfully. Task blocks such as [Wait For Task][] and [Cancel Task][] accept any `ITask<TResult>`.
+
+Properties shared by all tasks include:
+
+| Property | Purpose |
+| --- | --- |
+| `Id` | Unique identifier of the task ([Guid][]) |
+| `Status` | Current state as text (for example `"Running"`, `"RanToCompletion"`, `"Faulted"`, `"Cancelled"`) |
+| `IsCompleted` | `true` when the task has finished (successfully, faulted, or cancelled) |
+| `IsCompletedSuccessfully` | `true` when the task completed without fault or cancellation |
+| `IsFaulted` | `true` when the task threw an exception |
+| `IsCancelled` | `true` when the task was cancelled |
+| `Exception` | The [Exception][] thrown by the task, or `null` |
+
+These status strings match the lifecycle concepts used by [TaskStatus][MS TaskStatus] in .NET. Note that after cancellation, {{% ctx %}} examples set both `IsCancelled` and `IsFaulted` to `true` (see [Cancelling Tasks][]); that differs from a .NET task that ends only in the `Canceled` state. See [ITask&lt;TResult&gt;][ITask] for full property details.
+
+### IExecutionTask and ExecutionTask
+
+[IExecutionTask][] extends [ITask&lt;Structure&gt;][ITask] for asynchronous flow executions. In addition to the shared task properties, it exposes `ExecutionId` — the unique id of the child [flow execution][].
+
+[ExecutionTask][] is the concrete type produced by [Run Flow Async][]. It can be used wherever [IExecutionTask][] or `ITask<Structure>` is required.
+
+When an execution task completes successfully, its result is a [Structure][] containing the child flow's [output variables][]. Retrieve that result with [Wait For Task][] or [Wait For All Tasks][].
+
+## Creating a Task
+
+The primary way to create a task in a flow is [Run Flow Async][]:
+
+1. Select the child [flow][] to run.
+2. Supply any required [input variables][].
+3. Store the returned [IExecutionTask][] in a variable (for example `($)ExecutionTask`).
+
+The parent flow continues immediately. The child execution runs asynchronously; if the parent ends first, the child continues to completion. Unhandled exceptions in the child are stored on the task (`IsFaulted` becomes `true` and `Exception` is set) and do not stop the parent unless a wait block observes them.
+
+For creation examples and property details, see [Create an ExecutionTask][] on the [ExecutionTask][] data type page and [Run Flow Async][].
+
+Synchronous calls use [Run Flow][] instead: the parent waits for the child to finish and receives outputs directly, without an [IExecutionTask][].
+
+## Task Lifecycle
+
+A typical execution task moves through these states:
+
+| Status | Meaning |
+| --- | --- |
+| `"Running"` | The child [flow execution][] is in progress |
+| `"RanToCompletion"` | The execution finished successfully; a result is available |
+| `"Faulted"` | The execution threw an unhandled exception (see the task's `Exception` property) |
+| `"Cancelled"` | The execution was cancelled (for example by [Cancel Task][]) |
+
+You can inspect status with expressions (for example `($)ExecutionTask.IsCompleted` or `($)ExecutionTask.Status`) before deciding whether to wait, cancel, or branch with a [Decision][] block.
+
+## Working with Tasks
+
+| Goal | Prefer |
+| --- | --- |
+| Start another flow without waiting | [Run Flow Async][] |
+| Get the result of one task | [Wait For Task][] — see [Waiting for Tasks][] |
+| Get results from several tasks | [Wait For All Tasks][] — see [Waiting for Tasks][] |
+| Stop one running task | [Cancel Task][] — see [Cancelling Tasks][] |
+| Stop several running tasks | [Cancel All Tasks][] — see [Cancelling Tasks][] |
+| Limit how many executions run at once | [Semaphores][] (concurrency control, separate from tasks) |
+
+## Remarks
+
+### Manage Asynchronous Flow Executions
+
+Tasks are not created with C# `Task.Run` or `async`/`await` in the Expression Editor. Use [Run Flow Async][] (and the wait/cancel blocks) to manage asynchronous flow executions.
+
+### Known Limitations
+
+* [ITask&lt;TResult&gt;][ITask] and [IExecutionTask][] inputs support the [Expression Editor][] and [Variable Editor][]; the [Literal Editor][] is not available for these types.
+
+## See Also
+
+### Related Concepts
+
+* [Waiting for Tasks][]
+* [Cancelling Tasks][]
+* [What is a Flow?][]
+* [What is an Execution?][]
+* [What is a Semaphore?][]
+* [Handling Exceptions][]
+
+### Related Data Types
+
+* [ITask&lt;TResult&gt;][ITask]
+* [IExecutionTask][]
+* [ExecutionTask][]
+* [Structure][]
+* [Guid][]
+* [Exception][]
+
+### Related Blocks
+
+* [Run Flow Async][]
+* [Run Flow][]
+* [Wait For Task][]
+* [Wait For All Tasks][]
+* [Cancel Task][]
+* [Cancel All Tasks][]
+
+### Related Exceptions
+
+* [AggregateTaskException][]
+
+### External Documentation
+
+* [Task-based asynchronous programming][MS TAP]
+* [Task Class][MS Task]
+* [Task&lt;TResult&gt; Class][MS Task TResult]
+* [TaskStatus Enum][MS TaskStatus]
+
+[Waiting for Tasks]: {{< ref "waiting-for-tasks.md" >}}
+[Cancelling Tasks]: {{< ref "cancelling-tasks.md" >}}
+
+[ITask]: {{< url path="Cortex.Reference.DataTypes.Tasks.ITask.MainDoc" >}}
+[IExecutionTask]: {{< url path="Cortex.Reference.DataTypes.Tasks.IExecutionTask.MainDoc" >}}
+[ExecutionTask]: {{< url path="Cortex.Reference.DataTypes.Tasks.ExecutionTask.MainDoc" >}}
+[Create an ExecutionTask]: {{< url path="Cortex.Reference.DataTypes.Tasks.ExecutionTask.Create" >}}
+
+[Structure]: {{< url path="Cortex.Reference.DataTypes.Collections.Structure.MainDoc" >}}
+[Guid]: {{< url path="Cortex.Reference.DataTypes.Other.Guid.MainDoc" >}}
+[Exception]: {{< url path="Cortex.Reference.DataTypes.Exceptions.Exception.MainDoc" >}}
+
+[Run Flow Async]: {{< url path="Cortex.Reference.Blocks.Flows.RunFlow.RunFlowAsync.MainDoc" >}}
+[Run Flow]: {{< url path="Cortex.Reference.Blocks.Flows.RunFlow.RunFlow.MainDoc" >}}
+[Wait For Task]: {{< url path="Cortex.Reference.Blocks.Tasks.WaitForTask.WaitForTask.MainDoc" >}}
+[Wait For All Tasks]: {{< url path="Cortex.Reference.Blocks.Tasks.WaitForTask.WaitForAllTasksBlock.MainDoc" >}}
+[Cancel Task]: {{< url path="Cortex.Reference.Blocks.Tasks.CancelTask.CancelTaskBlock.MainDoc" >}}
+[Cancel All Tasks]: {{< url path="Cortex.Reference.Blocks.Tasks.CancelTask.CancelAllTasksBlock.MainDoc" >}}
+[Decision]: {{< url path="Cortex.Reference.Blocks.Decisions.MainDoc" >}}
+
+[AggregateTaskException]: {{< url path="Cortex.Reference.Exceptions.Tasks.AggregateTaskException.MainDoc" >}}
+
+[What is a Flow?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Flows.WhatIsAFlow.MainDoc" >}}
+[flow]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Flows.WhatIsAFlow.MainDoc" >}}
+[What is an Execution?]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Executions.WhatIsAnExecution.MainDoc" >}}
+[flow execution]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Executions.WhatIsAnExecution.MainDoc" >}}
+[What is a Semaphore?]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Concurrency.Semaphores.WhatIsASemaphore.MainDoc" >}}
+[Semaphores]: {{< url path="Cortex.Reference.Concepts.WorkingWith.Concurrency.Semaphores.WhatIsASemaphore.MainDoc" >}}
+[Handling Exceptions]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Exceptions.HandlingExceptions.MainDoc" >}}
+[output variables]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.WhatIsAVariable.OutputVariablesStructure" >}}
+[input variables]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Variables.WhatIsAVariable.FlowInputVariable" >}}
+
+[Expression Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.ExpressionEditor.MainDoc" >}}
+[Variable Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.VariableEditor.MainDoc" >}}
+[Literal Editor]: {{< url path="Cortex.Reference.Concepts.Fundamentals.Blocks.BlockProperties.PropertyEditors.LiteralEditor.MainDoc" >}}
+
+[MS TAP]: https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-based-asynchronous-programming
+[MS Task]: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task
+[MS Task TResult]: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task-1
+[MS TaskStatus]: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.taskstatus
diff --git a/data/urls.toml b/data/urls.toml
index e4563ae13..9eeea7efe 100644
--- a/data/urls.toml
+++ b/data/urls.toml
@@ -1853,6 +1853,8 @@
                         MainDoc = "/docs/reference/concepts/working-with/files-and-folders/attributes/"
                     [Cortex.Reference.Concepts.WorkingWith.FilesAndFolders.Paths]
                         MainDoc = "/docs/reference/concepts/working-with/files-and-folders/paths/"
+                    [Cortex.Reference.Concepts.WorkingWith.FilesAndFolders.WhatAreFilesAndFolders]
+                        MainDoc = "/docs/reference/concepts/working-with/files-and-folders/what-are-files-and-folders/"
                 [Cortex.Reference.Concepts.WorkingWith.Loops]
                     MainDoc = "/docs/reference/concepts/working-with/loops/"
                 [Cortex.Reference.Concepts.WorkingWith.Numbers]
@@ -2076,6 +2078,8 @@
                     MainDoc = "/docs/reference/data-types/files-and-folders/fileinformation"
                 [Cortex.Reference.DataTypes.FilesAndFolders.FileMatch]
                     MainDoc = "/docs/reference/data-types/files-and-folders/filematch"
+                [Cortex.Reference.DataTypes.FilesAndFolders.FileSystemInformation]
+                    MainDoc = "/docs/reference/data-types/files-and-folders/filesysteminformation"
                 [Cortex.Reference.DataTypes.FilesAndFolders.FolderInformation]
                     MainDoc = "/docs/reference/data-types/files-and-folders/folderinformation"
             [Cortex.Reference.DataTypes.Flows]
@@ -3043,6 +3047,8 @@
                     InstantiatingAnInt64 = "https://learn.microsoft.com/en-us/dotnet/api/system.int64?#instantiating-an-int64-value"
                     RepresentingAnInt64AsAString = "https://learn.microsoft.com/en-us/dotnet/api/system.int64?#representing-an-int64-as-a-string"
                 [MSDocs.DotNet.Api.System.IO]
+                    FileAttributes = "https://learn.microsoft.com/en-us/dotnet/api/system.io.fileattributes"
+                    FilePathFormat = "https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats"
                     FileNotFoundException = "https://learn.microsoft.com/en-us/dotnet/api/system.io.filenotfoundexception"
                     IOException = "https://learn.microsoft.com/en-us/dotnet/api/system.io.ioexception"
                     PathTooLongException = "https://learn.microsoft.com/en-us/dotnet/api/system.io.pathtoolongexception"