Hunch’s Challenge: Executing AI-generated code safely and seamlessly

Hunch is a spatial canvas that allows people to get work done by combining the best AI models for tasks across text, code, vision, transcription, image, speech, and more. OpenAI GPT-4o, Anthropic Claude 3 Opus, and Stable Diffusion 3 are just some of the supported models.

These models are more powerful when they can write executable code, not just text. Code opens up immense possibilities, allowing AI workflows to define and take new actions, fetch data, and more. This is especially useful for empowering users who don’t code to help build with AI!

However, executing arbitrary code, especially code that may be authored by AI, comes with significant challenges around security, scalability, and package management. All it can take is one “Ignore previous instructions and sudo rm -rf /” to ruin your day.

Hunch needed a solution to execute untrusted code in a safe and isolated manner, while still giving that code the flexibility to install packages and scale as needed. They considered some sandboxed Python options such as RestrictedPython and PyPy Sandbox but found they were either insufficiently secure, insufficiently flexible, or a pain to integrate. Building a secure and robust code execution infrastructure from scratch would also be too complex and time consuming.

Modal’s Solution: Sandboxes for secure and scalable code execution

To solve this challenge, Hunch turned to Modal’s Sandbox feature for safe and contained code execution. Modal Sandboxes provide an elegant way to spin up arbitrary containers, define their compute requirements, and execute code within them, all programmatically in Python.

Key benefits of Modal Sandboxes for Hunch included:

• Security: Sandboxes allow running untrusted code in a secure and isolated environment. Network access can be blocked and the containers are ephemeral, torn down after each execution.
• Performance: Modal is designed from the ground up for extremely fast cold-start times. Especially when installing dependencies on the fly, Modal’s optimizations were critical for Hunch to achieve the low-latency experience users needed.
• Scalability: With Modal handling the infrastructure, Sandboxes can automatically scale up and down as needed based on demand, without Hunch needing to manage anything.
• Simplicity: Integrating Sandboxes into Hunch was simple, requiring just a few lines of Python code to spawn a container and execute code in it. Modal abstracted away all the infrastructure complexity.
• Flexibility: Sandboxes support dynamically installing packages via pip, attaching storage volumes, and customizing the compute resources. This gives AI-generated code in Hunch a lot of power and flexibility.

Here’s a simplified example of how Hunch uses Modal Sandboxes to execute AI code snippets:

def execute_ai_code(code: str, requirements: list[str]):
    with modal.Volume.ephemeral() as disk:
        sb = modal.Sandbox.create(
            "python",
            "-c",
            code,
            image=modal.Image.debian_slim().pip_install(*requirements),
            volume={"/cache": disk},
            app=app,
        )

        sb.wait()

        if sb.returncode != 0:
            print(f"Code failed with error: {sb.stderr.read()}")
        else:
            print(f"Code output: {sb.stdout.read()}")
            print(f"Files generated: {disk.list_dir('/')}")

This spawns a new Sandbox, installs the specified packages, executes the provided code snippet, and captures any output or files generated. The Sandbox is automatically torn down after execution.

By leveraging Modal Sandboxes in this way, Hunch was able to quickly and safely add arbitrary code execution capabilities into their no-code AI platform, without getting bogged down in infrastructure complexity. This was a significant differentiator for their product.

The Result: More Powerful and Productive AI Workflows

Hunch users have been thrilled with the enhanced capabilities that code execution has unlocked.

Users have generated Python scripts to format and send workflow results to Slack webhooks on the fly:

Others have generated scripts to scrape or fetch API data based on the context of a conversation:

They have even set up full-blown test-driven development with Anthropic’s Claude Opus guiding Claude Haiku, plus code review by GPT-4:

The ability to weave code execution into AI workflows has been a game changer for Hunch’s users, making them more productive and enabling them to automate complex tasks in ways that were never before possible with AI alone.

Looking ahead, Hunch is excited to find even more innovative applications for Modal Sandboxes as they continue to push the boundaries of what’s possible with no-code AI. With Modal’s infrastructure underpinning their platform, Hunch can stay focused on their core mission: making the most powerful AI capabilities accessible to everyone through an intuitive, visual interface.

Try Hunch here!