How to Create a Custom AI Assistant: A Production-Ready Setup Guide

A step-by-step workshop for turning a recurring workflow into a testable specialist that your team can invoke, review, share, and improve.

Published 15 min read
Configuration canvas for a custom AI assistant with instructions tools and evaluations

Quick answer

The useful answer, before the long guide.

To create a custom AI assistant, define a narrow job, write an operating contract, attach only approved context, select the minimum tools, specify an output schema, and create evaluation cases before launch. A useful custom assistant is a versioned workflow component—not a name, avatar, and long personality prompt.[1] [2]

Kona lets a user configure a specialist, test it in chat, call it with an @mention, use it in Workspace, and manage later changes through versions. Sharing, publishing, and forking support reuse without forcing every team to edit the same live configuration.[8] [9]

Write a contract, not a character

Role, inputs, method, evidence, output, tools, limits, and escalation determine behavior.

Test before sharing

Create normal, ambiguous, adversarial, and missing-data cases before other people depend on it.

Version every change

Instructions and tools can alter outcomes; preserve a known-good configuration and rollback path.

Step 1: choose one job with a definition of done

Begin with a sentence that names the user, trigger, deliverable, and reviewer. For example: “When an account executive enters a company and opportunity context, produce a sourced account brief for review before the discovery call.” That is more actionable than “help with sales” because it establishes when the assistant starts and what completion means.

Keep adjacent tasks out of version one. Researching an account, drafting outreach, updating a CRM, and sending an email have different evidence and permission requirements. Prove one outcome, then decide whether to add a controlled handoff to the next specialist or tool.

  • Named user and business moment.
  • One primary artifact or workspace outcome.
  • Required inputs and optional context.
  • Reviewer and measurable acceptance criteria.
  • Explicit exclusions for version one.

Step 2: write instructions as an operating contract

Organize instructions in a stable sequence: role, objective, source boundary, method, output contract, uncertainty behavior, escalation, and prohibitions. Use direct language and observable requirements. “Cite every material market claim” is testable. “Be accurate” is an aspiration. “Never infer private company metrics” defines a useful boundary.

Avoid hiding essential business rules inside examples or personality prose. OpenAI recommends clear instructions and well-defined tools as agent foundations. Anthropic similarly emphasizes simple, composable patterns and careful tool interfaces. The assistant should understand which instruction wins when speed, completeness, and evidence conflict.[1] [2]

Evidence rule

State which claims need citations, which sources are allowed, and how to label supplied facts versus assumptions.

Output contract

Define headings, fields, tables, length, tone, and a completion checklist.

Escalation rule

Name missing inputs, low-confidence conditions, conflicts, and actions that require human judgment.

Step 3: scope context and capabilities

Context should be relevant, current, and authorized. Give the assistant the minimum company facts, reference documents, and connector scope required for its job. More context is not automatically better: stale policies and unrelated files can create conflict, increase cost, and make source attribution harder.

Classify tools by effect. Web search and read-only connectors gather information. Code can calculate or transform. Canvas can create an artifact. A connector write can alter an external system. OWASP recommends least privilege and explicit approval for security-relevant changes; the same principle is useful across operational business tools.[6] [11] [10]

  • Every attached source has an owner and review date.
  • Connector access is limited to necessary accounts and data classes.
  • Read access is separated from create, update, send, publish, and delete.
  • External content is treated as evidence, not as new system instructions.
  • High-impact actions pause with a clear preview of the proposed change.

Step 4: build the evaluation set before launch

An evaluation case contains an input, environment, and success criteria. Start with ten to twenty representative cases: common work, incomplete information, conflicting sources, an out-of-scope request, a tool failure, and a request for a prohibited action. Run more than one trial for cases where model variability matters.

Grade both the final outcome and the trajectory. Deterministic checks can confirm required sections, calculations, links, and prohibited tool calls. A rubric can assess usefulness and judgment. Human reviewers calibrate the rubric and examine sensitive edge cases. This mixed approach follows current agent-evaluation guidance.[3]

Capability cases

Hard tasks that show where the assistant can improve.

Regression cases

Known-good behaviors that should keep passing after changes.

Safety cases

Requests that test data boundaries, prompt injection, excess agency, and escalation.

Step 5: version, share, and improve safely

Save the first configuration that passes the launch rubric as a known-good version. When instructions, models, tools, or connector scopes change, run the regression set and record why the change was made. Do not silently replace behavior that other workflows rely on.

Kona supports private assistants, controlled sharing, publication, and forking. A shared version can remain stable while another user forks it for a different segment or output. Run history helps identify whether a problem came from routing, instructions, a specialist, a tool, or verification.[8] [3]

