Optional technical reference. This material is for developers, integration specialists and platform administrators. For the consultant lesson, read the practical guide.
Preserved from source baseline
d4587c7c0e073e58c2d430342f65ac55dd701bf4; source/static examples retain their stated scope. They are not new runtime verification or required consultant setup steps.
Current product update — 9 November 2026. App Chat is now an implemented optional App Shell feature, separate from the Studio Ask Inflow, AI Task, durable agent-run and Fabric workflows covered by this historical tutorial. An owner may configure App Chat separately with approved sources/actions and normal permission checks; none of those AI capabilities turns a generated summary into an approval. References below saying App Chat is “not a required or available step” refer only to this tutorial's workflow, not product availability. See the current App Chat lesson. The preserved text below predates App Chat and is not evidence of its runtime behavior.
Add governed AI and agents to the leave application
This tutorial adds an assistant capability to the reader-created people-ops application. It uses only fictional request leave-2026-014: Mohammad requests five days,14–18December2026, and Sara's decision is pending. Nadia is the builder; an AI administrator owns connection/model preparation. Replace all account/resource IDs, versions and revisions with actual admitted values from the identity, data/rule and App Shell tutorials.
The goal is to summarize or explain, not to let a model approve leave. Current Studio Ask Inflow, AI Task rules, durable agent runs and Fabric are implemented surfaces with distinct contracts. The separately planned floating app-specific App Chat is not a required or available step here. Generic memory grouping is not private conversation ownership.
The procedures are source-reviewed. No actual provider, application, materialization or UI workflow was executed for this documentation; runtime/provider/video/CI evidence remains NOT_RUN. Preparing an external connection or pressing Try may spend a provider attempt and requires the existing owner's authority.
Milestone 1 — Classify the input and keep permission separate from disclosure
Inputs. Use the synthetic leave request, actual workspace/actor context and a bounded explanation goal. If adapting the lesson to real personnel records, the human's ability to view them does not automatically approve sending them to a model, embedding endpoint, derived index or log.
Procedure. Write down the minimal facts the summary needs: fictional request identifier, dates, requested quantity and pending review. Exclude private notes, medical details and unrelated employee history. Have the actual data/AI-policy owner establish permitted disclosure and model classification before an external run. Decide whether the task reads Text, a governed DOCUMENT or an admitted Fabric dataset; each has its own source boundary.
Expected result. The teaching fixture has a clear content and authority boundary before model selection. A scope prefix, provider URL, prompt instruction or human view permission is not treated as a disclosure grant. Native source checks remain in force at execution.
Failure and recovery. If the owner cannot admit the intended content/provider route, continue with nonconfidential synthetic text or stop that branch. Do not copy private material into a Text input, generic memory or an index to bypass the actual policy. An unavailable permission/policy result is not approval by default.
Sources. Governed AI Task document adapter, Fabric contract/policy admission, generic memory boundary.
Milestone 2 — Prepare a real connection-backed model
Inputs. An authorized administrator owns the admitted endpoint and protected credential reference. The illustrative connection key people-ai is not a built-in provider. Nadia needs only the actual returned platform model coordinate for later rule/agent configuration.
Procedure. Create/update the connection through AI providers, keep credential material in its protected mechanism, and discover/select an actual vendor model only when the external attempt is authorized. Enable the intended connection and inspect the gateway's actual models/runtime plan. Retain the returned connection ID, connectionKey, vendor model ID and platform model ID as distinct values. Review the workspace allowlists, enabled state and monthly token limit; configure the purpose default only if that is the owner's chosen route.
Expected result. The task can refer to a real enabled model, commonly <connectionKey>-chat, with the capability/classification needed for the selected operation. A stored connection or runtime plan alone is not proof of reachability or a successful prompt.
Failure and recovery. Leave AI unavailable when no real admitted model exists. Ask the provider owner to resolve endpoint, credential, model or policy issues specifically. Do not copy obsolete seeded models, change to another agent's credential or remove token limits merely to make the lesson run.
Sources. Connection administration, model/runtime catalog, workspace policy/usage.
Milestone 3 — Author an explicit AI Task contract
Inputs. Nadia has actual rule-authoring permission and the chosen admitted model. The synthetic text contains the request facts and states that review is pending. The business result should be a summary, not an authoritative approve/decline decision.
Procedure. Choose Summarize Text and walk Goal, Inputs, Instructions, Result, Model and Try & publish. Connect a named required Text input, insert its actual prompt chip and limit instructions to facts/questions. Choose Return as Text or deliberately define typed JSON fields for a consumer; do not leave the downstream shape implicit. If using a DOCUMENT, select an actual admitted library ID whose supported extracted text exists. The saved prompt/schema belongs to the task body, independent of later template changes.
Illustrative caller input, not the rule execution envelope:
{"text":"Fictional leave-2026-014: Mohammad requests five working days,14–18December2026. Sara's review is pending. Summarize facts and unresolved questions only."}
Expected result. A saved task has explicit bindings, result shape, route and disclosure classification. A fixed language or instruction value belongs in its actual source:value binding, not a made-up caller path. JSON-schema field descriptions alone do not persist a business decision.
Failure and recovery. Correct unknown chips, missing required inputs and unsupported result fields through the wizard. A binary document without governed extracted text is refused rather than decoded arbitrarily. Do not weaken source policy or invent a model result to satisfy the publish checklist.
Sources. Actual template, self-contained rule contract, wizard.
Milestone 4 — Try, evaluate and publish the intended rule version
Inputs. Use only the admitted synthetic sample, saved draft and actual model. Retain failed test evidence as well as successful output. Text wording is nondeterministic; typed JSON output must obey its actual field/required/mapping contract.
Procedure. Run the native Try action only when permitted. Inspect the typed result first and safe diagnostics separately. Save a meaningful successful sample as an example, then deliberately review its expected mapped output. After changing instructions or schema, save the draft and re-check the example through the native surface. Publish the reviewed task and retain the actual rule key/version; configure consumers through that declared signature rather than assuming an unversioned latest draft is equivalent.
Expected result. The reader distinguishes matching output, a genuine output difference and a refused/unavailable runtime. A run that did not reach a model is not scored as a successful error-shaped business answer. A published rule exists only after native acceptance.
Failure and recovery. Resolve the actual model/input/output failure before another authorized attempt. Do not copy an erroneous answer into expected output just to turn the example green. Browser Stop ends its wait but may not cancel the provider request; preserve native usage and uncertain outcomes rather than reporting cancellation as proven.
Sources. Text/JSON and unavailable-run result handling, declared caller signature, wizard execution surface.
Milestone 5 — Use Fabric only through admitted plans and record policy
Inputs. This optional branch needs an actual synthetic dataset whose source, parameters and cross-workspace contract are admitted. Skip materialization when a Text-only summary meets the goal. A model's request for more data is not permission to fetch it.
Procedure. Discover the permitted dataset, inspect readiness and resolve its actual parameter declaration. Fabric request DTOs use {"parameters":{"values":{"employeeId":"ACTUAL_SYNTHETIC_ID"}}} when employeeId is declared; relationship inputs likewise use leftSide.values. These are VariableMap wrappers, unlike an AI task DTO that explicitly accepts flat input fields. Review the returned plan before an authorized materialization. Keep the original idempotency key and returned run coordinates. Read records through the native dataset/run routes with current mask/deny policy and bounded limit/after paging, then disclose only the separately approved projection to the AI task.
When the data-owner step uses the separate Studio Fabric designer (/api/fabrics), a viewable Fabric may show blank connectorId and objectRef because its bound source is hidden. Preserve that redacted pair and the unchanged binding when saving unrelated edits; do not interpret it as a missing source, guess the table or substitute a raw query. The service restores the stored source for an unchanged binding and still refuses unauthorized binding changes. Its publish response is also redacted while replication uses the stored source. Continue only with currently admitted preview/record access and the separately approved AI projection.
Expected result. Discovery, planning, execution and record reading have distinct results. Cross-workspace relationships retain the governing dataset contract gate. A visible catalog object does not prove every row is readable or every readable value may be sent to a provider.
Failure and recovery. Treat denied or unavailable data as unavailable, not an empty analytic result or a zero total. Resolve the source/contract/policy issue with its owner. After uncertain materialization, reconcile the original intent before force-refreshing again. Never query raw storage or strip masked fields from a copied source to bypass governance.
Sources. Dataset resolve/materialize, governed keyset record reads, relationship contract gate, separate Studio Fabric binding projection, unchanged/changed binding guard, publish response versus stored-source sync.
Milestone 6 — Start and inspect a bounded catalog agent
Inputs. Nadia selected an actual active case-summary agent and knows its allowed tool/connector lists. The synthetic goal is to prepare information for Sara, not to complete her business task. The integration has actual run-start/view permissions and any required admitted model.
Procedure. Start one durable run with its actual agent ID, bounded goal, minimal context and a permitted requested subset. Retain the returned run ID and inspect status/logs/attempts. Let admitted workers claim/renew/release their own work. If the run genuinely waits for a human, use its native resume contract with an explicit context patch and message; keep business-task approval separate.
Expected result. A policy-snapshotted run records PENDING/RUNNING/wait/outcome states. An unlisted tool/connector is refused before normal execution, while later tool services keep their own access/effect checks. A completed summary is evidence about that agent run, not proof of an approved vacation or a fully verified application.
Failure and recovery. Inspect timeouts and uncertain remote effects before repeating a run. Do not widen the allowlist, impersonate a worker or force a completion to match a desired story. Preserve actual failed attempts and ask the accountable service owner to reconcile an unknown connector result.
Sources. Catalog definition, run routes, policy subset admission.
Milestone 7 — Keep conversation memory, proposals and business decisions distinct
Inputs. Nadia may use the actual Studio Agent's owned conversation to discuss the application. She has the current conversation ID/revision and its admitted context. This is not a new floating App Shell chat or a generic memory scope prefix.
Procedure. Create/reopen through the owned conversation service. Send with the original clientRequestId and current expectedRevision, resolve current source context, and inspect event/memory lineage. Accept or reject an actual memory proposal through its native decision route. For a bounded goal/change proposal, review its discriminated target, revision, allowed option and separate sensitive gate where applicable. Sara's vacation response remains in the actual task form/action contract from the workflow tutorial.
Expected result. The assistant can explain and prepare within its current owned context. An ordinary chat message, memory acceptance or model-generated recommendation is not silently substituted for a business task receipt or native effect authorization. Stored source prose does not create a new grant after revocation.
Failure and recovery. Reconcile stale revisions and original unknown turn intents instead of creating competing requests. When source access is unavailable, continue only with admitted context. Do not migrate private history into generic /api/agent-memory, borrow another user's session or claim that a tool's “done” text establishes published/runtime correctness.
Sources. Owned conversation/messages/memories, send revision/intent body, discriminated decision.
The final worksheet
Retain the actual provider/connection/model/purpose IDs, AI task key/version/input/result contract, admitted dataset/parameters if used, durable agent run ID/outcome, owned conversation/revision/original turn intents and any native business task receipt. These are separate evidence items. Their existence does not establish each other's access, disclosure or success. See AI Gateway, AI Task rules, agent execution, memory boundaries and Studio Agent for the full worked reference.