Appearance

When to Build Plugins ​

Build a Noorle plugin when you need to extend AI agent capabilities with functionality that doesn't exist in the platform's built-in tools. This guide helps you decide between using existing capabilities and building custom plugins.

Key Scenarios for Plugin Development ​

External Service Integration ​

  • Custom API Connections: Your agents need to interact with third-party APIs that require complex authentication, custom headers, or specialized data processing
  • Proprietary Databases: Access internal or specialized data sources with custom query logic
  • Legacy Systems: Bridge modern AI agents with older enterprise systems that lack modern APIs
  • Multi-step API Workflows: Orchestrate complex sequences of API calls with error handling and retry logic

Specialized Processing ​

  • Domain-Specific Logic: Industry-specific calculations, algorithms, or workflows (financial modeling, scientific computations, etc.)
  • Advanced Data Transformation: Complex parsing, formatting, or conversion operations beyond simple scripts
  • Stateful Operations: Multi-step processes that require maintaining state between operations
  • Performance-Critical Tasks: CPU-intensive computations that benefit from compiled WebAssembly execution

Custom Business Logic ​

  • Workflow Automation: Company-specific processes, approval chains, and business rules
  • Compliance Requirements: Regulatory or security-specific operations that must be centrally managed
  • Proprietary Algorithms: Your unique intellectual property or methodologies
  • Parameter Management: Secure handling of API keys, credentials, and configuration across teams

Reusability and Scale ​

  • Multi-Agent Functionality: Capabilities that will be used across multiple agents or projects
  • Team Collaboration: Tools that need to be shared across different teams or accounts
  • Version Control: Logic complex enough to benefit from proper testing, versioning, and rollback capabilities
  • Security Boundaries: Operations requiring isolated execution environments

When NOT to Build Plugins ​

Consider Noorle's built-in capabilities first:

Use Built-in Web Intelligence ​

  • Web Search: For real-time web information and research
  • Web Fetch: For extracting content from web pages as structured Markdown

Use Built-in Computation ​

  • Code Runner: For Python/JavaScript scripts, quick calculations, and data transformations (5-10ms response times)
  • Virtual Machine: For complex processing, data science, and ML workloads with custom packages

Use Built-in Integration ​

  • HTTP Client: For simple API calls with standard authentication and headers
  • Files: For storage with intelligent lifecycle management
  • Knowledge Retrieval: For RAG-powered search through knowledge bases

Consider Existing MCP Servers ​

  • Check if reliable and economically-priced MCP servers already handle your use case
  • Leverage community-built MCP tools before building custom solutions

Decision Framework ​

Ask yourself these questions in order:

1. Does a built-in capability already solve this? ​

→ Use the built-in capability

Noorle's built-in tools cover most common use cases with optimized performance and transparent pricing.

2. Can this be solved with a simple HTTP call? ​

→ Use the HTTP Client capability

The built-in HTTP client handles standard API integrations without plugin overhead.

3. Is there a reliable existing MCP server for this? ​

→ Use the existing MCP server

Leverage community solutions when they meet your requirements and budget.

4. Do I need custom logic, authentication, or data processing? ​

→ Consider building a plugin

Plugins provide the flexibility for complex, custom operations.

5. Will multiple agents or teams benefit from this? ​

→ Definitely build a plugin

Shared functionality justifies the development investment.

Development Effort vs. Value ​

Build a Plugin When: ​

  • Reusability: The functionality will be used across multiple agents, projects, or teams
  • Security: You need secure parameter management for API keys, credentials, or sensitive configuration
  • Complexity: The logic is complex enough to benefit from proper testing, versioning, and error handling
  • Performance: You need the speed of compiled WebAssembly for CPU-intensive operations
  • Isolation: The operation requires a secure, sandboxed execution environment
  • Maintenance: You want centralized updates and rollback capabilities

Use Other Approaches When: ​

  • One-off Tasks: Simple operations that can be handled with existing built-in tools
  • Simple Logic: Operations simple enough to embed directly in agent prompts or basic scripts
  • Rapid Prototyping: Quick testing scenarios where plugin development overhead isn't justified
  • Standard Operations: Common tasks already covered by built-in capabilities

Plugin Benefits ​

Plugins provide several advantages over other approaches:

Technical Benefits ​

  • Isolation: Secure, sandboxed execution environment
  • Performance: Near-native speed through WebAssembly compilation
  • Versioning: Automatic version management with zero-downtime deployments
  • State Management: Persistent data across tool invocations

Operational Benefits ​

  • Reusability: Share functionality across agents and teams
  • Security: Centralized parameter and credential management
  • Maintainability: Proper testing, version control, and rollback capabilities
  • Collaboration: Team-based development and deployment workflows

Real-World Examples ​

Good Plugin Candidates ​

  • Custom CRM Integration: Complex Salesforce workflows with custom field mapping and validation
  • Financial Calculations: Proprietary risk assessment algorithms with regulatory compliance
  • Document Processing: Custom parsing of industry-specific document formats
  • Workflow Orchestration: Multi-step approval processes with state management

Better Suited for Built-ins ​

  • Weather Data: Simple API calls → Use HTTP Client
  • Web Research: Finding current information → Use Web Search
  • Data Analysis: Python/R scripts → Use Code Runner or Virtual Machine
  • Temporary Storage: Session-based file operations → Use Files

Getting Started ​

If you've determined that a plugin is the right approach:

  1. Plan Your Plugin: Define the tools, parameters, and security requirements
  2. Choose Your Language: Rust, TypeScript, or Python
  3. Review Examples: Study the language-specific guides for implementation patterns
  4. Start Development: Use the Noorle CLI to scaffold your project
  5. Test and Deploy: Leverage automatic versioning for safe deployments

Next Steps ​

Remember: Plugins provide isolation, reusability, and proper security boundaries. If you find yourself repeatedly implementing similar logic across different agents, that's a strong signal to build a plugin.

© 2025 Noorle Inc. All rights reserved.