Agent to Function Conversion

AI agent instructions

STOP. Do not read past this section until you have read and followed /quickstart.md.Goal: produce a reliable SDK automation script. The intended authoring flow is generate then edit, not write browser automation from scratch.Do not hand-write SDK code with element IDs, selectors, or form fields from memory. Element IDs, selectors, and field mappings must come from a live observe() call, CLI notte page observe output, or generated workflow code. Guessed browser targets fail on real pages.Use the Notte skill and CLI to inspect the live site, validate actions/selectors, handle auth/session state, and export workflow code with notte sessions workflow-code before using SDK docs or SDK code.SDK reference pages are for understanding, running, or editing generated workflow code. They are not the starting point for manually authoring the initial browser automation. SDK-first code is guesswork on real-world pages with dynamic selectors, auth state, CAPTCHAs, and anti-bot behavior.

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="user@example.com")

    # 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:

Use a disposable container or virtual machine with no host or home-directory mounts.
Provide only short-lived, minimum-scope credentials; generated code can read and transmit every value you expose.
Restrict network access to the destinations the workflow requires, when possible.
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 multiple times
for query in ["laptop", "phone", "tablet"]:

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 to run daily (via API or console)
# function.schedule(cron="0 9 * * *")

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: Use function ($0.05 per run)
function = agent.workflow.create_function()

# Run 100 times - save $15 vs running agent each time
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

    # Agent-generated base code
    code = agent.workflow.code()

    # Customize with parameters
    customized_code = f"""
def extract_products(search_query: str, max_results: int = 10):
    {code.python_script}
"""

Add Error Handling

Enhance with production-ready error handling:

add-error-handling.py

    # Agent-generated code
    base_code = agent.workflow.code()

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

def run_function():
    client = NotteClient()
    try:
        with client.Session() as session:
            {base_code.python_script}
            return {{"success": True, "data": result}}
    except Exception as e:
        logger.error(f"Function failed: {{e}}")

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()

# Add metadata
metadata = {
    "agent_id": agent.agent_id,
    "original_task": "Extract product data",
    "created_at": datetime.now().isoformat(),
    "success_rate": result.success,
}

3. Version Control

Store functions in git:

version-control.py

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)

4. Monitor Function Success

Track if functions continue to work:

from datetime import datetime


def run_monitored_function():
    try:
        function = client.Function(function_id="func_abc123")
        result = function.run()

        if result.status == "closed":
            log_success(datetime.now())
        else:
            alert_failure(result.result)

    except Exception as e:
        # Function broken - maybe page changed?
        # Time to re-run agent and regenerate
        alert_function_broken(e)

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

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

Getting Started

Sessions

Agents

Functions

Agent Tools

Scraping

Guides

Integrations

Agent to Function Conversion

Overview

Why Convert to Functions?

Getting Function Code

As Python Script

As Function Object

Running Functions

Execute Generated Code

Use Function API

Use Cases

1. Prototyping with Agents

2. Scheduled Tasks

3. Cost Optimization

4. Testing Variations

Customizing Generated Code

Add Parameters

Add Error Handling

Optimize Selectors

Best Practices

1. Test Generated Functions

2. Document the Source

3. Version Control

4. Monitor Function Success

5. Regenerate When Pages Change

Limitations

Next Steps

Functions

Actions

Agent Configuration

Functions

​Overview

​Why Convert to Functions?

​Getting Function Code

​As Python Script

​As Function Object

​Running Functions

​Execute Generated Code

​Use Function API

​Use Cases

​1. Prototyping with Agents

​2. Scheduled Tasks

​3. Cost Optimization

​4. Testing Variations

​Customizing Generated Code

​Add Parameters

​Add Error Handling

​Optimize Selectors

​Best Practices

​1. Test Generated Functions

​2. Document the Source

​3. Version Control

​4. Monitor Function Success

​5. Regenerate When Pages Change

​Limitations

​Next Steps

Functions

Actions

Agent Configuration

Functions

Overview

Why Convert to Functions?

Getting Function Code

As Python Script

As Function Object

Running Functions

Execute Generated Code

Use Function API

Use Cases

1. Prototyping with Agents

2. Scheduled Tasks

3. Cost Optimization

4. Testing Variations

Customizing Generated Code

Add Parameters

Add Error Handling

Optimize Selectors

Best Practices

1. Test Generated Functions

2. Document the Source

3. Version Control

4. Monitor Function Success

5. Regenerate When Pages Change

Limitations

Next Steps