WeKan used NitroStack as the MCP runtime behind APAF’s Project Guide, connecting guided client conversations directly to structured project-delivery workflows.
Customer: APAF by WeKan
Industry: AI / Product Engineering / Software Consulting
Use case: Conversational product discovery
NitroStack role: MCP runtime and orchestration layer
Outcome: Client conversations can flow directly into structured AI-generated project deliverables
Platform: 40+ specialized AI agents across 7 project delivery phases
A software brief rarely arrives ready for engineering.
Someone has an idea. Then come the questions: Who is it for? What problem is actually being solved? What belongs in the first version? What does the market look like? Which requirements are essential? What should the architecture account for?
APAF, developed by WeKan, was already built to turn those early inputs into structured project artifacts using more than 40 specialized AI agents across seven delivery phases. What changed with NitroStack was the way APAF could collect the context those agents needed.
APAF used NitroStack as the Model Context Protocol (MCP) runtime behind Project Guide, its conversational workspace for product discovery. Instead of treating discovery primarily as a sequence of forms and generation triggers, Project Guide could ask, clarify, capture and then invoke the appropriate APAF workflow. The conversation itself became part of delivery.
Why APAF moved beyond form-driven product discovery
APAF’s underlying problem was familiar to anyone who has run a software discovery session.
Forms are good at collecting known information. Discovery is different.
A client might be able to describe the product idea clearly but have no defined user personas. They may know the market but not the requirements. An answer to one question can expose three things that need clarification before the next useful decision can be made.
A consultant naturally works through that uncertainty in sequence: ask something, listen, spot the gap, probe further, then turn the answers into something the project team can use.
APAF’s earlier workflow was more linear:
Client input → trigger → agent → deliverable
It could generate the artifact, but the input process itself remained relatively static. The client still had to provide much of the required information through predefined fields before the intelligence behind APAF could do its work.
Project Guide was designed to close that gap. The objective was not to bolt a chatbot onto APAF. WeKan wanted the conversation to become a working discovery session—one capable of gathering the right context while keeping that context structured enough for downstream agents to use.
That difference shaped the implementation.
How Project Guide uses NitroStack as its MCP runtime
APAF already had the specialized agents and project-delivery architecture. Replacing them would have solved the wrong problem.
Instead, NitroStack became the runtime between Project Guide’s conversational experience and APAF’s existing backend.
Through MCP tools built around the workshop workflow, Project Guide can expose specific actions the conversation needs: presenting the next relevant question, saving a response, returning a contextual suggestion, triggering deliverable generation or passing structured information into another APAF process.
The architecture can be understood without turning it into a diagram:
Client brief → guided conversation → structured responses → APAF agents → project deliverable
The useful part is what happens in the middle.
A model is not simply producing text and leaving the application to figure out what to do with it. The conversational layer has callable operations. Those operations give the AI a defined way to interact with APAF’s product logic while the existing backend continues doing the work it was built to do.
That is the role MCP serves here. And it is where NitroStack’s MCP framework fits naturally: MCP tools provide explicit actions with structured inputs and outputs, rather than turning the entire application into one large prompt.
For APAF, NitroStack became the orchestration boundary between what the client is saying and what the product should do next.
How a conversation becomes a project deliverable
Consider a client working through market research.
They may begin with a reasonable description of the product and still be missing information required for a useful research deliverable. Asking them to complete a larger form does not necessarily solve that problem; people can leave fields vague, misunderstand what is being requested, or simply not know the answer yet.
Project Guide can handle that interaction incrementally.
It asks the next question based on the current stage. The client responds. That response is captured rather than disappearing into an unstructured chat transcript. Project Guide can provide additional context or suggestions, continue asking for missing information, and eventually trigger the relevant APAF workflow once the required inputs have been assembled.
The operating pattern becomes:
Ask → clarify → capture → suggest → generate
For example, once enough discovery context has been collected, those structured inputs can move into APAF’s Market Research and Business Discovery agents. Those agents remain responsible for their specialized work; Project Guide changes how the information reaches them.
This separation is important because APAF did not have to collapse its conversational interface and agent system into the same architectural layer. Its existing interface and streaming experience could remain responsible for the live conversation, NitroStack could manage the MCP-based interaction logic, and APAF’s backend could continue running specialized delivery workflows.
The team added a new interaction model without throwing away the systems behind it.
Developers building a similar pattern can see the same principle in NitroStack’s MCP tools model: expose defined application actions to the AI, keep business logic where it belongs, and use the protocol layer to control how the two interact.
What changed when discovery became part of the workflow
Project Guide changed more than the presentation of APAF.
Previously, the main handoff happened after the client had supplied the input. With the conversational workflow, APAF can participate while that input is still being formed.
That creates a different product experience.
A client no longer needs to understand the entire discovery structure before starting. Project Guide can expose it one useful question at a time. Responses can still be captured in a form suitable for downstream processing, so conversational flexibility does not mean giving up the structure required for formal project artifacts.
It also connects two parts of the system that can otherwise become detached in AI products: conversation and execution.
The customer is not chatting in one application and then manually transferring the useful information somewhere else. The discovery conversation can invoke the same broader delivery system that ultimately produces the work.
Pablo Jimenez Godoy, CEO of WeKan, describes the change this way:
“The biggest difference with NitroStack was moving Project Guide from a form-driven experience to something that actually feels like a discovery session. The system can ask the next question, capture the response, and trigger the right workflow. That makes the experience much closer to how we would work with a client manually.”
Pablo Jimenez Godoy, CEO, WeKan
There is also an architectural benefit. Because NitroStack operates as the MCP orchestration layer rather than replacing APAF’s agent backend, the same interaction pattern can be extended to other stages of the project-delivery process without requiring every stage to become its own standalone conversational application.
How NitroStack connected conversation to APAF’s agent backend
APAF already had the intelligence.
Its 40+ specialized agents covered work across seven phases, including initiation, discovery, requirements, design, architecture, development, testing and launch. The gap was a clean way for clients to interact with those capabilities conversationally while still giving the application control over what happened next.
NitroStack supplied that layer.
APAF used NitroStack as the MCP runtime behind Project Guide so conversational interactions could map to explicit application capabilities instead of remaining isolated model responses. The resulting system keeps responsibilities separate: Project Guide handles the interaction, NitroStack handles MCP-based orchestration, and APAF’s agents handle the specialized project work.
For teams building agentic products, that separation is often more useful than trying to put the entire application inside the chat layer.
APAF’s implementation shows one concrete MCP pattern: take an existing system with useful business logic and specialized AI capabilities, expose the actions needed during a conversation as controlled tools, and let the conversational experience invoke those operations as the user works through the task.
In Project Guide, one answer can be saved, the next question can be selected, missing context can be gathered, and the completed discovery can move into the appropriate agent workflow. The client starts with a conversation; APAF ends with structured work.
FAQ
How does APAF use NitroStack?
APAF uses NitroStack as the MCP runtime and orchestration layer behind Project Guide. NitroStack connects Project Guide’s conversational interactions to actions such as presenting questions, capturing responses and triggering APAF’s existing AI workflows.
What changed in APAF’s product discovery workflow?
APAF moved from a largely form-and-trigger-driven interaction toward guided conversational discovery. Project Guide can now ask follow-up questions, capture answers as structured inputs and use those inputs to start the relevant deliverable-generation workflow.
Did NitroStack replace APAF’s existing AI agents?
No. APAF retained its existing agent backend and project-delivery architecture. NitroStack sits between the conversational experience and those systems, providing the MCP layer through which Project Guide can invoke the required capabilities.
What does the Project Guide workflow look like?
A client begins with a project brief, works through a guided conversation, and provides answers that are captured as structured discovery data. Those inputs can then be passed to APAF’s specialized agents to generate the relevant project artifact—connecting client conversation → structured discovery → AI agent → deliverable.