Tools

Introduction

Skyramp Agentic Tools provide a comprehensive suite of capabilities designed to be consumed by AI agents and Model Context Protocol (MCP) implementations. These tools enable intelligent automation of test generation, execution, and optimization workflows through natural language interactions.

Tool Design

Skyramp Agentic tools fall into two primary categories based on their implementation approach:

Deterministic Core Library-Based Tools

These tools provide an interface to Skyramp Core Library functions to generate tests through deterministic algorithms and rule-based logic. They operate by systematically analyzing structured inputs such as API specifications, trace files, and configuration parameters, then applying predefined transformation rules to produce reliable, predictable test outputs. The design philosophy centers on consistency and reproducibility—given the same inputs, these tools will generate identical or functionally equivalent tests every time. This deterministic approach ensures that test generation follows explicit, traceable logic paths, making the process transparent and debuggable.

These tools are purpose-built for structured testing scenarios where specifications and contracts are well-defined. They excel at transforming formal documentation (like OpenAPI schemas) into executable test code, converting captured application traces into test scenarios, and generating tests that validate against explicit contracts and specifications. The core library implements sophisticated parsing and code generation algorithms that understand API structures, HTTP protocols, and testing framework conventions, enabling the creation of production-ready test code without requiring manual intervention or interpretation.

LLM-Based Tools

These tools harness Large Language Models to provide intelligent analysis, management, and optimization capabilities for testing workflows. They function by processing unstructured or semi-structured inputs—such as existing codebases, test files, code changes, or natural language descriptions—and using AI reasoning to understand context, identify patterns, and make strategic decisions. The design philosophy emphasizes adaptability and contextual awareness, allowing the tools to understand code semantics, infer relationships between components, and provide intelligent recommendations even when information is incomplete or ambiguous.

These tools are purpose-built for analysis and management scenarios requiring deep contextual understanding, pattern recognition, and intelligent decision-making. They excel at analyzing codebases to understand architecture and testing readiness, evaluating priority of different test types based on codebase characteristics, generating actionable recommendations with ready-to-use commands, identifying opportunities for code reuse and optimization across test files, and intelligently determining which tests are relevant to specific code changes. The LLM component enables semantic understanding of code relationships, intelligent matching of similar functionality across files, and the ability to adapt recommendations and optimizations based on existing codebase patterns and conventions.

Complementary Usage

These two categories of tools are designed to work autonomously or in combination, creating a comprehensive testing ecosystem. Deterministic tools provide the foundation for reliable, specification-driven test generation and execution, while LLM-based tools add intelligence for analysis, management, and optimization. Together, they enable agents to analyze codebases to understand testing needs, evaluate priority and recommend optimal test strategies, generate tests from various sources using deterministic tools, execute and validate tests across different environments, optimize test suites through intelligent code reuse and modularization, and provide continuous feedback and improvement suggestions based on code changes and test results.

Tool Categories

Test Generation Tools

Test Generation Tools form the core of Skyramp's testing capabilities, enabling automated creation of various test types from different sources including API specifications, captured traces, and natural language descriptions.

Generate Contract Test

This tool generates contract tests that verify API implementations match their OpenAPI or Swagger specifications. It's ideal for validating API responses against schema definitions, ensuring request and response contracts are maintained, and catching breaking changes in API implementations.

The tool requires an API schema file and endpoint configuration including the base URL and HTTP method. You can provide sample request and response data to validate against, configure assertion options for body values, and specify path parameters, query parameters, or form parameters as needed. The tool supports authorization headers for authenticated endpoints and allows you to skip SSL verification for testing environments. You can choose your target language and testing framework, and configure the runtime environment as local, Docker, or Kubernetes.

Generate Integration Test

This tool generates integration tests that chain multiple API calls together, using responses from one request as inputs to subsequent requests. It's particularly useful for testing complete workflows like create-read-update-delete sequences, validating data consistency across multiple endpoints, and testing complex business processes involving multiple API calls.

The tool accepts all the same parameters as contract test generation, but adds powerful chaining capabilities through the `chainingKey` parameter, which specifies the JSON path for extracting values from responses to use in subsequent requests. It can optionally work from backend trace files to automatically generate chained test sequences. The tool supports code reuse from existing test files to avoid duplication and can create modularized, parameterized test functions for better maintainability.

Generate Smoke Test

This tool generates lightweight smoke tests for quick health checks and basic API validation. Smoke tests are perfect for verifying API availability and basic functionality, running quick regression tests after deployments, and integrating into CI/CD pipelines for fast feedback.

The tool uses similar configuration to contract tests but is optimized for speed and simplicity. It focuses primarily on status code validation and basic response structure checking, with minimal assertion complexity to enable faster execution. These tests serve as a first line of defense to quickly identify if critical API endpoints are functioning.

Generate Fuzz Test

This tool generates fuzz tests that send malformed, unexpected, or edge-case inputs to discover security vulnerabilities and robustness issues. Fuzz testing is essential for security testing and vulnerability discovery, input validation testing, and exploring edge cases and boundary conditions.

