Frequently Asked Questions

No! AgentOp itself is free to use. However, if you use cloud AI providers (OpenAI or Anthropic), you'll need to pay for their API usage. Alternatively, you can use Local (wllama) models which are completely free with no API costs.

No. You can create agents using Local (wllama) without any API key. This is perfect for testing and learning. If you want to use OpenAI or Anthropic models, you'll need an API key from those providers. See our Provider Configuration guide for setup instructions.

Yes. Every agent has a "Run in Browser" page — click Try it now on the agent and it runs live on AgentOp with nothing to install. Running on the site this way is also the fastest option for Local (on-device) agents on computers without a dedicated graphics card (GPU). You can still download the agent as a standalone HTML file to run it offline — the downloaded file runs fastest on machines with a GPU or on a Mac. Either way all AI processing happens in your own browser; AgentOp only serves the agent code, never your conversations or API keys.

Basic Python knowledge is helpful but not required to get started. You can use existing templates with minimal code changes. For advanced customization, familiarity with Python functions, async/await, and basic web concepts (HTML/JavaScript) will be beneficial.

It depends on your AI provider choice:

• Local (wllama): $0 - completely free, runs in browser
• OpenAI GPT-4o-mini: ~$0.15 per million input tokens (~$0.001 per conversation)
• OpenAI GPT-4o: ~$2.50 per million input tokens (~$0.02 per conversation)
• Anthropic Claude 3.5 Sonnet: ~$3.00 per million input tokens (~$0.02 per conversation)

For most use cases, costs are minimal. Set spending limits on your API keys to control costs.

Your agent will show an error message when trying to generate responses. Users will need to either add credits to their API account or update the agent with a new API key. This is why we recommend setting usage limits when creating API keys.

Yes! You can edit your agent and change providers at any time. If costs are a concern, consider:

• Switching to Local (wllama) (free, but lower quality)
• Using GPT-4o-mini instead of GPT-4o (10x cheaper)
• Using Claude 3 Haiku instead of Sonnet (12x cheaper)

It depends on your provider choice:

• Local (wllama): 100% private - all processing happens in your browser, nothing sent to servers
• OpenAI: Conversations sent to OpenAI's servers (see their privacy policy)
• Anthropic: Conversations sent to Anthropic's servers (see their privacy policy)

AgentOp never sees your conversations or API keys. Everything runs in your browser. For the full picture — client-side encryption, generation-on-demand, and what the sponsored tier logs — see our Trust & Security page.

API keys are encrypted using AES-256 encryption before being embedded in the HTML file. The encryption happens entirely in your browser, and AgentOp never sees your plaintext keys. When you open the agent, you'll need to enter the encryption password to decrypt the key.

Yes! The best approach is to use Local (wllama) for public agents - no API key needed. Alternatively, you can share the agent code without an embedded key, and let users add their own API keys. Never share agents with embedded keys publicly, even if encrypted.

If using OpenAI/Anthropic, your API key is encrypted in the file. Without your encryption password, they cannot use it. However, as a precaution:

• Use unique encryption passwords for each agent
• Set spending limits on API keys
• Rotate keys regularly
• Monitor API usage for suspicious activity

Local GGUF models range from ~0.5GB to ~7.5GB depending on the model and quantization. Some examples:

• Qwen 3 4B (Q4_K_M): ~2.6GB (recommended default, best balance)
• Qwen 3 0.6B (Q4_K_M): ~0.5GB (smallest, fastest download)
• Llama 3.2 1B Instruct (Q4_K_M): ~0.8GB (ultra-compact)
• Hermes 3 Llama 3.2 3B (Q4_K_M): ~2.0GB
• Phi 4 Mini Instruct (Q4_K_M): ~2.5GB
• DeepSeek R1-0528 Qwen3 8B (Q4_K_M): ~5.2GB (strongest reasoning)
• Gemma 4 12B Instruct (Q4_K_M): ~7.5GB (largest, highest quality)

Models download once and are cached in your browser for future use.

Yes! After the initial download, local models work completely offline. You can even use the agent without an internet connection. The HTML file and cached model are all you need.

Local models run on your GPU via WebGPU, so you need a WebGPU-capable browser on a machine with a graphics card (or an Apple Silicon Mac):

• Chrome / Edge (desktop): Recommended — WebGPU GPU acceleration enabled
• Safari (Apple Silicon Mac): WebGPU-accelerated on the built-in GPU
• Firefox: WebGPU is rolling out — enable it, or use Chrome/Edge

A supported GPU is what makes local inference usable. Without one, a cloud provider (OpenAI or Anthropic) will give you a far better experience.

