k-skill Performance Benchmarks: Latency Analysis for Proxy and CLI Components

k-skill delivers sub-50ms routing latency with caching and 10-30% overhead on external API calls, with skill startup times under 300ms for both Node and Python runtimes.

The k-skill repository by NomaDamas is a modular framework that stitches together purpose-specific agents ("skills") through a lightweight HTTP proxy and command-line interface. Understanding its k-skill performance benchmarks helps developers optimize integration patterns and set realistic latency expectations for production deployments.

k-skill Proxy Performance: Fastify-Based Routing and Caching

The k-skill-proxy component handles all external API normalization, validation, and caching. Implemented in [packages/k-skill-proxy/src/server.js](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-proxy/src/server.js), it uses Fastify for low-overhead request handling.

Cached vs. Uncached Request Latency

Scenario	Measured Latency	Dominant Factor
Cache hit (KOPIS performance list)	≈ 12 ms	Fastify routing + memory lookup
Cache miss (first request)	≈ 560 ms	KOPIS API network latency
Proxy overhead on external calls	10-30%	JSON parsing + validation

The proxy reduces repeat-fetch latency from seconds to under 10ms for cached entries using lru-cache. The validation layer normalizeKopisListQuery prevents expensive downstream calls for malformed queries.

Benchmark Test Reference

The repository's test suite in [packages/k-skill-proxy/test/server.test.js](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-proxy/test/server.test.js) validates these performance characteristics:

// Example: Testing cached KOPIS endpoint performance
// GET /v1/kopis/performances?start=20260101&end=20260131&limit=5
// Expected: ~12ms on cache hit, ~560ms on cache miss

k-skill CLI Performance: Skill Startup and Execution

The k-skill-cli package executes skill scripts locally. Skill implementations live in packages/k-skill-cli/skills/**/skill.json.

Runtime Startup Benchmarks

Runtime	Skill Example	Startup Time
Node.js	kopis-performance-search	< 200 ms
Python	naver-ad-performance	< 300 ms

These measurements reflect cold-start execution via npx -y @nomadamas/k-skill@0 exec ... on modern hardware.

CLI Usage Examples

KOPIS performance search via CLI:

# Resolve proxy base URL and fetch performances

BASE=$(npx -y @nomadamas/k-skill@0 path kopis-performance-search)

curl -fsS --get "$BASE/v1/kopis/performances" \
     --data-urlencode "start=20260701" \
     --data-urlencode "end=20260731" \
     --data-urlencode "limit=5"

Naver-Ad performance skill execution:

# Verify connectivity (read-only doctor mode)

npx -y @nomadamas/k-skill@0 exec naver-ad-performance scripts/naver_ad_performance.py -- doctor

# Fetch campaign statistics

npx -y @nomadamas/k-skill@0 exec naver-ad-performance scripts/naver_ad_performance.py \
    -- stats --ids 12345,67890 --since 2026-06-01 --until 2026-06-30

Source: [kopis-performance-search/instruction.md](https://github.com/NomaDamas/k-skill/blob/main/kopis-performance-search/instruction.md) and [naver-ad-performance/instruction.md](https://github.com/NomaDamas/k-skill/blob/main/naver-ad-performance/instruction.md).

External API Latency: The Dominant Bottleneck

Third-party public APIs (KOPIS, Naver-Ad, Korean public data portals) determine end-to-end response times. When the external service responds in approximately 500ms, the complete request through k-skill finishes in approximately 550ms.

Factors affecting observed performance:

• Network conditions to external APIs
• Cache hit/miss ratio in the proxy layer
• Result set size controlled by limit/rows parameters

Programmatic Proxy Access

For applications integrating k-skill directly, the proxy exposes standard HTTP endpoints:

const fetch = require('node-fetch');

async function getKopisPerformances(start, end, limit = 10) {
  const base = process.env.KSKILL_PROXY_BASE_URL || 'http://localhost:3000';
  const url = `${base}/v1/kopis/performances?start=${start}&end=${end}&limit=${limit}`;
  const resp = await fetch(url);
  if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
  return resp.json();
}

getKopisPerformances('20260701', '20260731')
  .then(data => console.log('Performances:', data));

The route handling and KOPIS-specific helpers are defined in [packages/k-skill-proxy/src/kopis.js](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-proxy/src/kopis.js).

Summary

• Proxy routing: Sub-millisecond with Fastify, ~12ms for cached responses
• Proxy overhead: 10-30% added to external API latency
• CLI startup: <200ms (Node), <300ms (Python)
• Primary bottleneck: Third-party API network latency, not k-skill internals
• Optimization target: Request-level caching and batch fetching per [docs/roadmap.md](https://github.com/NomaDamas/k-skill/blob/main/docs/roadmap.md)

Frequently Asked Questions

How fast is the k-skill proxy for cached requests?

Cached requests through k-skill-proxy complete in approximately 12 milliseconds, consisting of Fastify routing overhead and in-memory cache retrieval via lru-cache. This represents a 50x improvement over uncached network calls to external APIs.

What is the skill startup overhead for k-skill CLI?

Skill startup overhead ranges from under 200ms for Node.js skills to under 300ms for Python skills. These cold-start times include package resolution through npx and runtime initialization, measured on the repository's CI runners (2 vCPU, 4GB RAM).

Where does k-skill add latency to external API calls?

k-skill adds 10-30% overhead primarily through JSON parsing, request validation via normalizeKopisListQuery, and response normalization. For a 500ms external API response, expect approximately 550ms total end-to-end latency.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}