Docs: Add Notte Integration

docs.json

@@ -111,6 +111,7 @@
                 ]
               },
               "integrations/magnitude",
+              "integrations/notte",
               "integrations/stagehand",
               "integrations/valtown",
               "integrations/vercel"

integrations/notte.mdx

@@ -0,0 +1,127 @@
+---
+title: "Notte"
+---
+
+[Notte](https://www.notte.cc/) is an AI agent framework that enables you to build sophisticated browser automation tasks. By integrating with Kernel, you can run Notte agents with cloud-hosted browsers using Chrome DevTools Protocol (CDP).
+
+## Adding Kernel to existing Notte implementations
+
+If you already have a Notte implementation, you can easily switch to using Kernel's cloud browsers by connecting via CDP.
+
+### 1. Install the Kernel SDK
+
+```bash
+uv pip install kernel
+```
+
+### 2. Initialize Kernel and create a browser
+
+Import the libraries and create a cloud browser session:
+
+```python
+from kernel import Kernel
+from notte_sdk import NotteClient
+
+# Initialize clients
+kernel_client = Kernel(api_key="your-kernel-api-key")
+notte_client = NotteClient(api_key="your-notte-api-key")
+
+# Create a browser on Kernel
+kernel_browser = kernel_client.browsers.create()
+```
+
+### 3. Connect Notte to Kernel's CDP endpoint
+
+Use Kernel's CDP URL to create a Notte session:
+
+```python
+# Connect Notte to Kernel's browser via CDP
+with notte_client.Session(cdp_url=kernel_browser.cdp_ws_url) as session:
+    # Create an agent with a task
+    agent = notte_client.Agent(session=session, max_steps=10)
+
+    # Run your automation task
+    result = agent.run(
+        task="extract pricing plans from https://www.notte.cc"
+    )
+```
+
+### 4. Clean up the browser session
+
+After your automation completes, clean up the Kernel browser:
+
+```python
+kernel_client.browsers.delete_by_id(kernel_browser.session_id)
+```
+
+## Complete example script
+
+Here's a complete, runnable script that demonstrates the full integration:
+
+```python
+from kernel import Kernel
+from notte_sdk import NotteClient
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+def main():
+    # Initialize clients
+    kernel_api_key = os.getenv("KERNEL_API_KEY")
+    notte_api_key = os.getenv("NOTTE_API_KEY")
+
+    if not kernel_api_key:
+        raise ValueError("KERNEL_API_KEY not found in environment variables")
+    if not notte_api_key:
+        raise ValueError("NOTTE_API_KEY not found in environment variables")
+
+    kernel_client = Kernel(api_key=kernel_api_key)
+    notte_client = NotteClient(api_key=notte_api_key)
+
+    # Create a headful browser on Kernel
+    print("Creating browser session on Kernel...")
+    kernel_browser = kernel_client.browsers.create()
+    # print(kernel_browser.browser_live_view_url)
+
+    try:
+        # Connect Notte to Kernel's browser via CDP
+        print("Connecting Notte to Kernel browser...")
+        with notte_client.Session(cdp_url=kernel_browser.cdp_ws_url) as session:
+            # Create an agent with a task
+            agent = notte_client.Agent(session=session, max_steps=10)
+
+            # Run your automation task
+            result = agent.run(
+                task="extract pricing plans from https://www.notte.cc"
+            )
+
+            print(f"Task completed: {result.answer}")
+
+    except Exception as e:
+        print(f"Error during automation: {e}")
+
+    finally:
+        # Always clean up the browser session
+        kernel_client.browsers.delete_by_id(kernel_browser.session_id)
+        print("Browser session cleaned up")
+
+if __name__ == "__main__":
+    main()
+```
+
+## Benefits of using Kernel with Notte
+
+- **No local browser management**: Run agents without installing or maintaining browsers locally
+- **Scalability**: Launch multiple browser sessions in parallel for concurrent tasks
+- **Cloud infrastructure**: Leverage Kernel's optimized browser infrastructure
+- **Stealth mode**: Built-in anti-detection features for web scraping
+- **Session control**: Programmatic control over browser lifecycle
+
+## Next steps
+
+- Learn about [creating browsers](/browsers/create-a-browser) on Kernel
+- Check out [live view](/browsers/live-view) for debugging your automations
+- Learn about [stealth mode](/browsers/stealth) for avoiding detection
+- Explore [session persistence](/browsers/persistence) for maintaining browser state

integrations/overview.mdx

@@ -22,6 +22,7 @@ Kernel provides detailed guides for popular agent frameworks:
 - **[Computer Use (Anthropic)](/integrations/computer-use/anthropic)** - Claude's computer use capability
 - **[Computer Use (OpenAI)](/integrations/computer-use/openai)** - OpenAI's computer use capability
 - **[Magnitude](/integrations/magnitude)** - Vision-focused browser automation framework
+- **[Notte](/integrations/notte)** - AI agent framework for browser automation
 - **[Val Town](/integrations/valtown)** - Serverless function runtime
 - **[Vercel](https://github.com/onkernel/vercel-template)** - Deploy browser automations to Vercel