Developer guide

This guide is the technical map for engineering and IT teams building custom automation capabilities directly on Rival. It outlines the platform’s developer workflow, execution runtimes, protocol standards, and enterprise deployment lifecycle.

The developer architecture map

1. Author and generate — Draft with RivalBot and define input/output execution schemas.
2. Runtime implementation — Write business logic in Python, JavaScript, Lua, or the Storm DSL.
3. Standardize — Expose capabilities over Model Context Protocol (MCP) servers.
4. Govern and publish — Enforce immutable SemVer tracking, RBAC, and administrative review.

Building a function

A function in Rival packages custom executable logic into a reusable, versioned, schema-bound endpoint that can be called by agents, workflows, or API clients.

• Manual setup — Follow the end-to-end flow in Creating a function to define input and output JSON schemas, configure execution parameters, and attach environment secrets.
• AI-assisted drafting — Use RivalBot to generate a functional first draft, initial runtime code, and a baseline schema directly from plain-language requirements.

Selecting an execution runtime

Functions execute inside isolated runtime environments. Choose based on performance requirements, external library needs, and logic complexity.

Runtime	Recommended use cases	Key characteristics
Python	Data manipulation, mathematical modeling, machine learning, SDK integrations	Full access to standard enterprise libraries and data processing tools
JavaScript (Node.js)	High-concurrency I/O, REST and GraphQL integrations, JSON payload handling	Fast cold-start times and native web protocol support
Lua	Lightweight data transformations, rule evaluation, low-latency scripting	Ultra-low execution overhead with a minimal memory footprint
Storm	Domain-specific process pipelines, custom taxonomy scripts, multi-step classification	Native DSL built for high-throughput workflow routing

Exposing capabilities via MCP

To make custom functions accessible across different AI models and agent frameworks without building a custom integration for each, Rival supports the Model Context Protocol (MCP).

• Standardized agent interface — Building as an MCP server turns your tool into a protocol-compliant capability that any compliant agent can discover and invoke dynamically.
• Decoupled execution — MCP isolates backend system logic from agent orchestration, which simplifies tool maintenance and updates.

For the protocol definition and the methods a server must implement, see What is an MCP Server.

Versioning and catalog publishing

Rival enforces strict software engineering discipline for the function lifecycle.

• Immutable semantic versioning — Published functions use explicit MAJOR.MINOR.PATCH version tags. Updating a function creates a new immutable version without breaking existing production workflows that rely on older builds.
• Marketplace distribution — Once tested, developers submit tools to the organization catalog. Depending on workspace policy, publishing to the shared catalog triggers an administrative review queue.

Governance and security integration

All developer activity operates inside enterprise governance boundaries.

• Role-based access control — Developer permissions dictate which environments, source repositories, and staging channels a user can touch.
• Connector and secret isolation — Functions reach external enterprise systems strictly through admin-vetted connectors and centralized workspace secrets. Raw API keys are never hardcoded in source files.
• Guardrails and model whitelisting — Code executes inside secure sandboxes governed by global data privacy policies, so unauthorized API calls and unmasked PII transmissions are blocked at runtime.

The recommended workflow

1. Design and draft — Use RivalBot to generate the initial function structure and JSON schema.

2. Implement logic — Write the core code in your chosen runtime: Python, JavaScript, Lua, or Storm.

3. Expose the endpoint — Wrap complex capabilities inside an MCP server for universal agent discovery.

4. Test and version — Run interactive sandbox tests, then tag the release with an immutable SemVer version.

5. Submit for review — Route the tool to the Requests queue for enterprise admin approval and global catalog publishing.

Next steps

Creating a function Walk through the end-to-end function creation process.

Building workflows Compose functions and agents into multi-step automated processes.

What is an MCP Server Protocol definitions, supported methods, and MCP server setup.

Versions and publishing Review versioning rules and how assets reach the shared catalog.