The tool automatically generates various types of malformed inputs including invalid data types, boundary values, special characters, and malformed JSON structures. It tests how your API handles unexpected inputs and helps identify potential security vulnerabilities or crash conditions. The tool shares configuration parameters with contract test generation but focuses on generating diverse input variations to stress-test your API's error handling.

Generate Load Test

This tool generates load and performance tests to validate API behavior under various traffic conditions. Load testing is crucial for performance benchmarking, capacity planning, stress testing, and bottleneck identification.

In addition to standard endpoint configuration, this tool requires load-specific parameters including test duration, number of concurrent threads, target requests per second, and rampup configuration. You can specify how quickly the load should increase to target levels through rampup duration and interval settings. The tool can execute the load test multiple times for statistical reliability. Load tests help you understand how your API performs under realistic traffic conditions and identify performance degradation points.

Generate UI Test

This tool generates UI tests from captured Playwright traces, converting user interactions into automated test scripts. It's perfect for automating repetitive UI testing, creating regression tests from manual testing sessions, and documenting user workflows as executable tests.

The tool requires a Playwright frontend trace file captured during user interactions. You can specify your target language and testing framework, enable code reuse to leverage existing test functions, and enable modularization to create parameterized, reusable test components. The tool analyzes the trace to extract selectors, user interactions, and navigation patterns, then generates idiomatic test code that accurately reproduces the recorded behavior while optimizing for maintainability and readability.

Generate End-to-End Test

This tool generates comprehensive end-to-end tests that validate entire user journeys from UI interactions through backend services. E2E tests are essential for full application flow testing, integration of frontend and backend validation, and ensuring critical business workflows function correctly across all layers.

The tool requires both a Playwright frontend trace and a backend trace file to capture the complete application behavior. It supports authorization headers for backend API calls and can enable code reuse and modularization for better test organization. The tool intelligently combines UI interactions with backend validations, ensuring that user actions produce the expected effects both in the interface and in the underlying data and services. This provides the most comprehensive testing approach for validating complete user experiences.

Generate Scenario

This tool generates test scenarios from natural language descriptions, automatically mapping them to API calls using OpenAPI specifications. It's ideal for rapid test creation from requirements, enabling business analysts to describe tests in plain language, and supporting exploratory testing automation.

The tool requires a short, descriptive scenario name and a natural language prompt describing what you want to test. You must provide an OpenAPI schema (as a file path or URL) and specify the destination host. The AI parses your description to determine the appropriate HTTP method, API path, request body, expected response, and status code. You can optionally provide a base URL if not specified in the schema. The tool excels at translating business requirements into technical test implementations without requiring detailed API knowledge.

Trace Collection Tools

Trace Collection Tools enable capturing of real application behavior, which can then be used to generate accurate and realistic tests. These tools capture both frontend user interactions through Playwright and backend API calls, creating a complete picture of application behavior that can be transformed into automated tests.

Start Trace Collection

This tool initiates trace collection for capturing user interactions and backend API calls. It's essential for recording user sessions that can be converted into tests, capturing production-like behavior patterns, and documenting complex workflows for automation.

For authenticated applications, you can provide a path to saved session storage to avoid manual login during each trace collection. The tool allows you to specify browser viewport size to match your target device or resolution, supporting presets like HD, Full HD, 2K, or custom dimensions. For backend tracing, you can deploy workers in Docker or Kubernetes environments, specifying network configuration and port settings. Service-level filtering through include and exclude parameters lets you focus traces on specific components of your application.

Stop Trace Collection

This tool stops trace collection and saves captured traces to specified files. Use it to complete your trace recording session, save traces for subsequent test generation, and export traces for analysis or sharing.

When stopping collection, you can provide output filenames for both the Playwright trace (typically a ZIP file) and the backend trace (typically a JSON file). You can specify an output directory for organized storage and provide the worker container name for proper cleanup of trace collection infrastructure. The tool ensures all collected data is properly saved and trace collection resources are cleaned up.

Analysis & Optimization Tools

Analysis & Optimization Tools help understand codebases, recommend testing strategies, and improve test quality through code reuse and modularization.

Analyze Repository

This tool analyzes a code repository to understand its structure, technology stack, and testing readiness. It's invaluable for quickly understanding new codebases, assessing current testing readiness, and identifying testing opportunities across the application.

You provide the absolute path to the repository you want to analyze. You can choose between a quick scan for rapid feedback or a full comprehensive analysis for detailed insights. Optionally, you can specify focus areas like 'api', 'frontend', or 'infrastructure' to concentrate the analysis on specific aspects of your codebase.

The tool identifies your technology stack including languages, frameworks, and libraries. It discovers API endpoints, detects frontend frameworks, identifies database and infrastructure components, and assesses existing test coverage. The analysis includes documentation quality assessment and provides a testing readiness score with recommendations for improvement.

Map Tests

This tool calculates priority scores for different Skyramp test types based on repository analysis. It helps you prioritize testing efforts, identify the most valuable tests to implement first, and optimize your overall testing strategy based on your specific application characteristics.