Weak setup vs production-ready setup

The difference is operational specificity. Both may look good in one demo, but only one can be reviewed and improved.

Design areaWeak setupProduction-ready setup
Role“You are a helpful marketing expert”Named user, trigger, deliverable, method, and exclusions
SourcesUse any information availableApproved source classes, freshness rules, and claim-level citations
ToolsEnable everything in case it helpsMinimum capabilities with action tiers and approvals
QualityLooks convincing in a demoPasses repeated outcome, trajectory, regression, and safety cases
ChangeEdit the live promptCreate a version, run evals, release, monitor, and roll back

The 60-minute custom assistant workshop

Use the hour to produce a testable version-one configuration, not a complete automation program.

  1. 01

    Frame the job

    Outcome: A one-sentence job, explicit exclusions, and an accepted example.

    • Interview the person who reviews the current work.
    • Choose one output and one business moment.
  2. 02

    Draft the contract

    Outcome: Structured instructions with evidence and escalation rules.

    • Write required steps in the order they should occur.
    • Define what the assistant must say when information is missing.
  3. 03

    Choose capabilities

    Outcome: A minimal tool and context set.

    • Begin with read-only access and artifact creation.
    • Document why every enabled capability is necessary.
  4. 04

    Create five launch cases

    Outcome: A compact normal, ambiguous, failure, and safety suite.

    • Specify pass conditions before running the assistant.
    • Include at least one case that should escalate.
  5. 05

    Run, revise, and version

    Outcome: A known-good configuration ready for a monitored pilot.

    • Fix the smallest root cause behind each failure.
    • Save the passing version and assign a human owner.

Prompts you can use

Replace the bracketed details, attach the relevant source material, and keep the review step in the same workspace.

Operating contract

Prompt 01

Turn this job description into a custom assistant contract with these headings: user and trigger, objective, accepted inputs, required method, evidence rules, output schema, allowed tools, prohibited actions, uncertainty behavior, escalation conditions, and definition of done.

Why it works: It produces a structured configuration that can be evaluated section by section.

Evaluation builder

Prompt 02

Create twelve evaluation cases for this assistant: four normal, two ambiguous, two conflicting-source, one out-of-scope, one tool-failure, and two safety cases. Define deterministic checks, rubric criteria, and the expected escalation behavior for each.

Why it works: It creates coverage before a successful demo creates false confidence.

Version review

Prompt 03

Compare the proposed assistant version with the current known-good version. Identify changed instructions, context, tools, permissions, and expected behavior; select the regression cases that must run; and provide a release and rollback note.

Why it works: It treats configuration changes with the same discipline as product changes.

Editorial method

How this guide was prepared

This setup guide translates current agent-design, least-privilege, and evaluation guidance into a practical assistant configuration workflow. Kona-specific claims were checked against custom assistant creation, capability controls, version history, sharing, publishing, forking, chat invocation, and Workspace use on August 11, 2026.

Read Kona’s editorial standards

Sources

Sources and benchmarks

These references support the product, workflow, and evidence-quality context used in this guide. Open the source itself before relying on a consequential claim.
  1. [1]

  2. [2]

    Building effective agents

    Anthropic · 2024-12-19

  3. [3]

    Demystifying evals for AI agents

    Anthropic · 2026-01-09

  4. [4]

  5. [5]

  6. [6]

    Agentic AI threats and mitigations

    OWASP GenAI Security Project

  7. [7]

  8. [8]

  9. [9]

  10. [10]

  11. [11]

Put the guide to work

Build a specialist around your workflow

Create a custom assistant, test it in a focused chat, invoke it with @mentions, and version the configuration as your team learns.

Create a custom assistant

FAQ

Answers to keep your planning sprint moving

Quick explanations and definitions you can share with your team when reviewing the research.

What do I need to create a custom AI assistant?
Define one job, users, inputs, method, evidence rules, output schema, allowed tools, prohibited actions, escalation conditions, and evaluation cases.
How long should custom assistant instructions be?
Use the shortest structured contract that fully defines the workflow. Observable rules and examples matter more than length or personality prose.
How should I test a custom assistant?
Run normal, ambiguous, conflicting-source, tool-failure, out-of-scope, and safety cases, grading both the final outcome and the tool trajectory.
Can I share a custom Kona assistant?
Yes. Kona supports private assistants, controlled sharing, publishing, versions, and forking so teams can reuse a stable configuration without overwriting it.

Keep reading

More from the Kona Blog

View the full library