Agent to Function Conversion

Convert agent executions into reusable function code

AI agent instructions

Read the Notte skill and follow its setup instructions when setting up Notte or building browser automation. This is the shared source for CLI setup, authentication, and the browser-to-code workflow.

Convert successful agent runs into deterministic function code that can be executed faster and cheaper than agents.

Overview

After an agent completes a task, you can extract the steps as function code:

from notte_sdk import NotteClient

client = NotteClient()

with client.Session() as session:
    agent = client.Agent(session=session)
    result = agent.run(task="Navigate to pricing page and extract plans")

    if result.success:
        # Convert to function code
        function_code = agent.workflow.code()
        print(function_code.python_script)

Why Convert to Functions?

Aspect	Agent	Function
Execution	AI decides each step	Predefined steps
Speed	Slower (LLM reasoning)	Faster (direct execution)
Cost	Higher (LLM tokens)	Lower (actions only)
Reliability	Can vary	Deterministic
Adaptability	Handles changes	Breaks if page changes

Use functions when:

• The task is well-defined and repeatable
• Page structure is stable
• Speed and cost matter
• You need predictable execution

Getting Function Code

As Python Script

Get executable Python code:

get-python-script.py

agent = client.Agent(session=session)
result = agent.run(task="Login and navigate to dashboard")

if result.success:
    # Get function code
    code = agent.workflow.code(as_workflow=True)

    print(code.python_script)

Example output:

from notte_sdk import NotteClient

client = NotteClient()

with client.Session() as session:
    # Step 1: Navigate to login page
    session.execute(type="goto", url="https://example.com/login")

    # Step 2: Fill email field
    session.execute(type="fill", selector="input[name='email']", value="[e-mail]")

    # Step 3: Fill password field
    session.execute(type="fill", selector="input[name='password']", value="********")

    # Step 4: Click login button
    session.execute(type="click", selector="button[type='submit']")

    # Step 5: Wait for dashboard
    session.execute(type="goto", url="https://example.com/dashboard")

As Function Object

Create a reusable function:

create-function-object.py

result = agent.run(task="Extract product data")

if result.success:
    # Create function from agent
    function = agent.workflow.create_function()

    print(f"Created function: {function.function_id}")

    # Run function later
    function_result = function.run()

Running Functions

Execute Generated Code

Review the generated Python before running it:

Generated workflows contain LLM-produced code and should be treated as untrusted. Inspect the entire file, then run it only in an isolated environment with the minimum required permissions.

# Generated from agent
from notte_sdk import NotteClient

client = NotteClient()

with client.Session() as session:
    session.execute(type="goto", url="https://example.com")
    session.execute(type="click", selector="button.search")
    session.execute(type="fill", selector="input[name='query']", value="laptop")
    data = session.scrape(instructions="Extract product names")

print(data)

Before testing the saved file:

1. Use a disposable container or virtual machine with no host or home-directory mounts.
2. Provide only short-lived, minimum-scope credentials; generated code can read and transmit every value you expose.
3. Restrict network access to the destinations the workflow requires, when possible.
4. Destroy the environment and revoke its credentials after the test.

Use Function API

Run via the function endpoint:

use-function-api.py

agent.run(task="Complete task")

# Create function from successful agent
function = agent.workflow.create_function()

# Run it again whenever you need (it replays the agent's steps)
for _ in range(3):
    result = function.run()
    print(result.result)

Use Cases

1. Prototyping with Agents

Use agents to figure out the automation, then convert:

prototyping-with-agents.py

# Phase 1: Prototype with agent
agent = client.Agent(session=session)
result = agent.run(task="Find all products under $100")

if result.success:
    # Phase 2: Convert to function for production
    code = agent.workflow.code()

    # Save for production use
    with open("production_function.py", "w") as f:
        f.write(code.python_script)

2. Scheduled Tasks

Convert one-time agent runs to scheduled functions:

scheduled-tasks.py

agent = client.Agent(session=session)
result = agent.run(task="Extract daily price changes")

# Convert to function
function = agent.workflow.create_function()

# Schedule it to run daily: see Function Schedules
print(f"Function ID to schedule: {function.function_id}")

Then schedule the function by its ID, as described in Function Schedules.

3. Cost Optimization

Run agents once, then use cheaper functions:

cost-optimization.py

agent = client.Agent(session=session)
result = agent.run(task="Complex data extraction")

# Recurring: replay the steps as a function (no LLM reasoning)
function = agent.workflow.create_function()

# Run it as often as you need
for i in range(100):
    function.run()

4. Testing Variations

Create function templates from agents:

testing-variations.py

# Base workflow from agent
agent = client.Agent(session=session)
result = agent.run(task="Search and extract results")

code = agent.workflow.code()

# Modify code for variations
# - Different search queries
# - Different extraction logic
# - Different URLs