Local models are much smaller (0.6B–12B parameters vs hundreds of billions for frontier cloud models), so they're less capable:

• Good for: Simple conversations, basic Q&A, prototyping, learning
• Not as good for: Complex reasoning, specialized knowledge, creative writing

Think of local models as "good enough for many tasks" rather than "best in class." The tradeoff is worth it for privacy and zero cost.

Generally no. Local models need a WebGPU-capable GPU, and most phones don't expose one to the browser for sustained inference — so local agents are impractical on mobile. Use a desktop or laptop with a graphics card (or an Apple Silicon Mac) for local models, or pick a cloud provider (OpenAI/Anthropic), which works fine on mobile.

This usually means:

1. Wrong encryption password: Re-enter the correct password
2. API key expired or revoked: Create a new agent with a fresh API key
3. No credits remaining: Add credits to your OpenAI/Anthropic account
4. Rate limit exceeded: Wait a few minutes and try again

For Local (wllama) agents, this means the model is downloading from HuggingFace. Check:

• Internet connection is stable
• Browser DevTools Network tab to see download progress
• Sufficient disk space for the model cache
• Allow several minutes for the first download (models range from ~0.5GB to ~7.5GB)

If it keeps timing out, switch to Qwen 3 4B (Q4_K_M) — it is the recommended default model, offering the best balance of download size (~2.6 GB), speed, and function-calling capability. For very slow connections, try Qwen 3 0.6B (~0.5 GB) or Llama 3.2 1B (~0.8 GB).

Only pure-Python packages work with Pyodide. Packages with C extensions (like NumPy, pandas) must be pre-compiled for Pyodide. Check the Pyodide package list to see what's available. Most common data science packages are supported.

Open your browser's Developer Tools (F12) and check the Console tab. Pyodide errors will appear there. Common issues:

• Import errors - package not available in Pyodide
• Syntax errors - check Python code carefully
• API errors - verify API key and network connection
• Memory errors - model or code too large for browser

AgentOp agents are designed to run as standalone HTML files in browsers. While technically you could host the HTML on a server, each user would still run the code in their browser (not on your server). For server-side AI, consider using LangChain directly in a Python backend instead.

Yes! Navigate to your agent's detail page and click "Edit" to modify any aspect: Python code, description, provider, packages, etc. Download the updated version when done.

Define async def Python functions and export their schemas via get_tool_schemas():

async def search_web(query: str) -> str:
    """Search the web for information."""
    # Your implementation (e.g. call an API via js.fetch)
    return f"Results for: {query}"

def get_tool_schemas():
    return [
        {
            "type": "function",
            "function": {
                "name": "search_web",
                "description": "Search the web for information.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "query": {"type": "string", "description": "The search query"}
                    },
                    "required": ["query"]
                }
            }
        }
    ]

AgentOp handles the LangChain orchestration, tool dispatch, and provider routing automatically. See the Agent Creation guide for more examples.

Yes! Templates define the HTML/CSS/JS structure for agents. Create custom templates from the Templates page. See our Template System guide for detailed instructions.

• Download: Get the HTML file to run the agent locally
• Fork: Create your own copy on AgentOp that you can edit and customize

Fork when you want to modify an agent and save your changes. Download when you just want to use it.

Several options:

• Public listing: Set visibility to "Public" - appears in marketplace
• Direct link: Share your agent's URL (e.g., agentop.com/agents/your-agent/)
• HTML file: Share the downloaded HTML file directly
• GitHub: Upload HTML to a repository and enable Pages

Yes! Agents are standalone HTML files that can be:

• Uploaded to any web server
• Hosted on GitHub Pages
• Embedded in websites via iframe
• Included as downloadable files

For public hosting, use Local (wllama) to avoid API key issues.

Yes! Use an iframe to embed the agent HTML:

<iframe
  src="path/to/agent.html"
  width="800"
  height="600"
  style="border: none;"
></iframe>

The agent will work as a standalone component within your application.

OpenAI and Anthropic agents work well on mobile browsers. Local (wllama) agents are generally not practical on phones — they run on the GPU via WebGPU, which mobile browsers rarely expose for sustained inference. For local models, use a desktop/laptop with a graphics card or an Apple Silicon Mac; on mobile, choose a cloud provider instead.

Agents you create are yours. You own the code and can license it however you choose. AgentOp does not claim ownership of your agents. However:

• Respect the licenses of any templates you use
• Respect the licenses of Python packages you include
• Check GGUF model licenses if using local wllama models

Yes! You can create commercial agents and products using AgentOp. Make sure to:

• Review OpenAI/Anthropic terms of service if using their APIs
• Check local model licenses for commercial use restrictions
• Respect third-party package licenses