×
Become a Naftiko Design Partner
Tell us a bit about your team and the integration / AI problem you're trying to solve. We'll route you to the right person at Naftiko within two business days.
Partner with Naftiko
Three ways to work with us, and one thing they share: a capability running against your own systems, reviewed and governed, before anyone talks about a contract.
The Naftiko Platform ships in four editions: Community (free, self-hosted), Developer and Team (managed hosting), and Enterprise (with Backstage and Kubernetes integration). All share the same open-source core under Apache 2.0. We need partners to tell us whose pain it removes, what it must do before it touches a system of record, and who signs for it.
Three programs, three different jobs
They are deliberately separate. Each one answers a different question, and mixing them is how partner programs stop teaching you anything.
Learn
Design Partners
Open · 5 enterprises
Enterprises with a live agentic AI program and a use case blocked at the system-of-record boundary.
You get
Hands-on engineering from our team, direct influence on the Enterprise roadmap, and an Enterprise edition trial.
We get
Evidence — what the pain actually is, what your reviewer actually required, what your security team actually asked for before releasing a key, and a named reference.
Cost
Shared commitment
Deliver
Service Partners
Opening in Q4 '26
Systems integrators, consultancies, and boutique integration shops who deliver capabilities for their own clients.
You get
Certification, enablement, a shared capability library, co-sell motion, and margin on the editions you place.
We get
Delivery capacity we do not have to hire, and reach into accounts we would not otherwise see.
Cost
You earn margin
Reach
Ecosystem Partners
Opening in Q1 '27
Companies with a public or partner API who want agents to consume it well rather than badly.
You get
Published, governed capabilities for your API, presence in the catalog, and a place in the Shipyard Playground where developers actually try things.
We get
Distribution, a public capability corpus, and third-party validation of the spec.
Cost
Free while the corpus is thin
The design partner engagement is the capability lifecycle
We did not invent a program structure. We use the product's own lifecycle — three stages, two human gates — as the project plan. You experience the trust model instead of hearing it pitched, and every stage that stalls tells us exactly which part of the product is weak.
Stage 0
Week −1
stage
Playground
Walk a Shipyard track and lint your own spec in File Validation. Browser only. Nothing to install, nothing to buy, nothing to sign.
Unlocks
Removes the "we need a POC budget first" blocker — there is nothing to budget for.
Stage 1
Weeks 1–4
stage
Mock sources
Your engineer drafts a capability against mocked sources, runs it, and points an MCP client at it. We import from your spec, sit with them once, then get out of the way.
Unlocks
No credentials exist yet, so security review is not on the critical path.
Gate 1
Week 5
gate
Spec review
Your reviewer reads one declarative artifact: what it consumes, what it exposes, what it shapes and masks. The linter has already caught the mechanical defects.
Unlocks
Agent behaviour gets signed off as a pull request review, inside a process you already own.
Stage 2
Weeks 6–8
stage
Staging
Repoint the same spec at a staged API with synthetic data. The contract should survive the switch from mock to wire unchanged — if it does not, that is our defect, not yours.
Unlocks
Proves behaviour on realistic shapes without exposing real data.
Gate 2
Weeks 9–10
gate
Bind credentials
Security binds least-privilege credentials to the golden sources, scoped to exactly the operations the capability declared. We document what the gate required.
Unlocks
This is the real buying moment, and the honest place to find out what still blocks you.
Stage 3
Weeks 11–13
stage
Production
Run against a real workload. We close the gaps we can and write down the ones we cannot.
Unlocks
Go / no-go, a gap list, and a jointly signed ROI one-pager in your own numbers.
Nothing touches a system of record until week nine
Everything through Gate 1 runs on mocked sources and synthetic data. No credentials are issued, no real data moves, and no system of record is reachable — so the review that normally consumes a quarter of paperwork simply does not apply yet. Your engineers can be productive in week one. That is a procurement fact as much as an architectural one, and it is the first number the engagement produces: weeks of security paperwork avoided before any value was delivered.
Every gate leaves a measured number behind
A partner program that only collects requirements produces a better product and no business case. We baseline your incumbent approach at Stage 1 and measure against it at Stage 3, across four levers.
Cost
Right-sized tools instead of a tool dump
An agent handed 150–200 CRUD tools pays a per-turn tax before it reasons about anything. A capability collapses that into a handful of task-shaped tools with the sequencing executed server-side.
What we measure
- Tool count exposed to the agent
- Per-turn token floor before any reasoning
- Model round-trips per completed task
- Model tier required to hit accuracy
Velocity
Governance that runs left, not late
Polychro catches the expensive defects — wrong schema, over-broad surface, missing mask — in the editor and on the pull request, not three weeks later in review or in a production incident.
What we measure
- Time-to-first-capability, with our help and without
- Elapsed time from Stage 1 to Gate 1 approval
- Defects caught pre-review versus at review
- Time to onboard the second and tenth capability
Risk control
Gates that are cheap to pass and hard to bypass
Regulated enterprises do not lack controls. They lack controls that are affordable to apply. Governance is spent on the artifact and not re-spent on the plumbing beneath it.
What we measure
- Capabilities re-entering review after an engine upgrade — should be zero
- Effort to answer "are we patched?" across the estate
- Audit evidence produced without bespoke work
- Controls satisfied by the artifact versus by process
Trust at scale
The outcome that actually gets funded
Most enterprise agent programs are not stalled on model quality. They are stalled where a probabilistic agent meets a regulated system and the honest answer is "we can't let it touch that yet." Converting that into a governed yes is the whole point.
What we measure
- Use cases moved from blocked to production
- Time from idea to production-approved capability
- Systems of record safely reachable by agents
- Programme-level agent spend per completed task
Who we are looking for right now
The design partner cohort is capped at three to five and time-boxed to a quarter. We would rather turn people away than run a cohort we cannot serve properly.
A good fit
- ✓You have a funded agentic AI program, not a slide about one.
- ✓You have at least one use case that is blocked today because an agent cannot be trusted near a system of record.
- ✓Your estate is not all clean REST — SOAP, XML, CSV, flat files, and private networks are the interesting cases, not the disqualifying ones.
- ✓You can put an engineer on it for a few hours a week and a reviewer in the room at Gate 1.
- ✓You are willing to be a named reference and to co-sign a one-page ROI case at the end.
Probably not yet
- ×You want a proof of concept built for you rather than with you.
- ×You cannot name the use case, the reviewer, or the budget line.
- ×You are evaluating five platforms in parallel on a two-week clock.
- ×You need the engagement to stay confidential in every direction, including anonymized findings.
Ecosystem partners: make your API the one agents get right
If you publish an API, agents are already consuming it — usually as a flat dump of CRUD endpoints that burns context and gets mis-picked. An ecosystem partnership publishes governed, task-shaped capabilities for your API instead: reviewable specs, MCP and REST and Agent Skill exposure from one artifact, and a slot in the Playground where developers try it before they commit. While the public corpus is still thin this costs you nothing but the time to review what we publish.
Service partners: we are opening this after the first cohort clears Gate 2
Systems integrators sell what is repeatable. Certifying delivery partners before the delivery pattern is proven manufactures churn on both sides, so we are holding this until the first design partners have taken a capability all the way to a bound credential and a production workload. If you deliver integration work and want to be first in line, tell us now — the signed ROI one-pagers from the cohort will be the enablement material.
Start where it costs you nothing
Walk a Shipyard Playground track and lint one of your own specs before you talk to us. It takes an afternoon, it costs nothing, and it means the first conversation starts from a shared artifact instead of a slide.