Customizing Generated Code

Add Parameters

Make functions reusable with parameters:

add-parameters.py

import textwrap

from notte_sdk import NotteClient

client = NotteClient()
with client.Session() as session:
    agent = client.Agent(session=session)
    agent.run(task="Complete task")

# Steps only (no imports, client or session boilerplate)
steps = agent.workflow.code(as_workflow=False).python_script

# Wrap the steps in a parameterized function
customized_code = f"""
from notte_sdk import NotteClient


def run(search_query: str, max_results: int = 10):
    client = NotteClient()
    with client.Session() as session:
{textwrap.indent(steps, " " * 8)}
"""

# Edit the steps to use search_query and max_results, then save
with open("extract_products.py", "w") as f:
    f.write(customized_code)

Add Error Handling

Enhance with production-ready error handling:

add-error-handling.py

import textwrap

from notte_sdk import NotteClient

client = NotteClient()
with client.Session() as session:
    agent = client.Agent(session=session)
    agent.run(task="Complete task")

# Steps only (no imports, client or session boilerplate)
steps = agent.workflow.code(as_workflow=False).python_script

enhanced_code = f"""
from loguru import logger
from notte_sdk import NotteClient


def run():
    client = NotteClient()
    try:
        with client.Session() as session:
{textwrap.indent(steps, " " * 12)}
        return {{"success": True}}
    except Exception as e:
        logger.error(f"Function failed: {{e}}")
        return {{"success": False, "error": str(e)}}
"""

with open("function_with_error_handling.py", "w") as f:
    f.write(enhanced_code)

Optimize Selectors

Review and improve generated selectors:

optimize-selectors.py

# Generated code might use:
session.execute(type="click", selector="div.container > button:nth-child(3)")

# Optimize to:
session.execute(type="click", selector="button[data-testid='submit']")

Best Practices

1. Test Generated Functions

Always test before production:

test-generated-functions.py

    agent.run(task="Complete task")

    # Generate function code
    code = agent.workflow.code()

# Save for review before isolated execution
with open("generated_function.py", "w", encoding="utf-8") as generated_file:
    generated_file.write(code.python_script)

print("Saved generated_function.py. Review it, then run it in a disposable container or virtual machine.")

2. Document the Source

Track which agent generated the function:

document-the-source.py

result = agent.run(task="Extract product data")

function = agent.workflow.create_function()

# Keep a record of where the function came from (e.g. in your repo)
metadata = {
    "function_id": function.function_id,
    "agent_id": agent.agent_id,
    "original_task": "Extract product data",
    "created_at": datetime.now().isoformat(),
    "agent_success": result.success,
}
with open(f"function_{function.function_id}.json", "w") as f:
    json.dump(metadata, f, indent=2)

3. Version Control

Store functions in git:

version-control.py

from pathlib import Path

from notte_sdk import NotteClient

client = NotteClient()
with client.Session() as session:
    agent = client.Agent(session=session)
    agent.run(task="Extract products")

    # Save function code
    code = agent.workflow.code()

    function_path = Path("functions/extract_products.py")
    function_path.parent.mkdir(exist_ok=True)
    function_path.write_text(code.python_script)

# Commit to git
# git add functions/extract_products.py
# git commit -m "Add product extraction function from agent run"

4. Monitor Function Success

Track if functions continue to work:

monitor-function-success.py

from datetime import datetime

from loguru import logger
from notte_sdk import NotteClient

client = NotteClient()


def run_monitored_function():
    function = client.Function(function_id="func_abc123")
    # raise_on_failure=False returns failed runs instead of raising
    result = function.run(raise_on_failure=False)

    if result.status == "closed":
        logger.info(f"Function succeeded at {datetime.now()}")
    else:
        # Function broken - maybe the page changed?
        # Time to re-run the agent and regenerate
        logger.error(f"Function failed: {result.result}")

5. Regenerate When Pages Change

When functions break, use agents to update:

regenerate-when-pages-change.py

# Old function failing
try:
    old_function.run()
except Exception:
    print("Function broken, regenerating...")

    with client.Session() as session:
        # Use agent to figure out new function
        agent = client.Agent(session=session)
        result = agent.run(task=original_task_description)

        if result.success:
            # Generate new function
            new_function = agent.workflow.create_function()
            print(f"New function created: {new_function.function_id}")

Limitations

Functions work best for:

• ✅ Stable, unchanging pages
• ✅ Deterministic tasks
• ✅ Known sequences of actions

Functions are not suitable for:

• ❌ Pages that change frequently
• ❌ Tasks requiring adaptation
• ❌ Complex decision-making

When pages change or tasks become complex, revert to agents.

Next Steps

Functions

Deploy automations as serverless APIs

Actions

Available session actions

Agent Configuration

Optimize agent runs

Functions

Deploy and manage serverless functions