Skip to main content
Discuss your build
Menu

How KNWN Studio Works

From one valuable workflow to a build your team can own.

We do not begin with a list of endpoints or a promise to add AI everywhere. We begin with a user, a job they need to complete, the systems behind it, and the rules the integration must respect. Then we build the smallest complete path, prove it, expand it, and hand it over.

One-off project | Written scope and acceptance criteria | Client-controlled deployment | Complete handover

Map the workflow

Choose the job worth enabling.

We define the user, trigger, desired result, systems involved, and boundaries of the first build. If the workflow is too broad, depends on unavailable data, or would be better handled inside the existing product, we narrow it or say so.

Decision outputs

  • Primary user and workflow
  • In-scope and out-of-scope requests
  • Source systems and technical owners
  • Read, draft, and committed actions
  • Initial architecture and feasibility risks

Define tools and access

Define what will be built before the full build begins.

We map the workflow into tools, data flows, permissions, confirmation points, optional interface requirements, deployment responsibilities and acceptance scenarios. Assumptions and exclusions are written down, so the proposal does not rest on vague language like "make it production ready".

The proposal defines:

  • Approved workflows and tool surface
  • Required integrations
  • Authentication and authorization model
  • Evaluation and acceptance criteria
  • Deployment environment, deliverables and ownership
  • Client responsibilities and review gates
  • One-off project fee, with explicit exclusions

Every Studio engagement is quoted as a one-off project after the workflow and technical dependencies are reviewed. The proposal states the fee, delivery stages, assumptions, exclusions and acceptance criteria before work begins.

Build the experience

Prove one complete path, then build out the rest.

We connect one representative request through the tool layer to the source system and back. That slice exposes problems in the API, data, identity, permissions and user experience while they are still cheap to correct.

Your team reviews it before we complete the remaining surface: the other tools, account connection, permission checks, safe writes, structured results, optional UI, failure behavior and logging.

Typical work includes:

  • Tool and schema implementation
  • Integration with source APIs or services
  • Authentication, authorization, tenant and scope enforcement
  • Read, draft and write separation, with confirmation and idempotency
  • Optional UI using the MCP Apps standard
  • Rate limits, timeouts and normalized errors
  • Logging and audit events
  • Plugin packaging and metadata where included

Evaluate the behavior

Test the behavior users and operators will rely on.

We turn the acceptance criteria into repeatable scenarios and record the result. The set covers the happy path, but also requests that should not call a tool, invalid input, permission failures, consequential-action confirmation, dependency failures and relevant edge cases.

Evaluation groups

  • Direct requests, and natural or indirect phrasing
  • Similar but out-of-scope requests
  • Missing or invalid inputs
  • Unauthorized and cross-tenant access
  • Confirmation and cancellation paths
  • Duplicate and partial write cases
  • Empty results, timeouts and upstream failures
  • Behavior with and without optional UI

Your team receives the agreed evaluation cases, results, known limitations, and fixes completed before acceptance.

Deploy and hand over

Move the accepted build into the environment your team will control.

We deploy to the agreed production environment, verify the production path, transfer the project assets, and walk the responsible team through configuration, operation, logs, rollback and future changes.

Handover can include:

  • Source repository and dependency files
  • Architecture and data-flow documentation
  • Tool, plugin, skill and UI assets
  • Infrastructure and deployment configuration
  • Environment and secrets inventory
  • Automated tests and evaluation fixtures
  • Operational runbook and rollback steps
  • Known limitations and deferred work
  • Live or recorded technical handover

The project is accepted against the written scope and acceptance criteria, not a general claim that every possible prompt or future platform change is covered.

Frequently asked questions

What happens after the first call?

If the project appears viable, KNWN requests the minimum technical material needed to confirm the workflow and architecture. We then prepare a written scope with deliverables, assumptions, exclusions, review gates, acceptance criteria, delivery plan, and one-off project fee.

Do you charge a subscription?

The Studio build is a one-off scoped project. There is no mandatory KNWN hosting or Studio subscription required to operate the handed-over implementation. Third-party infrastructure and usage costs remain the client's responsibility.

How long does a project take?

The delivery plan is set after the workflow, systems, authentication, interface, deployment, and review requirements are understood. KNWN does not publish one universal duration because it would be meaningless across materially different builds.

Can we begin without a complete API?

We can assess the workflow, but the implementation still needs a reliable and authorized path to the required data and actions. Missing backend work is identified during scope and included only when it is feasible and explicitly approved.

When do we see something working?

The process prioritizes a complete vertical slice before the full tool surface. The exact review point appears in the proposal. Its purpose is to reveal integration and behavior problems before the remaining implementation is completed.

How is the project accepted?

Acceptance is based on the written deliverables and scenarios agreed in the scope. KNWN demonstrates the workflows, provides the relevant evaluation results, resolves in-scope defects, deploys to the agreed environment, and completes the documented handover.

Can KNWN maintain it after launch?

Yes, if both teams agree on a separate support or expansion scope. Ongoing support is optional and is not required for ownership of the original build.

Start with the workflow you want to make possible.

Tell us who needs it, what they should be able to accomplish, which systems are involved, and which actions require approval. We will tell you whether it is a fit and what the first build should include.