Side by Side
At a Glance
14 dimensions of comparison between Naftiko and Toolhouse — same row, different layer of the stack. Scan top-to-bottom to see where each product makes a different choice on the same axis.
Dimension
Naftiko
Toolhouse
Category
Naftiko
Spec-driven integration platform
Toolhouse
Backend-as-a-Service for AI agents — agent runtime + 40+ pre-built tool catalog + memory + RAG + MCP hub
Origin
Naftiko
Kin Lane (API Evangelist) + Jerome Louvel (Restlet → Talend → Qlik), 2025
Toolhouse
Toolhouse.ai (founded 2024) — agent infrastructure category
Primary primitive
Naftiko
Capability — declared in YAML; consumes + exposes
Toolhouse
Agent + Tool + Bundle + Run + MCP Server
Layer in the stack
Naftiko
Build-time + ship-time + runtime engine that authors integrations
Toolhouse
Hosted agent runtime — deploy agent to Toolhouse infra and they run it as a REST endpoint with streaming + state
Core artifact
Naftiko
YAML capability spec (declarative)
Toolhouse
th file (YAML agent spec) + Agent Studio visual definition + installed tool list
Open source posture
Naftiko
Apache 2.0 Framework, free Fleet community, paid Standard / Enterprise
Toolhouse
SaaS-only — Basic free (15 credits/mo), Pro $10 (100), Business $500 (15k), Enterprise custom
Multi-protocol exposure
Naftiko
REST + MCP + Skills + A2A (roadmap) — same capability, all protocols
Toolhouse
REST Workers API (streaming) + hosted MCP server + MCP client (consume remote MCPs)
Governance scope
Naftiko
Design-time (Spectral lint), admission (Kyverno / OPA), runtime engine
Toolhouse
Per-account API key + per-agent run isolation + per-plan rate limits + per-run credit metering
Discovery surface
Naftiko
Backstage capability catalog + scorecards
Toolhouse
Hosted Tool catalog (40+ tools) + Bundle marketplace + Agent marketplace + MCP Discovery (auto-wires servers from prompt)
Audit / observability
Naftiko
OpenTelemetry + Prometheus + structured logs
Toolhouse
Per-run logs + per-MCP-server logs (separate surface) + per-agent metrics + Studio chat sessions
Identity / OAuth
Naftiko
Runtime secret injection (env, ExternalSecrets); Keycloak / OpenFGA roadmap
Toolhouse
HTTPBearer JWT + per-user API keys; OAuth callback handling; centralized integrations
Cost / FinOps
Naftiko
Cost-center labels propagated to K8s; Kubecost integration
Toolhouse
Per-run credit metering (Pro $0.10/credit, Business $0.0333/credit); FOCUS-aligned billing model
Stateful memory
Naftiko
Bring your own — capabilities can consume any storage backend declaratively
Toolhouse
Built in — Toolhouse RAG (one-command vector store), conversational memory across runs, agent-attached files
Founder framing
Naftiko
“Capability fleet” — many ships, one navy
Toolhouse
“Build, deploy, run AI agents without infrastructure”
Common Ground
Where They Overlap
Both Naftiko and Toolhouse bet on the layer above per-vendor MCPs. Here are the 8 concrete places where those bets actually meet — same problem, sometimes the same shape, increasingly the same conversation.
1
Both treat MCP as first-class infrastructure
Toolhouse exposes its 40+ tools as a hosted MCP server AND ships an MCP client that auto-wires remote MCP servers based on agent prompt (MCP Discovery). Naftiko's
exposes: mcp adapter ships MCP servers from any capability YAML. Neither product treats MCP as bolted on — it's load-bearing on both sides.2
Both register a governable entity per workflow
Toolhouse registers Agents (with vanity slugs, schedules, files, memory). Naftiko registers Capabilities (with consumes, exposes, governance). Either way, the entity is the unit that gets policy applied.
3
Both ship a hosted catalog as a core moat
Toolhouse ships 40+ pre-built tools (web search, RAG, code execution, browser automation, integrations) and a Bundle marketplace. Naftiko's Backstage capability catalog organizes capabilities for discoverability. Both refuse the 'every team rebuilds the same integration' anti-pattern.
4
Both ship a per-run observability surface
Toolhouse captures per-run execution logs AND per-run MCP server logs separately — every agent invocation is replayable + auditable. Naftiko emits OpenTelemetry events from every capability container into Datadog / New Relic / Prometheus. Both refuse 'we'll figure out observability later.'
5
Both publish a FOCUS-aligned FinOps model
Toolhouse publishes a per-run credit billing model with FOCUS-aligned dimensions. Naftiko propagates cost-center labels into Kubecost for per-call attribution. Both refuse the 'no per-call cost visibility' anti-pattern.
6
Both ship CLI + spec-driven dev experience
Toolhouse ships
th CLI + YAML th files (think Vercel for agents). Naftiko's capability YAML + framework deploy is the same shape — declare in YAML, deploy as a container, manage via CLI. Both refuse GUI-only agent definition.7
Both pull agent-first UX upmarket
Toolhouse's Agent Studio + CLI + Workers API + creator marketplace target both 'vibe coders' and engineers. Naftiko's
exposes: skill + MCP adapters expose capabilities to agents directly. Both treat agents as first-class consumers.8
Both ship multi-model support
Toolhouse supports OpenAI, Anthropic, Together, Groq, NVIDIA — model-agnostic by design. Naftiko's roadmap includes Open Router routing for the same reason: customers shouldn't be locked to a single inference provider.
Where We Diverge
How Naftiko Is Different
The clearest single-sentence difference: Toolhouse is a hosted runtime for running agents; Naftiko is an open-source engine for authoring the capabilities those agents reach. Toolhouse ships and runs the agent; Naftiko ships and runs the integration layer the agent calls.
1
Hosted agent runtime vs spec-driven integration engine
Naftiko
Authors integration capabilities — consumes existing APIs / files / web pages, exposes governed REST + MCP + Skills surfaces. Customer runs the engine in their infra.
Toolhouse
Runs autonomous agents in Toolhouse-managed infrastructure — agent state, scheduling, memory, RAG, and tool wiring all hosted. Customer hands Toolhouse a prompt and a slug.
Different layers — Naftiko ships what the agent calls; Toolhouse runs the agent that does the calling.
2
Open-source-self-hosted vs SaaS-runtime-only
Naftiko
Apache 2.0 Framework runs in your container, your Kubernetes, your VPC. Open-source is the engine.
Toolhouse
Hosted SaaS only — agents run on Toolhouse infrastructure. Enterprise tier offers data residency options; standard tiers do not self-host.
3
Capabilities as the primitive vs Agents as the primitive
Naftiko
Primary identity is ‘the thing that does X’ — a functional integration unit composed from declared consumes and exposes. The agent is downstream.
Toolhouse
Primary identity is the Agent — a deployed AI worker with a prompt + model + installed tools. The integration is configured per-agent.
4
Three governance altitudes vs runtime-only governance
Naftiko
Spectral rulesets at design time, Kyverno / OPA at admission time, runtime checks in the engine. Lifecycle-shaped governance.
Toolhouse
Per-account API keys + per-agent run isolation + per-plan rate limits + per-run credit budget. Runtime-only governance — no design-time linting layer.
5
Builds MCP servers from any source vs MCP Discovery for agent prompts
Naftiko
Any consumed API (REST / file / HTML / event stream) becomes an MCP server through
exposes: mcp. The author decides the MCP shape.Toolhouse
MCP Discovery auto-detects and wires MCP servers based on the agent prompt at deploy time. The agent decides the MCP shape.
Same protocol, opposite directions. Naftiko = author the artifact; Toolhouse = wire it from intent.
6
Bring-your-own state vs built-in stateful memory + RAG
Naftiko
Stateful storage is whatever the capability declares — Naftiko consumes any backend; the engine doesn't impose a memory model.
Toolhouse
Built-in conversational memory across runs, attached files, and Toolhouse RAG (one-command vector store). State is part of the agent runtime.
7
Spec-driven integration depth vs hosted-catalog breadth
Naftiko
Customer authors any integration as a capability YAML — bring your own consume + expose + governance. Maximum customization.
Toolhouse
Toolhouse ships 40+ pre-built tools + Bundle marketplace + Agent marketplace + Creator Rewards. Maximum out-of-the-box agent-tooling breadth.
Composio is the spiritual cousin on the catalog axis; Toolhouse layers a managed agent runtime on top of the catalog story.
8
Consumes-side governance vs no consumes-side governance
Naftiko
Governs the consume side — HTTPS enforcement, PII detection, retry safety per upstream, schema validation. Owns the supply chain.
Toolhouse
Tools consume what they consume; Toolhouse doesn’t lint upstream APIs or enforce supply-chain policies. Toolhouse-as-supply-chain is one big trust boundary.
Partnership Thesis
Service Partnership
Toolhouse runs AI agents in production. Naftiko ships the integration capabilities those agents reach. The 10 capabilities below treat every Toolhouse API surface as a Naftiko-consumable one and treat every Naftiko-built MCP as a Toolhouse-discoverable one — Naftiko-built capabilities auto-wire into Toolhouse agents through MCP Discovery, Toolhouse run logs (including the MCP-server-logs surface) flow into Naftiko's OpenTelemetry pipeline, and Naftiko-governed sources can sync into Toolhouse RAG. The two products meet at the agent boundary on every dimension.
“Toolhouse runs the agent. Naftiko governs the integration layer the agent calls. Together: production AI agents that pick up Naftiko-built capabilities through MCP Discovery, with full per-run observability and unified FOCUS-aligned cost across both runtimes.”
Two First-Meeting Questions
Q1. Naftiko-built MCPs auto-wired by Toolhouse MCP Discovery
Would Toolhouse support a documented ‘register a Naftiko-built MCP’ pattern in MCP Discovery — pointing at the Naftiko
exposes: mcp adapter as the canonical way for a Naftiko-authored capability to become invocable by any Toolhouse agent through prompt-driven auto-wiring? Naftiko produces MCPs; Toolhouse wires them at agent-deploy time; the join point is a one-page docs section.Q2. Toolhouse runs Naftiko-built capabilities natively
Would Toolhouse consider a runtime path where a Naftiko capability container can be deployed as a Toolhouse agent's tool surface — letting customers ship governed Naftiko capabilities directly into Toolhouse-hosted agents without a separate Naftiko deployment? Naftiko brings the spec-driven integration depth; Toolhouse brings the hosted runtime; together they cover the ‘ship a governed capability inside a managed agent’ gap neither product fully closes today.
Integration Kit
Partnership Capability Map
10 Naftiko capabilities authored to integrate with Toolhouse as a service partner. Each one consumes a specific Toolhouse surface and exposes it as REST + MCP through the Naftiko engine — shipped as inline alpha2 YAML in the api-evangelist repository and published to the apis.io capability catalog.
Toolhouse Agents Discovery
toolhouse-agents-discovery
Pull deployed Toolhouse agents (name, slug, model, prompt, installed tools, schedule) into Naftiko Fleet so Backstage shows every Toolhouse-running agent alongside Naftiko-declared capabilities.
Toolhouse Tools Discovery
toolhouse-tools-discovery
Pull Toolhouse's 40+ pre-built agent tool catalog into Naftiko Fleet discovery so the catalog is consumable from any Naftiko capability and surfaced in Backstage.
Toolhouse Bundles Management
toolhouse-bundles-management
Manage Toolhouse Bundles (named, reusable tool collections) from Naftiko spec — declare which toolset a capability's agents should ship with.
Toolhouse Agent Invoke
toolhouse-agent-invoke
Invoke a deployed Toolhouse agent through the Workers API as a governed Naftiko operation — pass-through with streaming + conversation continuity (run_id), with Spectral / OPA / OpenTelemetry guards layered on top.
Toolhouse Agent Runs Bridge
toolhouse-agent-runs-bridge
Bridge Toolhouse agent runs (status, execution logs, and MCP server logs) into Naftiko's OpenTelemetry pipeline — single observability dashboard across Toolhouse activity and Naftiko capability calls.
Toolhouse MCP Server Bridge
toolhouse-mcp-server-bridge
Wrap Toolhouse's hosted MCP server as a Naftiko consume so any Naftiko capability can reach the Toolhouse tool surface and re-expose it as a governed Naftiko-built MCP.
Toolhouse MCP Discovery Register
toolhouse-mcp-discovery-register
Register Naftiko-built MCP servers with Toolhouse MCP Discovery so any Toolhouse agent that requires that capability can auto-wire the Naftiko-built MCP at agent-deploy time.
Toolhouse RAG Bridge
toolhouse-rag-bridge
Manage Toolhouse RAG documents + vector stores from Naftiko spec — sync Naftiko-governed source documents into a Toolhouse-RAG-backed agent without leaving the spec layer.
Toolhouse Schedules Management
toolhouse-schedules-management
Manage Toolhouse cron schedules from Naftiko spec — declare when an agent should fire autonomously and provision the schedule via Platform API.
Toolhouse FinOps Bridge
toolhouse-finops-bridge
Pull Toolhouse credit usage and correlate with Naftiko's per-call cost attribution to produce a unified FOCUS-aligned cost view across both systems.
