One platform for your IT team

Transform your IT

Name: Mockarty
Author: Mockarty

Bring tasks, knowledge, development and testing tools together. Work as a team, connect your AI IDEs and delegate to native agents — at your own pace, with control over the process.

Download Documentation

Team workspace Project knowledge Development Quality & security AI agents

From scattered tools to a shared workflow.

Keep tasks, knowledge, APIs, tests and security together. Plan work, check changes and save results in one workspace.

Your team drives the work and makes decisions. Mockarty brings context and tools together.

Scroll to explore the capabilities

One team workspace

Every task has context. Your team has a shared workspace.

Plan tasks in the tracker, explore ideas on boards and keep requirements and decisions in the wiki. Link them to each other and to tests so the whole team can follow the work.

Mockarty/ Payment platformInterface illustration

Issue tracker

To do2

PAY-41Refund checks

APIMK

PAY-43Request retries

QAAK

In progress1

PAY-42Payment contract

APIAL

From backlog to delivery

Boards

Requirement Payment API Checks No duplicate charge PAY-42

Payment flow＋100%

From an idea to a clear diagram

Wiki

PAYOverviewRequirementsDecisions

Requirement

Payment contract

v3 · Version history

Idempotency

A repeated request returns the result of the first payment.

Verify a repeated request

PAY-42

From a decision to shared knowledge

One project. Tasks, diagrams and documentation share the same context.

Less switching. More meaningful work.

Bring development and testing tools alongside project tasks and knowledge. Your team shares context and keeps results in one place.

Develop without waiting on dependencies

Use service mocks and test data to develop in parallel and exercise errors, timeouts and difficult scenarios.

API checks in one workflow

Keep requests, collections and contract checks alongside load tests. Save scenarios and review the results with your team.

Browsers and devices in a shared workflow

Record and run UI scenarios in browsers and on connected devices. Place runners where your checks need to execute.

From a requirement to a test result

Keep test cases, plans, runs and reports together. Link checks to project tasks and requirements.

Delegate routine work

Native agents work with project tools and context. Connect your AI IDEs through MCP and choose which work to delegate.

APIs and integrations for your workflow

Create mocks, send requests and work with messages. Choose the protocols you need and connect your services and brokers.

HTTP / REST

Full REST API mocking with route parameters, query matching, header conditions, and dynamic response generation using 50+ faker functions.

Route parameters and pattern matching
Body, header, query param conditions
50+ faker functions for realistic data
Global, Chain, and Mock stores for stateful workflows

Client

GET /api/users/:id

Mockarty

Route + Method

Conditions (body, query, headers)

Stores (gS / cS / mS)

Faker + JsonPath templates

Mockarty

200 JSON + Headers

Client

gRPC

Upload .proto files and get fully functional gRPC mock servers with reflection support.

Proto-based mock generation
Unary and streaming support
gRPC reflection for tool compatibility

gRPC Client

protobuf RPC

gRPC ServerMockarty

.proto upload

Service + Method

Unary / Stream

gRPC Server

resolution

Mockartymock resolution

GraphQL

Mock GraphQL queries and mutations with condition-based response matching.

Query and mutation detection
Field-level condition matching

Client

POST /graphql

Mockarty

GraphQL detection

query / mutation / subscription

Conditions on variables

Mockarty

{ data, errors }

Client

SOAP / WSDL

Import WSDL definitions and auto-generate SOAP mock services with proper XML envelope handling.

WSDL import and auto-generation
SOAPAction header matching

SOAP Client

XML Envelope + SOAPAction

Mockarty

WSDL import

Path + Action + Method

XML → JSON conditions

Mockarty

SOAP Response / Fault

SOAP Client

WebSocket

Mock bidirectional WebSocket communication with event-based response patterns.

Event-based message matching
Bidirectional communication support

WS Client

events

WS ServerMockarty

serverName

event + data

bidirectional

WS Server

resolution

Mockartymock resolution

Server-Sent Events

Mock Server-Sent Events streams with configurable event types and intervals.

Configurable event streams
Custom event types and intervals

Client

