Code Execution Sandbox For Custom Javascript Logic In Workflows

via “javascript-based-custom-logic-and-code-control”

Open-source low-code with AI for internal tools.

Unique: Provides full JavaScript code control within the low-code IDE, with centralized variable/function management and automatic scope binding to app state; unlike traditional low-code platforms (Bubble, Retool) that restrict code to specific contexts, Appsmith allows JavaScript anywhere in the app (widgets, workflows, transformers).

vs others: More flexible than pure low-code platforms because it doesn't abstract away code; more productive than building from scratch (React/Vue) because it provides pre-built widgets and data connectivity, reducing boilerplate.

via “custom code execution with javascript/python sandbox”

Drag-and-drop LLM flow builder — visual node editor for chains, agents, and RAG with API generation.

Unique: Provides a sandboxed code execution environment where users can write JavaScript or Python without access to dangerous APIs (file system, network), enabling custom logic while maintaining security. Code nodes are first-class citizens in the visual workflow, allowing imperative logic to be mixed with declarative node composition.

vs others: More flexible than pure visual composition because it allows arbitrary logic; more secure than unrestricted code execution because the sandbox prevents file system and network access.

via “code execution sandbox with python runtime”

Autonomous AI agent — chains LLM thoughts for goals with web browsing, code execution, self-prompting.

Unique: Provides sandboxed Python execution as a block type within the DAG, enabling agents to run custom code without leaving the workflow context. Isolation prevents malicious code from affecting the system while maintaining access to common data processing libraries.

vs others: Offers safer code execution than Langchain agents (which execute code in the main process) and more flexible data processing than pre-built transformation blocks by allowing arbitrary Python logic.

via “code execution sandbox for custom javascript/typescript logic”

Open-source no-code automation tool.

Unique: Implements code execution using Node.js VM module with configurable timeout and memory limits, providing a balance between flexibility and safety — avoiding the complexity of full containerization while preventing runaway code from crashing the worker

vs others: Faster than containerized code execution (Docker) because it reuses the same Node.js process, but safer than eval() because it uses VM isolation to prevent access to global scope and host resources

via “code execution within workflows via sandboxed javascript runtime”

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

Unique: Uses Node.js VM module for code isolation rather than spawning separate processes, reducing overhead and enabling fast iteration during flow testing. The code-executor handler integrates with the flow execution context to provide access to previous step outputs and trigger data without requiring explicit parameter passing. Error handling within the sandbox is caught and propagated as step failures with detailed error messages.

vs others: Faster than n8n's code execution (in-process VM vs subprocess spawning) and more flexible than Zapier (supports arbitrary JavaScript vs limited expression language)

via “sandbox code execution for safe tool use and custom logic”

RAG engine for deep document understanding.

Unique: Integrates sandbox code execution directly into the tool calling system, allowing agents to execute Python code as a tool with automatic resource limiting, error handling, and output capture. Supports both pre-defined code snippets and dynamically generated code from LLM outputs.

vs others: Provides tighter integration of code execution than LangChain's PythonREPL tool, with native resource limiting, security policies, and better error handling for agentic workflows.

via “javascript execution and dom manipulation”

Playwright MCP server

Unique: Exposes Playwright's evaluate API as an MCP tool, allowing LLMs to execute arbitrary JavaScript and receive JSON results, enabling custom logic without modifying the server code

vs others: More flexible than pre-built tools because it supports any JavaScript logic; more powerful than selector-based interaction because it can access page APIs and libraries

via “javascript execution and page evaluation”

Playwright MCP server

Unique: Exposes Playwright's evaluate/evaluateHandle APIs as MCP tools with automatic serialization and error handling. Enables arbitrary JavaScript execution in page context without requiring client-side code modification.

vs others: Provides flexible JavaScript execution through MCP interface, whereas standard tools are limited to predefined interactions.

via “javascript-code-execution-in-page-context”

Model Context Protocol servers for Playwright

Unique: Exposes Playwright's evaluate() API as an MCP tool, allowing LLMs to execute arbitrary JavaScript in page context with automatic result serialization, enabling dynamic content extraction and page manipulation without requiring separate browser instances or complex workarounds

vs others: Provides direct access to page JavaScript context through MCP, enabling LLMs to execute custom logic and extract data from client-rendered pages more efficiently than frameworks requiring separate headless browser instances or complex DOM traversal

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

