×
Become a Naftiko design partner
Tell us who you are and what you are trying to unblock. Every partnership at this stage is a design partnership — if you already know whether you are coming in as an enterprise, a SaaS vendor, or a system integrator, say so; if not, we will work it out with you. We route every enquiry to a person within two business days.
Learn
Become a Naftiko design partner
Tell us about the use case that is blocked today and what your reviewer needs to see before a credential is attached. The cohort is capped at five, and we would rather turn people away than run one we cannot serve properly.
Reach
Make your API the one agents get right
Tell us about the API you publish and which jobs your customers actually hire it for. As a design partner we will help you shape those into governed capabilities — no rewrite, no migration. You also get a say in how public capability distribution works before it is built. While we are in the design partner phase, this costs you nothing but the time.
Deliver
Deliver Naftiko capabilities for your clients
We are opening this program once the first enterprise design partners have taken a capability through to a bound credential and a production workload. Certification, enablement, and commercial terms will be shaped by what that cohort teaches us. Tell us what integration work you deliver today and we will put you first in line.
Partner with Naftiko
Three audiences, one engagement, and one thing they share: a capability running against your own systems, reviewed and governed, before anyone talks about a contract.
The Naftiko Platform is open source at its core under Apache 2.0. The Community edition is available today, free and self-hosted; the Developer, Team, and Enterprise editions are in development. That is exactly why everyone who works with us at this stage is a design partner — we need enterprises, SaaS vendors, and system integrators to tell us whose pain it removes, what it must do before it touches a system of record, and who signs for it.
Three audiences, all of them design partners
Every program on this page is a form of the same thing: a design partnership. You run the capability lifecycle with us against real systems, and we learn what the product still gets wrong. What differs is the question each audience answers — and mixing those questions is how partner programs stop teaching you anything.
Enterprises, SaaS vendors, and system integrators all enter through the design partner engagement described below. Same lifecycle, same two human gates, same jointly signed ROI one-pager at the end.
Learn
Apply as a design partner
Enterprises
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 early access to the Enterprise edition as it is built.
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
Reach
Apply as a design partner
SaaS Vendors
Open · 5 SaaS vendors
Companies with a public or partner API who want agents to consume it well rather than badly.
You get
Governed capability specs for your API, authored with our team and kept in Git where anyone can review them — plus a say in how public capability distribution works before it is built.
We get
A real capability corpus, third-party validation of the spec, and the requirements that shape distribution.
Cost
Free during the design partner phase
Deliver
Apply as a design partner
System Integrators
Waitlist · opens after Gate 2
Systems integrators, consultancies, and boutique integration shops who deliver capabilities for their own clients.
You get
A place at the front of the queue, visibility into the delivery pattern as the first cohort proves it, and first access to certification and enablement when the program opens.
We get
Delivery capacity we do not have to hire, and reach into accounts we would not otherwise see.
Cost
No fee to join the waitlist
Every 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
- Control evidence the artifact and its Git history produce 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.
SaaS vendors: 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. You know your business capabilities better than we do, so the default path is that you design them and we help: choosing which jobs deserve to be capabilities, shaping the MCP surface an agent actually sees, and wiring it on top of the public APIs you already run — no rewrite, no migration. If you would rather see it first, we can draft a first cut and you review it. What you get today is reviewable specs in Git, and MCP, REST, and Agent Skill exposure from one artifact. Public distribution of those capabilities is still being designed, and design partners get to shape it. While that is true, this costs you nothing but the time.
Apply as a design partner
System integrators: 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 enterprise design partners have taken a capability all the way to a bound credential and a production workload. Certification, enablement, and the commercial terms will be defined by what that cohort teaches us. 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.
Apply as a design partner
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.