GET /events/* Accept: text/event-stream

Mockarty

Path + Event name

Event chain

Loop + Heartbeat + Delay

Mockarty

data: {...}

Client

MCP (Model Context Protocol)

Model MCP tools, resources and prompts to test AI integrations. Generate standalone MCP servers for your scenarios.

Tool, resource, and prompt support
Works with Cursor, Claude, Windsurf
Generate standalone MCP servers

AI AgentCursor / Claude / Windsurf

JSON-RPC 2.0

MockartyMCP :5772

tools/call

resources/read

prompts/get

Mockarty

{ result } / { error }

AI Agent

Apache Kafka

Native Kafka mocking and real-cluster integration: test publishing, consumption, and event handling in one workspace.

Publish and consume against a real cluster
Mock payloads resolved via Mockarty

Kafkaorders.created

consume messages

Mockartynative

Message enters the resolver

Conditions (topic, body, headers)

Action: response + output config

Mockarty

find mock

Mockartyadmin node

Publish to different topic / cluster

Webhook (optional)

RabbitMQ

Native AMQP mocking and RabbitMQ integration: test queues, routing, and message handling in Mockarty.

Publish and consume against a real broker
Mock payloads resolved via Mockarty

RabbitMQnotifications

consume messages

Mockartynative

Message enters the resolver

Conditions (queue, exchange, body)

Action: response + output config

Mockarty

find mock

Mockartyadmin node

Publish to different queue / exchange

Webhook (optional)

NATS

Connect NATS clients to Mockarty and test event-driven scenarios with native message mocking.

Subject-based publishing and subscriptions
Message matching and mock responses
Request / reply scenarios

NATS Client

PUB orders.created

MockartyNATS

Subject · Headers · Payload

Message matching and mock responses

Request / Reply

Mockarty

MSG orders.result

Subscriber

SMTP

Mock SMTP servers for testing emails, notifications and bounce handling. The built-in server accepts real SMTP connections with STARTTLS support.

5 condition types: sender, recipient, subject, body, headers
Configurable SMTP response codes (250, 550, 421, etc.)

Applicationsends email

SMTP :2525

SMTP Servernative

Parse email (from, to, subject, body)

Conditions (sender, recipient, subject)

Action: accept / reject / delay

SMTP Server

find mock

Mockartyadmin node

Web mailbox interface

STARTTLS with auto-certificates

Start with an existing API contract

Use specifications and recorded traffic to prepare mocks and scenarios. Spend less time entering data and get to integration checks sooner.

OpenAPI / Swagger

Import OpenAPI / Swagger to generate REST mocks from your specification

.proto / gRPC

Upload .proto files to generate fully functional gRPC mock servers

WSDL / SOAP

Import WSDL definitions to auto-generate SOAP mock services

GraphQL Schema

Define GraphQL queries and mutations to create mock resolvers

MCP Schema

Describe MCP tools and resources in JSON — generate standalone MCP servers for AI agents

HAR (Traffic Recording)

Import recorded traffic from HAR files and use it to create mocks

Server Generator

Generate production-ready servers from API specs. Generated servers run autonomously with their own cache and resolve mocks through Mockarty.

OpenAPI

.proto

WSDL

GraphQL

MCP

Server Generator CLI

gRPC

WebSocket

Kafka

RabbitMQ

SSE

SOAP

MCP

Mockarty Central storage for mocks, conditions, and stores

Local Cache Each server caches mocks for speed and load testing

APIs, data and integration scenarios

Prepare data, run checks, analyse results and automate work — use what your project needs.

Stateful Mocking

Global, Chain, and Mock stores for complex workflows like order processing and auth flows

50+ Faker Functions

Generate realistic names, emails, UUIDs, dates, addresses, and more

Advanced Conditions

JsonPath, regex, body/header/query matching with AND logic

Proxy Mode

Forward to real services, inject delays, replace headers, test timeouts

OneOf Responses

Return different responses randomly or in order — simulate flaky services

Code Generators

Generate standalone servers for MCP, gRPC, GraphQL, SOAP, SSE, WebSocket, Kafka, RabbitMQ

Built-in API Tester

Postman-like tool with collections, environments, variables, and test scripts

Check quality from different angles

Manage testing and run functional, load and security checks alongside project tasks.

Test management

Test cases, plans, runs and reports. Links to tasks and requirements help you see what has been checked.

Browsers and devices

Record and run UI scenarios. Connect browser and device runners to the environment you need.

Load and performance

Load scenarios, metrics and distributed runners to test how your service behaves under load.

Fuzzing and edge cases

Test unexpected inputs and analyse the errors they reveal.

API compatibility

Check contracts and schemas, and track changes and differences between services.

Security and Red Team

Investigate vulnerabilities and test defences in your own environment with specialist tools.

Resilience to failures

Model delays, errors and infrastructure failures. Check how your system behaves when things go wrong.

Find the holes before attackers do

A full red-team module, built in — AI agent or manual, all on your own infrastructure.

AI security agent

On-premise

Autonomous personas plan, scan and triage into one report.

Security agents are not included in the base offering.

50+ scanners

OWASP API Top-10, injection, auth, BOLA, misconfig, TLS, CVEs.

Fuzzing

Mutate real traffic to crash edge cases before prod does.

On-prem & air-gapped

Deploy inside your perimeter. Configure local dependencies to operate without external services.

Access control & audit

Namespace isolation and auditing. Configure SIEM export and PII encryption separately.

Chaos Engineering for Kubernetes

Controlled failures in your K8s cluster: kill pods, sever the network, prove resilience — all from Mockarty.

Pod Termination

Selectively kill pods to test self-healing and failover behavior

Network Chaos

Network partitions, DNS spoofing, and service isolation via NetworkPolicy

Presets & Scheduling

6 ready-made chaos scenarios (Chaos Monkey, Scale to Zero, etc.), run on cron schedule or from CLI

Observability

Cluster topology dashboard, real-time experiment logs, and recovery metrics

Contract Testing

Keep API contracts, check compatibility and track differences from schemas. Use the results before releasing changes.

Public API Registry

Centralized registry of API contracts. Publish, discover, and subscribe to contract changes across teams.

OpenAPIgRPCGraphQLAsyncAPIWSDL

Mock Drift Detection

Automatically detect when mocks diverge from real API schemas. Get alerts before bugs reach production.

Mock

Real API

14% drift

Pact Violation Tracking

Consumer-driven contract testing. Track pact violations across services and teams with detailed reports.

auth-service → user-api

payment-svc → billing-api

order-svc → inventory-api

gateway → analytics-api

For developers and QA

Project tasks, requirements and knowledge alongside engineering tools
Mocks and test data for parallel development and difficult scenarios
APIs, UIs, load and contracts — checks in one workspace
Saved scenarios and results for team collaboration
Your AI IDE with MCP access to tools and knowledge

For team leaders

One platform — fewer separate tools and context switches
Shared tasks, knowledge and results make progress easier to follow
Security — RBAC, namespace isolation, audit trail
Place components and runners to meet your team’s needs
Adopt AI gradually and set boundaries for delegation

How We Compare

Feature	Mockarty	WireMock	Postman	Mockoon
HTTP / gRPC / GraphQL	11	3	3	2
SOAP / WebSocket / SSE				WS
MCP / Kafka / RabbitMQ
AI Assistant		cloud
Stateful Mocking
Code Generators
Built-in API Tester
Performance Testing
Traffic Recording
RBAC & Namespaces
On-Premise
CLI + SDK		Java

Capability	Mockarty	PactFlow	Specmatic	Microcks
API registry		broker
Mock drift detection
Pact / CDC support
Multi-protocol	11	HTTP	6	8
Spec validation
Backward compatibility
Mock generation from contracts
Can-I-Deploy gate
On-premise		$$
Fuzzing / Security
AI Assistant

Capability	Mockarty	Chaos Mesh	LitmusChaos
Pod termination
Network chaos
I/O & disk chaos
HTTP fault injection
Experiments as code		CRD	CRD
Web dashboard
Safety guardrails
CI/CD reports	JSON
Mock integration
On-premise
AI Assistant

Feature	Mockarty	Postman	k6
API Request Builder (GUI)
Collections & Folders
Environments & Variables	+ Stores
Pre/Post-Request Scripts
Load Testing		100 VU
Ramp / Staged Load
APDEX Performance Scoring
Dynamic Mock Responses		static
Postman Collection Import		N/A	converter
CI/CD Integration		Newman
Self-Hosted / On-Premise		$$

Feature	Mockarty	StackHawk
OWASP API Top-10 scanners
AI security agent	On-premise
Fuzzing
Recorded-traffic replay attacks
On-Premise / air-gapped		SaaS
CI/CD gating
RBAC & Namespaces
Integrated with mocks & API tester

Feature	TestRail	Allure TestOps	Zephyr
Test case management
Manual + automated runs
Custom fields & templates
Allure import		native
Review / approval workflow
Dashboards & widgets
Part of one testing platform			Jira
On-Premise	$$

Comparison based on publicly available documentation as of March 2026. All trademarks and product names mentioned belong to their respective owners. Mockarty is not affiliated with, endorsed by, or sponsored by any of the listed products. Feature data is sourced from official project documentation. If you are a rights holder and believe any information requires correction — contact us.

Grow with your team’s needs

From local work to distributed runners and devices. Place execution where your code, tests and data need it.

Horizontal Scaling

Add resolver nodes and runner agents on demand. Each component scales independently.

High Availability

Cluster deployments with health checks and readiness probes.

Performance

Caching, Redis and connection pooling support data access and test execution.

Work and knowledge are together. Bring in your agents.

Give your AI IDE access to project context and tools. Start with one agent and one task.

Start where you already work.

Connect Mockarty MCP to your usual AI IDE. Work with project tasks, documents, tests and tools in natural language.

Illustrative workflow

Read the refund requirements in the project wiki and prepare a test plan. Link it to the team’s task.

Codex

Mockarty MCP

Project context connected

Tracker, wiki and testing tools are available

Scenarios and results stay in the team workspace

01
Connect MCP
Give your agent access to your Mockarty workspace with the appropriate permissions.
02
Set the context
Choose a project. Connect knowledge, documents and the tools it needs.
03
Work through your agent
Describe a task. The agent uses tools and brings back a result for review.

Development teamNew teammate

Shared project memoryProject Memory · RAG

Requirements and documents

Decisions and agreements

Tasks and results

People change. Project knowledge stays.

A new colleague or another agent starts with saved requirements, decisions and results. Less repeated explanation and manual knowledge transfer.

Current knowledge, verification and project rules help maintain quality.

A built-in team of AI specialists

Agents use project knowledge and specialist tools. Delegate scenario preparation, checks and result analysis, and extend the team with your own agents.

Specialists for different tasks

Test planning, APIs and UIs, load, fuzzing, contracts and chaos. An orchestrator brings in specialists and gives them the context they need.

PlanningTestsAnalysisDataReview

Connect tools and knowledge

Connect MCP servers, APIs and knowledge bases. Configure access so agents can use the tools they need within their project permissions.

MCPOpenAPIgRPCWSDLRAGA2A

Help with engineering work

Generate tests, analyse fuzzing results, diagnose performance and work with collections alongside your scenarios and data.

TestsFuzzingLoad testingDiagnosticsLogs

Your IDEs and agents

MCP exposes Mockarty tools to your AI IDEs. A2A connects external agents for collaboration and task delegation.

CursorClaudeWindsurfA2A

Choose your model:

OpenAIClaudeGeminiMistralGroqOllamaOpenRouter

Mission illustration

How agents help your team

Project contextRequirements and constraints

Test planScenarios based on acceptance criteria

Run the checksAPIs, tests and test data

Review the resultsErrors, service responses and run results

Results for the teamScenarios and results are ready for team review

An open ecosystem for your agents.

MCP exposes tools; A2A connects agents. Build automation alongside Mockarty and work with its native specialists.

MCP

MCP: give your agent tools

Connect your instance’s MCP server. Your agent gets access to permitted operations: mocks, tests, reports, issues and knowledge.

Connect through MCP

A2A

A2A: connect agent systems

Exchange tasks between your system and Mockarty. Make the platform part of your own agent network.

Integrate through A2A

Your context is shared. Delegate more work to Mockarty.

Use the native agent network, runners and missions for controlled autonomy.

01 / ASSISTANT

From conversation to autonomous work.

Project context, planning, and handoff to a mission in one conversation.

Agent chatExample task

Add payment refunds. Follow our API contract, test retries, and prepare the changes for review.

I’ll gather context and build a plan, then bring in specialists and checks.

Project WikiRepositoryAcceptance criteria

Next step — a mission

01 Prepare changes02 Verify scenarios03 Submit for review

Draft code changes. Approval before deployment.

See how a mission runs

02 / THE MISSION

The whole task, in view.

Every step produces an artifact that informs the next.

Autonomous missionsInterface illustration

Payment servicepayments-apiRunners connected

Payment refunds

Running

Add the refund API and verify request retries.

PLAN & EXECUTION

Context gatheredAPI contract and requirements
Plan preparedTasks and acceptance criteria
Changes in progressCoding runner · payments-api
VerificationAPI · retry · regression
Result & reviewChanges, reports, findings

MISSION EVIDENCE

Change planAnalyst · prepared

Code changesCoding · in progress

Verification reportQA · pending

Approval before delivery

The next step follows product policy.

Simplified product interface. Mission data and progress are illustrative.How missions work

03 / EXECUTION

From a plan to real execution.

Code, tests, devices, and knowledge — connected to execute the mission.

Specialist network

Coding runner

Code and changes

+ validate(input)+ handle(payment)+ test(retry)

Test runners

APIs and load

Device runners

Browsers and devices

RAG runner

Knowledge and documents

Project memory + RAG

04 / CONTROL

Fewer manual steps. Decisions stay in control.

You set the limits of autonomy. Mockarty runs the mission and retains its results.

Human in the loop

The plan and key actions go through approval.

Autonomous

Work continues within configured permissions and limits.

Budget & permissionsPause the missionAction history

MISSION OUTPUT

Context survives handoffs

Changes, verification reports, and decisions remain in the project context.

Project Memory

Start with what your team needs today.

A shared workspace, agent collaboration or an autonomous mission. Choose your starting point and expand delegation at your own pace.

Open Mockarty Cloud Deploy on your infrastructure

Your process. Your infrastructure.

Choose how much to delegate and where to execute. Start with a human in the loop and expand autonomy where you are ready.

Deploy on your infrastructure

Self-hosted, Docker and Kubernetes. Place components within your own environment.

Connect your model

Configure an LLM provider or a local model. Use local dependencies for an isolated environment.

Connect on your terms

MCP, A2A and APIs for your agents, integrations and automation. Access follows permissions and licensing.

Transform your IT

From scattered tools to a shared workflow.

Every task has context. Your team has a shared workspace.

Issue tracker

Boards

Wiki

Payment contract

Idempotency

Less switching. More meaningful work.

Develop without waiting on dependencies

API checks in one workflow

Browsers and devices in a shared workflow

From a requirement to a test result

Delegate routine work

APIs and integrations for your workflow

HTTP / REST

gRPC

GraphQL

SOAP / WSDL

WebSocket

Server-Sent Events

MCP (Model Context Protocol)

Apache Kafka

RabbitMQ

NATS

SMTP

Start with an existing API contract

OpenAPI / Swagger

.proto / gRPC

WSDL / SOAP

GraphQL Schema

MCP Schema

HAR (Traffic Recording)

Server Generator

APIs, data and integration scenarios

Stateful Mocking

50+ Faker Functions

Advanced Conditions

Proxy Mode

OneOf Responses

Code Generators

Built-in API Tester

Check quality from different angles

Test management

Browsers and devices

Load and performance

Fuzzing and edge cases

API compatibility

Security and Red Team

Resilience to failures

Find the holes before attackers do

AI security agent

50+ scanners

Fuzzing

On-prem & air-gapped

Access control & audit

Chaos Engineering for Kubernetes

Pod Termination

Network Chaos

Presets & Scheduling

Observability

Contract Testing

Public API Registry

Mock Drift Detection

Pact Violation Tracking

For developers and QA

For team leaders

How We Compare

Grow with your team’s needs

Horizontal Scaling

High Availability

Performance

Work and knowledge are together. Bring in your agents.

Start where you already work.

Connect MCP

Set the context

Work through your agent

People change. Project knowledge stays.

A built-in team of AI specialists

Specialists for different tasks