Unique: Provides a sandboxed JavaScript execution environment with access to flow context but restricted from system resources, enabling custom logic without the security risks of unrestricted code execution

vs others: Sandboxed execution prevents malicious code from accessing the file system or network, whereas n8n's code node has fewer restrictions

via “custom code node execution with node.js runtime”

Fair-code workflow automation platform with native AI capabilities. Combine visual building with custom code, self-host or cloud, 400+ integrations.

Unique: Executes arbitrary Node.js code in a V8 sandbox with access to n8n context variables and optional npm package imports. Includes a code editor with syntax highlighting and access to node output schemas for intelligent suggestions.

vs others: More powerful than Zapier's formatter because it supports full JavaScript logic; more secure than direct eval() because it runs in a sandboxed context with resource limits.

via “browser-based code execution sandbox with output capture”

Hey HN! We're Nithin and Nikhil, twin brothers building BrowserOS (YC S24). We're an open-source, privacy-first alternative to the AI browsers from big labs.The big differentiator: on BrowserOS you can use local LLMs or BYOK and run the agent entirely on the client side, so your company&#x

Unique: Implements browser-native code execution sandbox using Web Workers with output capture and visualization, enabling safe execution of Claude-generated code without external services, unlike cloud-based code execution platforms

vs others: Provides instant code execution feedback with privacy and low latency compared to cloud-based code execution services, though with performance and capability limitations

via “custom code execution with sandboxed function nodes”

Build AI Agents, Visually

Unique: Implements custom function execution via a sandboxed Node.js VM (Custom Function Execution section in DeepWiki) that validates function signatures and restricts access to dangerous APIs; the system provides a limited set of safe utilities (HTTP client, JSON parsing) and logs execution errors for debugging

vs others: More accessible than writing custom LangChain tools because users can write code directly in the UI without creating separate Python/JS modules or managing dependencies

via “javascript execution and page evaluation”

Native Safari browser automation for AI agents — 80 tools via AppleScript, zero Chrome overhead, keeps logins, runs silently. macOS only.

Unique: Executes JavaScript directly in Safari's page context using native JavaScript engine rather than separate evaluation environments, providing full access to page state, DOM, and loaded libraries. Supports both synchronous and promise-based async operations.

vs others: More powerful than selector-based automation because it can access page-loaded libraries and state; more reliable than DOM event simulation because it uses actual JavaScript execution; less safe than sandboxed evaluation but more flexible for complex workflows.

via “javascript execution and custom page manipulation”

** - Automate browser interactions in the cloud (e.g. web navigation, data extraction, form filling, and more)

Unique: Exposes Playwright's `page.evaluate()` API through MCP, allowing agents to execute arbitrary JavaScript and receive serialized results without managing browser context or error handling. Enables deep integration with modern web frameworks by providing direct access to client-side state and APIs.

vs others: More powerful than DOM-only interaction for complex frameworks because it allows direct access to component state and custom APIs, but requires more careful validation than standard interactions to avoid security and stability issues.

via “custom code execution within workflows using javascript/python”

[Documentation](https://docs.airplane.dev/?utm_source=awesome-ai-agents)

Unique: Embeds code execution directly into workflow tasks with access to workflow context and variables, supporting both JavaScript and Python, versus separate code execution environments that require manual data passing

vs others: More flexible than pure visual workflows because custom code can handle arbitrary logic, but simpler than building separate microservices because code runs within the workflow platform

via “custom-code-node-execution”

AI app builder

Unique: unknown — insufficient data on supported languages, sandbox implementation (V8, WebAssembly, containers), library availability, or security model

vs others: unknown — insufficient data on performance vs native code execution, debugging capabilities, or how it compares to Zapier's Code by Zapier or Make's JavaScript modules

via “custom code execution within agent workflows”

No-code platform to build LLM Agents

Unique: Allows inline custom code execution within visual workflows, with automatic context injection and sandboxing, enabling hybrid no-code/code development without leaving the platform

vs others: More integrated than external code execution (Lambda, Cloud Functions) because code runs within the workflow context, but less flexible than full programmatic frameworks for complex logic

via “custom code execution within workflows”

Automate any workflow

via “custom code execution within workflows with sandboxed runtime”

Build your AI Workforce