The tool takes the analysis report from `skyramp_analyze_repository` and evaluates how well each test type aligns with your codebase. You can provide custom weight multipliers to emphasize certain test types based on your priorities, or focus the evaluation on specific test types if you're only interested in a subset. The scoring considers technology stack compatibility, API surface area, code complexity metrics, risk assessment, and return on investment potential.

The output provides priority scores for each applicable test type along with clear rationale explaining why certain tests scored higher. It recommends an optimal order for implementing different test types based on your specific application needs.

Recommend Tests

This tool generates actionable test recommendations with ready-to-use generation prompts. It provides specific, implementable guidance for creating your test suite, helping you bootstrap test creation with clear next steps.

The tool takes both the priority scores from test mapping and the original repository analysis to create comprehensive recommendations. You can specify how many recommendations you want (default is top 5) and set a minimum score threshold to filter out low-priority suggestions. Each recommendation includes a rank, ready-to-use generation commands with all necessary parameters filled in, clear rationale explaining why this test is recommended, and implementation guidance for getting started.

Code Resuse

This tool finds and reuses existing test functions from the workspace to avoid code duplication. It's essential for maintaining DRY (Don't Repeat Yourself) principles in your test suite, improving test maintainability by centralizing common functionality, and reducing overall code duplication across test files.

You provide the path to a test file that needs code reuse optimization. The tool scans your workspace for existing test files (looking for Skyramp-generated tests by default), identifies reusable functions that could benefit the target test file, suggests appropriate imports and function calls, and updates the test file to leverage existing code rather than duplicating functionality.

The LLM intelligently matches functionality across test files, understanding semantic similarity even when function names differ. It generates proper import statements, refactors test code to use shared functions, and ensures the updated tests maintain their original behavior while leveraging the reused code.

Code Modularization

This tool modularizes test files after code reuse, creating parameterized and well-organized test functions. It's ideal for improving test organization and structure, creating parameterized test functions that can handle multiple test cases, and enhancing overall test maintainability and readability.

You provide the path to a test file that should be modularized. This tool is typically run after code reuse has been completed to further optimize the test structure. The tool analyzes the test file to identify modularization opportunities, extracts common patterns that can be parameterized, creates reusable functions with clear parameters, and refactors the test file into a more maintainable structure.

The LLM understands testing best practices and applies them to restructure your tests. It creates fixtures, helper functions, and parameterized tests where appropriate, while maintaining test clarity and ensuring all test cases remain properly covered.

Utility Tools

Utility Tools provide supporting functionality for authentication, API analysis, and other common tasks.

Read Files

This tool efficiently reads multiple files in batches for analysis or processing. It's useful for bulk file analysis, efficient context gathering across multiple files, and processing collections of files in your workspace.

You provide an array of file paths (either relative to workspace root or absolute paths). The tool reads them in configurable batches (default 20 files per batch) with specified text encoding (default UTF-8). It includes error handling for individual files so that problems with one file don't prevent reading others. This tool is particularly helpful when agents need to gather context from multiple files efficiently.

Login

This tool authenticates users with Skyramp services. It's used for initial setup and configuration, establishing authenticated sessions, and gaining access to cloud-based Skyramp features.

The tool manages secure authentication flow, handles token management for subsequent operations, and persists session information for continued use. Once authenticated, you can access premium features, save test results to the cloud, and leverage Skyramp's infrastructure for test execution.

Logout

This tool logs out from Skyramp services. It's important for session cleanup, following security best practices, and switching between different user accounts.

The tool invalidates authentication tokens, cleans up session data, and ensures a secure logout process. After logout, you'll need to authenticate again to access Skyramp cloud features.

Parse Open API

This tool analyzes OpenAPI specifications to identify required path parameters and other API details. It helps you understand API requirements before generating tests, validate API specifications for completeness, and extract detailed parameter information including types and constraints.

You provide the path to an OpenAPI specification file and optionally a specific endpoint URL to analyze. The tool extracts required and optional path parameters, identifies parameter types and validation constraints, and provides comprehensive endpoint metadata. This information is particularly useful when preparing to generate tests or when you need to understand API requirements.

Execute Test

This tool executes Skyramp-generated tests in the specified environment. It's used for running generated tests as part of CI/CD pipelines, validating test functionality during development, and executing comprehensive regression test suites.

You provide the path to the test file (either relative to the workspace root or as an absolute path), specify the test type (integration, contract, smoke, fuzz, load, e2e, or ui), and indicate the programming language of the test. The workspace path helps locate dependencies and configuration. Tests can be executed in local, Docker, or Kubernetes environments depending on how they were generated and your infrastructure setup.

Verify with Skyramp

This tool verifies code changes by running appropriate Skyramp tests. It's perfect for pre-commit verification, automating code review validation, and enabling continuous validation during development.

The tool automatically identifies which tests are relevant to your code changes and executes them to provide quick feedback on code quality. It integrates seamlessly into development workflows to catch issues early, before they reach production or even before commits are finalized. This enables a fast feedback loop for developers making changes.