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

> Discover k-skill performance benchmarks. Analyze sub-50ms latency for proxy and CLI components, plus low overhead on API calls and fast startup times for Node and Python.

- Repository: [NomaDamas/k-skill](https://github.com/NomaDamas/k-skill)
- Tags: performance
- Published: 2026-08-04

---

**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)](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)](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-proxy/test/server.test.js) validates these performance characteristics:

```javascript
// 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`](https://github.com/NomaDamas/k-skill/tree/main/packages/k-skill-cli/skills).

### 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:**

```bash

# 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:**

```bash

# 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)](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)](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:

```javascript
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)](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)](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.