Usage Limits & Optimization

Understanding platform limits and optimization strategies for efficient resource usage.

Overview

Noorle's built-in capabilities are designed for high performance with generous limits. This guide covers usage boundaries and optimization techniques for maximizing efficiency while managing costs.

Capability Limits

Web Fetch

Limit	Value	Notes
Response Size	200KB	Included per request
Large Responses	>200KB	Count as multiple requests
Timeout	30 seconds	Configurable
Rate Limit	100/minute	Per user
Cache Duration	15 minutes	Automatic

Optimization Tips:

• Use cache for repeated fetches
• Request only needed content types
• Batch related fetches

Web Search

Limit	Standard	Deep
Query Length	200 chars	500 chars
Results per Search	10	20
Rate Limit	60/minute	30/minute
Cache Duration	5 minutes	5 minutes

Optimization Tips:

• Use specific queries to reduce result processing
• Cache searches for recurring queries
• Choose appropriate mode for use case

Code Runner

Limit	Value	Notes
Instantiation	<10ms	Overhead per execution
Memory	128MB	Per execution
CPU Time	Max 100ms	Maximum CPU time
Timeout	30 seconds	Maximum execution time
Code Size	10KB	Maximum code length
Output Size	1MB	Console output
Package Access	Standard library only	Use VM for external packages
Network Access	Disabled	No HTTP requests
File Operations	Disabled	No file read/write
Concurrent Executions	Unlimited	Each isolated

Optimization Tips:

• Keep executions under 100ms CPU time for optimal performance
• Process data in chunks for large datasets
• Use efficient algorithms and data structures
• Consider Virtual Machine for complex operations or external packages

Virtual Machine

Limit	Value	Notes
Sizes Available	XS to XL	5 predefined sizes
vCPU Range	0.5 - 8.0	Based on selected size
Memory Range	512MB - 8GB	Based on selected size
Idle Timeout	10 minutes	Auto-terminates if idle
Containers per Session	1	One active at a time
Package Installation	Unlimited	Any Python/Node/system packages
Network	Outbound only	No inbound connections
Pricing	$0.000015/sec	Base rate (XS), larger sizes are multiples

Optimization Tips:

• Choose the right size for your workload (start small, scale up as needed)
• Use Code Runner for simple operations that don't need packages
• Monitor costs - VMs auto-terminate after 10 min idle to save money

HTTP Client

Limit	Value	Notes
Request Body	2MB	Maximum size
Response Body	2MB	Maximum size
Timeout	Configurable	Default 30s, min 1s, max 300s
Rate Limit	1000/minute	Per user
Redirects	10	Maximum chain

Optimization Tips:

• Implement retry logic with exponential backoff
• Use connection pooling for same host
• Compress large payloads

Files

Limit	Value	Notes
Per-File Size	10 MB	All scopes
Files per Scope	1,000 files	Each scope independently
working Lifetime	48 hours inactive	Automatic cleanup
input Lifetime	Persistent	Until manually deleted
output Lifetime	Persistent	Until manually deleted

Optimization Tips:

• Use working scope for temporary processing (free)
• Only store results in input/output scopes (paid)
• Clean up unneeded files to minimize storage costs

Knowledge Retrieval

Limit	Value	Notes
Query Length	500 chars	Search query
Results per Search	100	Maximum
Document Size	10MB	Per document
Index Size	10GB	Per knowledge base
Concurrent Searches	100/second	Per knowledge base

Optimization Tips:

• Pre-filter with metadata before searching
• Use appropriate chunk sizes
• Cache frequent queries

Plugins (WASM)

Limit	Value	Notes
Memory	128MB (default), 512MB (max)	Per invocation
CPU Time	Max 100ms	Per request
Timeout	30 sec (default), 120 sec (max)	Configurable per plugin
Module Size	10MB	Compressed npack file
Languages	Python, TypeScript, JavaScript, Rust, Go	Plus any WASM-compatible language

Optimization Tips:

• Configure memory limits based on your workload (up to 512MB max)
• Set appropriate timeout for your plugin's operations (up to 120 sec max)
• Optimize code for memory efficiency and quick execution
• Use efficient algorithms for compute-intensive tasks
• Keep module size small for faster deployment and lower memory footprint

Cost Optimization

Free vs Paid Resources

Always Free

• Code Runner executions
• Web Fetch (standard use)
• HTTP Client requests
• Files working scope (temporary storage)

Usage-Based Pricing

• Web Search queries
• Virtual Machine per-second compute (size-dependent)
• Files input/output scopes (persistent storage)
• Knowledge base searches

Summary

Key takeaways for optimal usage:

1. Use free resources first: Code Runner and working scope storage
2. Cache aggressively: Reduce repeated paid operations
3. Batch operations: Minimize overhead and API calls
4. Choose appropriate tools: Match capability to task requirements
5. Optimize data flow: Process in working scope, persist selectively to input/output

Next Steps

Explore Capabilities

• All Capabilities - Overview of all built-in tools
• Code Runner - Free computation resource
• Virtual Machine - Scalable compute

Platform Configuration

• MCP Gateway - Configure your gateway
• Model Routing - Optimize AI model usage
• Service Accounts - Set up API access