KnowledgeAdmin portal

Sign in

The break-glass admin key from Key Vault. Kept in this browser tab only.

KnowledgeAdmin portal

Set your password

At least 12 characters. A few words together is fine.

KnowledgeAdmin portal
Work
Records
Admin
Help

Content

Create an index, load documents into it, and check what was loaded.

  1. 1House style
  2. 2Product
  3. 3Upload
  4. 4Plan
  5. 5Write & check
  6. 6Approve & load

1 · House style

How every page is laid out and written: front matter rules, the headings for each page type, writing rules, and any prompt text you already use. One for everything; every change is kept as a version.

What to do: before your first product, press Open and check it says what you want. Paste your own prompt text (for example from Copilot) under Extra instructions for the AI, try it on a piece of a manual, and save.

2 · Products

Each product has a profile: its name, platform, versions, owner and who may see it (these fill in every page's front matter), plus notes and terms the AI is given with every page.

What to do: start a product the first time you build pages for it, then open its profile and fill in the blanks. Next time, just pick it below.

3 · Upload a document

A manual, guide or data sheet to turn into pages. A reference copy is kept (the master stays where it is); its text is read, then the AI plans the pages.

What to do: choose the product, then what this is: a new document; a new revision of one already turned into pages (only what changed is shown, your edits kept); or a rebuild of one (the same document, pages made again with the current house style, pictures and the nothing-left-out check; new pages take over the saved ones, no duplicates). Add notes if needed. Press Start: reading and planning take a minute or two (longer for a big manual).

No file needed: the copy we keep is read again. Your hand edits to the saved pages are replaced by the new pages; What changed on each page shows before and after, so you can carry anything across.

Bring pages up to date

The house style or a product profile has changed since these pages were made. Applying it re-lays the pages out in the new style; the facts stay exactly as they are (it won't recover anything missing: for that, rebuild from the document under Upload or Library › Originals), and you check and approve each page as usual.

Jobs

Every document being turned into pages. Work carries on if you close the browser: open a job to pick up where you left off.

Try it before saving

Writes one sample page with the house style as it is in the box above (saved or not), so you can see the effect. Nothing is kept.

    What to do: View shows an old version; Compare shows what changed against the current one; Restore puts an old version into the editor so you can save it as the newest.

    4 · Plan

    The pages the AI suggests, made from the document's contents. Nothing is written yet.

    What to do: check the list. Rename pages, change a page type, move pieces between pages (by their p-numbers, listed under "All pieces of the document") or tick Skip. The bar must be fully accounted for: every piece of the document is on a page or skipped on purpose. Press Save plan, then Write pages.

    What changed in the document

    Every section, old and new

    What happens to each page

    All sections of the document

    5 · Write & check

    Each page next to the part of the original it came from, with our checks. Red must be fixed; amber is worth a look.

    What to do: go through the pages one by one. Read the checks, compare the page with the original on the right, and edit the page if needed (Save edit checks it again). To have it rewritten, write a note and press Redo. When it's right, press Approve.

    Parts of the manual on none of the pages. For each one: Add a page for it (then Write pages), or add it to an existing page by hand. If it really isn't needed (for example a parts list nobody asks about), leave it.

      The page
      The original

      6 · Approve & load

      Approved pages are saved (each a new version, with the original and the style versions it came from) and loaded into an index, ready to ask and test.

      Reference copies of every document turned into pages. The master stays where it is (SharePoint, the website…); this copy is what each page was checked against.

      Every approved page, with the original and the house style and profile versions it was made with. behind means the style or profile has changed since.

      Copies saved pages into an index without converting anything again: choose a product above, or All for every product. Use it to make a release index (for example kb-2026-11-18) from pages already approved.

      Terminal layouts, wiring diagrams and screenshots, each with a description in words (that's what a search finds). Pictures from a manual arrive here when it goes through the Page builder and are approved with their page. A picture on its own is added below, checked, approved, and loaded into an index by itself.

      What to do: for each picture marked to check, read the AI's description against the picture, fix it (Edit), then Approve. To use pictures on their own, tick the approved ones, choose an index and press Load. The style of descriptions is set under House style › Pictures.

      Add a picture on its own

      A terminal layout, wiring diagram or screenshot that isn't in a manual we've loaded. The AI drafts the description; you check and approve it.

      Picture

      The house style and every product profile, with their versions.

      Everything kept in Azure storage for the knowledge system, by kind. Internal files (sign-ins, settings) are counted but not listed here.

      1

      Indexes

      One index per loop (loop-0, loop-1 …) keeps every loop comparable. is the one apps and GitHub use unless they name another.

      What to do: pick a name for this round of testing (for example loop-0), type it under New index and press Create. Use an index you already have to add to it instead.

      2

      Load files

      Markdown: converted pages (.md), cut at headings, front matter kept. Raw: PDF, Word and web pages as they are today (loop 0).

      What to do: choose the index, choose Raw for original PDFs and Word files or Markdown for converted pages, pick a folder (or files), then press Load. Read the result: anything skipped says why.

      3

      What is in an index

      Every file loaded: when, from where (GitHub or an upload), its platform and who may see it, and the pieces it was cut into. This is exactly what the AI searches.

      What to do: choose an index and press Show. Click a file to see the pieces it was cut into and its front matter. If a file is missing, load it again in step 2.

      4

      Keep it current

      Every page's owner and review date (from its front matter: owner: and last_reviewed:). A page is due for review 12 months after it was last checked.

      What to do: choose an index and press Check. Pages that are overdue, have no date or no owner come first: ask the owner to check them, update last_reviewed, and load them again.

      Convert a document to a draft page

      PDF, Word or a saved Zoho page becomes Markdown with an empty front matter template. A person checks every step and value before it goes into the repository.

      What to do: choose a PDF or Word file and press Convert. A draft .md page downloads; fill in the front matter, check every step and value against the original, then load it in step 2 with Markdown mode.

      What to do: type a question the way a customer or installer would ask it, choose the index, then press Ask. To follow up ("and for Integriti?"), just ask again: it remembers this conversation until you press New conversation. Any language works.

      1

      Check and run

      Asks every wording of every question against one index. Keep the questions, instructions and model the same between loops so the results can be compared.

      What to do: choose the index for this loop and look at the checklist. When every line is green, press Run test. It takes a few minutes; the run then appears in step 2, ready to score.

        2

        Score the answers

        Every run is kept. Open one to score it in the portal; the spreadsheet download is filled in with the same scores.

        What to do: press Score on the newest run. For each answer, compare it with the known answer and press Yes or No for the four checks. Suggest scores lets the AI pre-mark them first; you confirm or change each one.

        3

        Compare loops

        Scored runs side by side: how many answers passed each check. This shows what each loop's change was worth.

        What to do: score at least one run; it appears here. The aim by the last loop: every answer passes all four checks.

        Question set (set up once, before loop 0)

        Each question: id, type, platform, the known answer James confirmed, and its wordings (ours, customer, new starter).

        What to do: edit the questions in place (keep the spacing exactly as shown) and press Save question set. If something is out of place it lists every problem and saves nothing. Don't change it once loop 0 has run.

        What to do: for each answer below, read the known answer and the AI's answer, then press Yes or No for each check. If anything is No, choose why. It saves as you go. Not sure what a check means? Press the ? button at the top.

        Answer instructions

        What the AI is told before every question. Each save is a new version, used from the next question on and recorded on every answer and spreadsheet. Change it only between loops, and log why.

        What to do: only change these between loops, when the failure log says Made up. Edit the text, press Save as new version, and note the new version number in the failure log.

        Earlier versions

        Choose one to read it.

        What to do: click a version to read it. To go back to one, copy its text into the box above and save it as a new version.

        
          

        Word list

        Our own terms, and the words customers and installers use for them. When a question uses one, its meanings are searched too, and the AI is told what it means.

        What to do: add the words people use that our documents don't (e.g. panel means controller), product names and part numbers worth explaining. Separate several meanings with commas. Press Save word list.

        Pinned answers

        An approved answer for particular questions, given as it is instead of searching. Use it for sensitive questions (installer codes, safety) or anything that must always be answered the same way. A question close enough in meaning to one of its wordings gets it.

        What to do: write the questions it is for (one per line; a few different wordings work best), the exact answer, optionally the platform, and who may get it (internal only unless you say otherwise). Press Pin answer. Test it on Ask: pinned answers show a pinned tag.

        How it's going

        Real questions from people and apps. Test runs and command-line questions are left out unless you include them.

        What to do: check the answered and thumbs-up figures are rising over time. Click a tile or a question to see the conversations behind it.

        Questions per day

        Hover a day for its numbers.

        Most asked

        Near-identical wordings grouped together.

        Marked unhelpful

        The latest answers given a thumbs down.

        Pages used most

        Cited in the most answers.

        Pages never used

        In the live index, not cited in this period.

        By app or person

        By index

        Topics

        All questions grouped into topics by the AI, with how often each was asked and how much of it was answered.

        Conversations

        Every question from the portal and from apps, with the answer, its sources, any thumbs and comments, and your notes.

        What to do: search or filter to the answers you want (for example Not documented or Thumbs down), open one to read it, and tag it or add a note. Export downloads what you're looking at as a spreadsheet file.

        Background work

        Loads, test runs and reports since the service last started.

        What to do: nothing. A long job shows its progress here.

        Find content gaps

        Groups every question that came back not documented, was withheld, or got a thumbs down into topics, with what's missing and which page to write. Test runs are left out.

        What to do: choose a period and press Find gaps (about a minute). Then work down the list: set each gap to In progress when someone is writing it and Done once the page is loaded.

        Conflicting content

        Finds pages that disagree with each other: a different value, limit, step or wiring for the same product, platform and version. Differences explained by platform or version are left out.

        What to do: choose an index and press Find conflicts (a few minutes for a big index). For each conflict, check the two pages against the original documents, fix the wrong one, and load it again.

        People

        Tester sees only the testers' page (/ask): asks questions, rates answers and sees their own questions. Viewer sees everything and may ask questions. Operator also loads content, runs evaluations and edits the question set and instructions. Admin also manages people, apps and keys. There is always at least one Admin.

        What to do: change someone's role with the drop-down (it saves at once). New setup link gives a fresh 24-hour link for a forgotten password. Remove signs them out for good.

        Add someone

        They get a one-time link (valid for 24 hours) to choose their own password. You send it by email or Teams.

        What to do: type their email and name, choose a role (most people: Operator), press Add and make link, then copy the link and send it to them by email or Teams within 24 hours.

        Who did what

        The newest 100 changes.

        What to do: nothing. Every change in the portal is listed here with who made it.

        Apps

        Every app that calls the service has its own key. Cancelling one stops only that app. Keys are shown once, when made; only a fingerprint of each is kept.

        What to do: to stop an app, press Cancel key. To replace a lost key, cancel the old one and make a new one below.

        Add an app

        Give it only what it needs: most apps just ask questions; the GitHub Action only pushes content.

        What to do: type the app's name, tick only what it needs, press Make key, then copy the key straight away and give it to whoever sets up the app.

        Copy this key now. It won't be shown again. Give it only to the people setting up this app.

        How an app asks

        Optional: platform (inception or integriti) and index. The reply has status (answered, not_documented or withheld), answer with [n] markers, and citations, plus an answer_id. To pass on a user's thumbs: POST /api/feedback with {"answer_id": "…", "rating": "up" or "down", "comment": "…"} and the same key.

        What to do: give this example to the app's developer, with its key.

        
          

        Chat window for a website

        A chat bubble for the dealer portal or our website, with follow-ups, sources, thumbs and the support hand-off. It only works on the websites listed for its key, each visitor can ask up to 30 questions in 10 minutes, and its users only see the pages its audience allows.

        What to do: add an app above with Ask questions, the website's address under Websites allowed, and audience Dealer or Public. Then give the website's developer this line with the key in it. To try a key here first, paste it below and press Preview.

        
            

        When it can't answer

        Added to every answer that comes back not documented or withheld, in the portal, apps and the chat window, e.g. how to reach support.

        What to do: write a short message and, optionally, a link (the support form, an email as mailto:, or a phone number as tel:). Press Save. Leave both empty to add nothing.

        Teams: weekly summary and alerts

        Every Monday from 8 am a summary of the last 7 days goes to a Teams channel, plus an alert if background work fails, Azure errors pile up, or most questions come back not documented (each at most every 6 hours).

        What to do: in Teams, open the channel's ⋯ › Workflows › Post to a channel when a webhook request is received, follow the steps, and copy the address it gives. Paste it here and press Save, then Send a test.

        
          

        How to use the Knowledge System

        Everything in one place. Start with The big picture, then follow the flow you need.

        The big picture Your first ten minutes Who can do what Page builder: turn a manual into pages Library: everything we keep 1. Content: prepare and load documents 2. Ask: try a question 3. Evaluate: set up the question set 3. Evaluate: run a test loop Scoring an answer What changes in each loop Follow-ups and other languages Word list and pinned answers Who sees what (audience) Making an index live Chat window, support hand-off and Teams Dashboard: how it's going Conversations: review answers Content gaps: what to write next Keeping pages current Change the AI's instructions Add a person Connect an app Connect GitHub Words used here Common problems

        The big picture

        Answers come only from our own approved documents, with a source for every claim.

        1. Documents go in. On Content, files are loaded into an index (a searchable collection). Each file is cut into small pieces.
        2. Someone asks. On Ask (or from an app), a question is matched against the pieces. The best 8 are handed to the AI.
        3. The AI answers from those pieces only, numbering its sources like [1]. If they don't cover it, it says so and points to support.
        4. The answer is checked. If it points to a source it wasn't given, the answer is withheld.
        5. We test it properly. On Evaluate, the same five questions are asked three ways after every change, and James scores the answers. That shows what each change was worth.

        Your first ten minutes

        The test index holds made-up pages about a "Demo Reader". It isn't a real product; it's there to show how the system behaves.

        1. The test index is already loaded, so skip Content for now. Open Ask, choose index test, and ask How do I set the address of a Demo Reader on Inception?
        2. Read the answer, then Sources (where each [n] came from), then What search found (everything the AI was given; a blue edge means it used that piece).
        3. Ask How do I set the address of a Demo Reader? with no system named. Notice it answers for both systems.
        4. Set Platform to Inception and ask again. Notice the difference.
        5. Ask What is the maximum cable length for a Demo Reader? It should say this isn't documented.

        Who can do what

        Your role is shown under your initials, top right. Anything your role can't do is hidden.

        RoleCanUsually
        TesterOnly the testers' page (/ask): ask, rate answers, see their own questionsTrial testers
        ViewerSee every page, ask questions, download scoring spreadsheetsAnyone curious
        OperatorAlso create and delete indexes, load and convert files, run evaluations, edit the question set and the instructionsJoey, James
        AdminAlso add and remove people, change roles, make and cancel app keysGabriel

        Page builder: turn a manual into pages

        Page builder. Operator to build; anyone can look.

        The page builder turns a manual into separate pages in our house style. The AI plans and writes; our own checks make sure nothing was lost or made up; a person approves every page.

        How it reads a document (piece by piece). The document reader breaks the manual into pieces: headings, paragraphs, lists, warnings and notes, tables and pictures, each with the page it's on. Page headers, footers and page numbers are set aside. Our code groups the pieces into a draft from the manual's own structure (a section becomes a page; a captioned or long table, such as a parts list, a page of its own), so the same manual always gives the same draft. The AI then names, merges and splits the draft pages, and must place every piece on a page or skip it with a reason. Anything it doesn't place is kept as a page of its own, so nothing is lost quietly. The job's score shows how many pieces, tables, pictures and warnings made it onto pages.

        Document types. Chosen at upload or worked out from the name and title: a manual is split by section; a data sheet becomes one specification page; a quick start guide one procedure; release notes one page per version; a slide deck one page per topic; a spreadsheet one page per table. A poor scan gets a warning.

        1. House style (once). Open it and check the front matter rules, the headings for each page type, and the writing rules. Paste any prompt you already use (e.g. from Copilot) under Extra instructions for the AI. Try it on a piece of a manual, then save. Every change is a new version you can compare or restore.
        2. Product (once per product). Start it, then fill in its profile: platform, versions, owner, who may see it, and notes and terms. These fill in every page's front matter.
        3. Upload. Choose the product and the document, add notes if needed ("skip the warranty chapter"), press Start. A reference copy is kept; the text is read; the AI plans the pages.
        4. Plan. Check the suggested pages. Rename, change the type, move sections (s-numbers) between pages, or skip. The bar must show every section in a page or skipped on purpose. Then Write pages.
        5. Write & check. After writing, the AI also checks each part of the manual against the pages made from it and lists anything on none of them (a task, value or warning): add a page for it, or add it to a page. Each page sits next to the part of the original it came from, with checks: green fine, amber look at it (e.g. a number not in the original, fewer warnings), red must be fixed (e.g. a front matter value the house style doesn't allow). Edit and Save edit, or write a note and Redo. Then Approve.
        6. Approve & load. Choose the index and load. Each page is saved as a version with the original and style versions it came from, and can be asked straight away.

        Example: "SIFER Reader" profile, upload the SIFER installation manual with the note "skip the warranty chapter" → 12 pages planned → write → check each against the manual → approve 11, skip 1 → load into loop-2 → ask "How much power does a SIFER reader need?".

        A new revision of a manual

        1. Upload it and under This document is choose a new revision of the old one.
        2. The page builder compares the two section by section (renumbered chapters still match) and shows what changed. Each page made from the old revision is either unchanged (nothing to do), changed (only the changed parts are rewritten; your hand edits stay), or up for retiring (what it came from is gone). Sections new in this revision get new pages.
        3. Check the changed and new pages: What changed shows the page before and after; the original shows the old and new wording. Approve. For a page up for retiring, Retire takes it out, Keep it leaves it as it is.
        4. Load: changed and new pages are saved, unchanged pages are recorded against the new revision, retired pages come out of the index (their history is kept, under Library › Pages › Retired).

        Making the pages again from the same document (rebuild)

        When the house style has changed a lot, or the pages were made before pictures and the nothing-left-out check existed, choose a rebuild of the document on Upload (or Rebuild pages next to it under Library › Originals). The document is read again, the pages are planned and written afresh, and each new page takes over the saved page with the same file name (or title), so nothing is duplicated. Saved pages that match nothing are offered for retiring. Hand edits are replaced: What changed shows before and after.

        After changing the house style or a profile

        Pages made with an older version show as behind. On the Page builder, Bring pages up to date › Apply re-lays them out in the new style. The facts must not change: a check flags any value that went missing. Check, approve and load as usual; review dates stay as they were.

        Coming next: saving pages to GitHub.

        Library: everything we keep

        Records › Library. Anyone can look.

        • Originals: the reference copy of every document turned into pages (open it to see exactly what a page came from). The master stays where it is today.
        • Pages: every approved page, its version, who approved it, the original it came from, and the house style and profile versions it was made with. behind means the style or profile has changed since.
        • Style files: the house style and every product profile, with their history.
        • Pictures: every terminal layout, wiring diagram and screenshot we hold, with its description. See Pictures.
        • Storage: how much is kept, by kind, and an estimate of what it costs.

        Pictures in pages and answers

        Page builder and Library › Pictures. Operator to add and approve.

        A picture can only be found by words, so every picture has a description: what it is, of what product, and the labelled parts (LAN A, OUT1…). The AI drafts it; a person checks it. How descriptions are written is set under House style › Pictures.

        1. From a manual: when a manual goes through the Page builder, its figures are kept and described, and each one is put on the page its section goes to (as a line ![description](kb://picture/…)). The side-by-side view shows them; a check flags a picture on the page that isn't in the source, or a source picture left off. Approving the page approves its pictures.
        2. On its own: Library › Pictures › Add a picture on its own. Choose product, platform and who may see it, add the picture; the AI describes it. Edit the description, Approve, then tick it and Load it into an index: it becomes a one-line page that answers can cite.
        3. In answers: when the answer cites a passage that has a picture, the picture is shown under the answer (portal, website chat window, and the API's pictures list), with its description and where it came from. Only pictures the asker's audience may see are shown.
        4. Crowded pictures: one description can't carry a 30-terminal diagram. Add close-ups as separate pictures, each with its own description.

        Step 1 · Content: prepare and load documents

        Operator. Everything starts here: the AI can only answer from what is loaded.

        1. Create an index: Content › step 1, type a name (loop-0 for the first test) › Create.
        2. As they are today (loop 0): Content › step 2, choose the index, mode Raw, pick the folder of original PDFs and Word files › Load.
        3. Converted pages (loop 1 on): Content › Convert a document › choose the PDF or Word file › Convert. A draft .md page downloads.
        4. Open the draft in VS Code or Obsidian, fill in the front matter at the top (title, product, platform, version …), and check every heading, step and value against the original.
        5. Put the checked pages in one folder and load it in Markdown mode.
        6. Check: Content › step 3 › Show. Every file should be listed; click one to see its pieces.
        ---
        title: Configure a door in Inception
        document_id: inception-configure-door
        product: inception
        platform: inception
        content_type: procedure
        applies_to_version: Inception 9.4 and later
        source_document: Inception Programming Guide.pdf
        owner: Joey Wong
        access_level: dealer
        last_reviewed: 2026-10-08
        ---

        Step 2 · Ask: try a question

        Any role. Do this after loading, to see the answers look sensible before testing properly.

        1. Ask › type the question as a customer would ask it.
        2. Choose the index to search (main is what apps use).
        3. Leave Platform on Both unless you want to limit it to one system.
        4. Press Ask (or ⌘/Ctrl + Enter). Answers take 3 to 20 seconds.
        5. Check the status tag: answered not documented withheld.

        Step 3 · Evaluate: set up the question set

        James, then Joey. Once, before the first test run.

        1. Evaluate › Question set. Replace the placeholders with five real questions, one of each type:
        TypeWhat it tests
        procedureFinds the right procedure and gives every step in order
        specificationGives one exact value, not a near miss
        troubleshootingWorks back from a symptom to a cause
        platform trapStays on Inception when the Integriti answer is different
        not documentedA real question our documents don't answer; it should say so
        1. For each: known_answer (the correct answer James has confirmed) and three wordings: ours, customer and new_starter.
        2. Keep the spacing exactly as in the example (two spaces for each step in). If a question contains a colon, put it in quotes.
        3. Press Save question set. It lists every problem at once if anything is out of place.
        questions:
          - id: Q1
            type: procedure
            platform: inception
            known_answer: "Configuration › Doors › Add; name it; choose the reader; …"
            wordings:
              ours: How do I configure a door in Inception?
              customer: how do i add a door on my inception system
              new_starter: What are the steps to set up a new door in Inception?

        Step 3 · Evaluate: run a test loop

        Joey runs it, James scores it. The same five steps every loop; change only one thing between loops.

        1. Create: Content › step 1, type the loop's name (loop-0, loop-1 …) › Create.
        2. Load: Content › step 2, choose that index. Loop 0: Raw with the original files. Loop 1 on: Markdown with the converted pages. Pick the folder › Load. Read what was skipped and why.
        3. Check: Content › step 3 › Show. Every file should be listed.
        4. Check and run: Evaluate › step 1, choose the index. When every line of the checklist is green, press Run test. Leave the model and the platform box alone. Watch the progress bar; it takes a few minutes.
        5. Score: Evaluate › step 2 › Score on the new run. Optionally press ✦ Suggest scores first so the AI pre-marks each answer. Then, for every answer, compare it with the known answer and press Yes or No for the four checks (see Scoring an answer). It saves as you go.
        6. Compare: Evaluate › step 3 shows this loop beside the earlier ones.
        7. Log and change: Joey adds each failure to the failure log (loop, question, wording, why wrong, the fix) and picks one change for the next loop.

        Succeed: by the last loop all five are correct and cited, and the undocumented question is refused. Stop and rethink: fewer than three of five correct after loop 3.

        Scoring an answer

        In Evaluate › Score: each answer shows the known answer beside the AI's answer. Press Yes or No for each check; press it again to clear it. The Spreadsheet button downloads the same scores.

        1. AI suggestions (optional): ✦ Suggest scores has the AI read each answer against the known answer and the passages. Its suggestions show as a purple outline and "AI: Yes/No", with its reasoning. They don't count until you choose.
        2. Agree with one answer's suggestions? Use the AI's marks for this answer. Agree with all? Accept all suggestions: it only fills checks you haven't marked; your own marks stay.
        3. Use the To score filter to see what's left, and Wrong to review everything marked No.
        ColumnY when
        CorrectIt matches the known answer
        CitedIts sources point to the passage that supports it
        Right platformInception, not Integriti, and the right version
        HonestIt says it doesn't know when the documents don't cover it; otherwise Y unless it made something up
        Why wrongMeaningThe fix in a later loop
        Content missingOur documents don't contain the answerAdd or write the content
        Not foundIt's in the documents but search missed it (check the Passages sheet)Fix headings, wording or front matter
        Wrong platform or versionIt used an Integriti or wrong-version passageFix the "Applies to" information
        Made upIt said something the passages don't sayTighten the instructions

        What changes in each loop

        One change per loop, so we know what made the difference.

        LoopThe documents are…How
        0Exactly as they are todayLoad the originals in Raw mode
        1Clean MarkdownConvert each document, check it, load in Markdown mode
        2Plus front matter and an "Applies to" sectionFill in the eight fields at the top of each page
        3Split into three layersShared reader facts / Inception setup / programming, in the deck's folder layout
        4–5Whatever the failure log showsOne change each

        Follow-ups and other languages

        Ask.

        1. After an answer, just ask the next question: "and for Integriti?", "what about step 3?". The earlier questions and answers go with it, so it knows what you mean. "Searched for:" shows how it understood the question.
        2. New conversation starts again. Changing the index or audience does too.
        3. Ask in any language. It searches our English documents and answers in your language, keeping product names and part numbers as they are.
        4. Apps do the same by sending the earlier turns as history: [{"question": "…", "answer": "…"}].

        Word list and pinned answers

        Instructions & words. Operator.

        1. Word list: the words people use and what they mean in our documents, e.g. panel = controller, prox card = credential. Questions using them search their meanings too, and the AI is told what they mean.
        2. Pinned answers: a fixed, approved answer for particular questions, e.g. installer-code resets or safety warnings. Write a few wordings of the question (one per line) and the answer. Any question close enough in meaning gets that answer, with a pinned tag, without searching.
        3. Both work from the next question on. Every change is in "Who did what".

        Who sees what (audience)

        Content and Apps & keys.

        1. Each page says who may see it in its front matter: access_level: internal, dealer or public. Pages without one count as internal, the safe default.
        2. Each app key has an audience: internal (staff, everything), dealer (dealer and public pages) or public (public pages only). Its users only get answers from those pages, whatever the app asks for.
        3. On Ask, Show answers as lets you see exactly what a dealer or the public would get.

        Making an index live, and automatic re-tests

        Content and Evaluate.

        1. The live index is the one apps answer from when they don't name one. It's marked live on Content.
        2. An Admin promotes a tested loop with Make live on Content › Indexes. Apps switch at once; nothing is reloaded. The change shows in "Who did what".
        3. GitHub keeps pushing approved pages into main. Make main live once it's ready.
        4. On Evaluate, Re-test automatically runs the question set after every GitHub push, so a content change that makes answers worse shows up in step 2.

        Chat window, support hand-off and Teams

        Apps & keys. Admin.

        1. Chat window: make an app with Ask questions, the website's address under Websites allowed, and audience Dealer or Public. The website adds one line (shown on Apps & keys). Visitors get a chat bubble with follow-ups, sources and thumbs. The key only works from those websites, and each visitor can ask 30 questions in 10 minutes.
        2. When it can't answer: a message and link (support form, email or phone) added to every not-documented answer, everywhere. Raising a Zoho ticket automatically comes once we have Zoho API access.
        3. Teams: paste a channel's Workflows webhook address. A weekly summary arrives Mondays from 8 am, plus alerts when something goes wrong. Preview the summary shows what it will say.

        Dashboard: how it's going

        Records › Dashboard. Real use only; tick Include test runs to add Evaluate runs.

        1. Pick 7, 30 or 90 days. The tiles show questions asked, % answered, % not documented, withheld answers, % helpful (thumbs) and the typical answer time.
        2. Click any tile, question or thumbs-down to open those conversations.
        3. Questions per day shows answered (green), not documented (amber) and withheld (red). Hover a day for its numbers.
        4. The Content gaps and Pages to review tiles link to those pages. AI cost is an estimate from Azure's list prices; the search service and storage are a fixed monthly cost on top.
        5. Pages used most and Pages never used show which pages earn their keep. A page never used may be unfindable (fix headings or wording) or not needed.
        6. Topics (Operator) groups every question into topics with how much of each was answered.

        Conversations: review answers

        Records › Conversations.

        1. Search words in the question or answer, or filter by result, thumbs, app or person, index or tag.
        2. Click a conversation to read the answer, its sources, and any thumbs and comments.
        3. Operators can add tags (comma between them, e.g. needs content, wrong platform) and a note. They save when you leave the box.
        4. Export (CSV) downloads exactly what you're looking at, for Excel.

        Thumbs: every answer on Ask has Was this helpful? Yes / No. No asks what was wrong. Apps can send their users' thumbs too (see Apps & keys).

        Content gaps: what to write next

        Records › Content gaps. Operator.

        1. Pick a period and press Find gaps. The AI groups every not documented, withheld or thumbs-down answer into missing topics.
        2. Each gap shows what's missing, what to write, a suggested page path, its priority and how often it was asked. The questions lists them, each with a link to the conversation.
        3. Set each gap's status: open, in progress (someone is writing it), done (the page is loaded) or won't do.
        4. Run it again after new pages go in: answered questions drop out of the next report.
        5. Make page outline downloads a ready-to-fill page for a gap: front matter, the usual headings, and the questions it must answer. It contains no facts: the writer fills those from the real source.
        6. Conflicting content (same page) finds pages that disagree, so the right one can be kept.

        Keeping pages current

        Content › step 4.

        1. Every Markdown page should have owner: (who keeps it right) and last_reviewed: (when it was last checked, e.g. 2026-10-10) in its front matter.
        2. Check lists the pages overdue (not reviewed for 12 months), with no review date, due soon, or with no owner.
        3. The owner checks the page, updates last_reviewed, and it's loaded again.

        Change the AI's instructions

        Operator. Only between loops, and only when the log says "Made up".

        1. Instructions › edit the text in the box.
        2. Save as new version. Note the version number in the failure log.
        3. Every answer and spreadsheet records which version it used. Earlier versions keeps every one, so you can always go back.

        Add a person

        Admin.

        1. People › Add someone: email, name, role › Add and make link.
        2. Copy the link and send it to them by email or Teams. It works once, within 24 hours.
        3. They open it and choose their own password (at least 12 characters). Until then they show Invite pending.
        4. Forgot their password, or the link expired: New setup link next to their name.

        Connect an app

        Admin. For the Zoho desk, the website chat, the dealer portal or our apps.

        1. Apps & keys › Add an app: a name, tick Ask questions › Make key.
        2. Copy the key straight away: it isn't shown again.
        3. Give the key and the example under How an app asks to the app's developer.
        4. Its questions appear in Activity under its name. To stop it, Cancel key; no other app is affected.

        Connect GitHub

        Admin, once. After this, every approved change in the content repository updates main by itself.

        1. Apps & keys › add an app called "GitHub content repository" with only Push content ticked › copy the key.
        2. In GitHub › inner-range-knowledge › Settings › Secrets and variables › Actions: add the secret KB_INGEST_KEY (the key) and the variable KB_URL (this portal's address, without a slash at the end).
        3. GitHub › Actions › Publish to the knowledge system › Run workflow › full, once, to fill main.
        4. From then on each change to main sends only the pages that changed; deleted or moved pages are taken out.

        Words used here

        Index
        A searchable collection of documents. One per loop, plus main for apps.
        Piece
        A small part of a document (one section of a page, or about 2,000 characters of a raw file). Search finds pieces, not whole documents.
        Loop
        One round of the test: load, ask the question set, score, change one thing.
        Raw / Markdown
        Raw is a document as it is today (PDF, Word). Markdown is a tidied plain-text page with headings, the format we are moving to.
        Front matter
        The labelled lines at the top of a Markdown page (title, platform, version …) between two --- lines.
        Question set
        The five test questions, each in three wordings, with the confirmed answer.
        Instructions
        The standing rules the AI follows on every question. Versioned.
        Withheld
        The AI's answer pointed to a source it wasn't given, so it wasn't shown.
        App key
        A password for one app. Cancelling it stops only that app.

        Common problems

        A file was skipped
        The result says why and what to do (for example: an old .doc file, a PDF in Markdown mode, an empty file). Fix it and load just that file again.
        "Its front matter couldn't be read"
        The page loaded without its labels. Open it, go to the line given, and usually put a value with a colon in quotes.
        Every answer is "not documented"
        The index is probably empty or the wrong one. Check Content › What is in an index.
        "The AI service is busy"
        Azure is under load. Wait a minute and try again.
        "You're signed out"
        Sign-ins last 12 hours. Sign in again.
        A button you need isn't there
        Your role doesn't include it. Ask an Admin.
        Anything else
        Tell Gabriel what you did, which index, and the time.