IAM.Agent: connect IAM services in the development candidate

Availability and prerequisites

This guide covers a development candidate built from a source checkout, not a published release. The new Enterprise controls and separate Community preview still require staging acceptance, supported-platform builds and coordinated publication. If your installed version lacks these fields, use the source build provided by the developer.

Obtain the correct environment endpoint, available model and separate credentials for Router or Secure, Core MCP, Docs and Mind from your administrator. Access to one service does not grant access to the others. Native configuration requires the desktop runtime; an Enterprise browser preview cannot persist settings in the native engine.

Each capture states its provenance. Historical MCP/audio captures use an educational transport fixture. New document captures use real Core, Docs, Mind and Router staging with owned synthetic sources, generated files and completed ingestion receipts; they contain no customer material.

Router and Secure attribution

1. Open Settings → Providers, then IAM Router & Secure.
2. Set IAM Router API URL to the administrator-provided OpenAI-compatible endpoint ending in /v1. To process traffic through Secure, use the address of the configured Secure gateway.
3. Enter that gateway’s credential in IAM Router API key. The saved value is hidden after reopening; do not manually replace it with mask characters.
4. Leave IAM Secure request attribution at Standard routing, or choose Secure inline attribution when your administrator has configured the internal gateway with IAM_SECURE_APP.
5. Select the IAM Router provider and a model permitted by your key for a task. Send a short request without personal data and inspect its response.

Attribution by itself does not change the endpoint or enable DLP. Protection requires a separate synthetic staging policy test and evidence from the gateway; an ordinary successful answer does not prove protection. Correct endpoint, key or model errors using administrator-provided settings. Do not switch to a direct external provider to bypass Secure refusal.

When Secure returns blocked_by_policy or a blocked policy event, direct chat ends with a policy error. Task execution discards partial output and stops without escalating to another provider. Review the authorized policy with your administrator before submitting a changed request; a blocked result is not a completed document or task.

Connect IAM.Core, Docs or Mind through MCP

1. Open MCP servers. In Add server, enter a Name, such as IAM.Core staging.
2. Choose http (Streamable JSON-RPC / SSE) under Transport. Set URL to the exact MCP endpoint, usually ending in /mcp; a Router inference URL is different.
3. Enter supplied credentials in HTTP headers (NAME=VALUE per line), one header per line. A bearer-token example is Authorization=Bearer YOUR_TOKEN; this is a format example, not a working key.
4. Keep Enabled selected and click Add. Click Test in the server row: the lightning icon has the Check connection tooltip. Inspect the server identity and discovered tools.
5. Click Publish tools to refresh engine tools. Refresh reloads the configured server list.
6. Repeat for another service using its endpoint and authorization. If Core already provides the required Docs/Voice/Speech tools, add a separate server only when needed.
7. To replace a token, click Edit: leaving the mask unchanged preserves the saved value, entering a new value replaces it, and removing the line clears that header. Click Save. Use Disable to turn a server off or Delete to remove it.

Remote credential-bearing connections require HTTPS; loopback HTTP is allowed for local services. Do not put tokens in URLs. The negotiated JSON/SSE behavior is described in the direct document workflow below.

The online badge indicates enabled configuration, not successful connectivity. Test and the tool list confirm discovery; separately invoke a permitted operation with synthetic data. A tool name alone does not prove authorization, access to the real iamdocs corpus or success of every project action. For 401/403, check token expiry and roles; for discovery errors, check the endpoint and supported transport. Errors from authenticated peers may deliberately omit server response bodies.

Enlarge screenshot

1 2 3 4 5 6

1. MCP
2. URL
3. HTTP headers (NAME=VALUE per line)
4. Save
5. Test
6. Discovered synthetic tools

Service bindings in IAM workspace

1. Open Settings → IAM workspace, or click the cable icon named IAM workspace at the bottom of the sidebar. This opens /settings/services.
2. Under Service connections, select an existing MCP server separately for IAM.Core, IAM.Docs, IAM.Mind, IAM.Voice, IAM.Speech and IAM.Market / Hosting. If it has not been added, click Configure MCP servers and follow the steps above.
3. Click Check for the selected service. A successful handshake/discovery refreshes the local catalog. Refresh catalog reloads configuration and published tools; Inspect tools expands their list.
4. For Server disabled, enable the configuration in MCP servers. For Saved server unavailable, select an existing configuration. For No published tools, test the server and confirm the token permits the required operations.

A binding associates a service row with an MCP server in this client; it creates no account or permissions. The count covers locally published tools from that server, rather than successfully verified actions of the named product. The same Core server may serve several rows. Configure Router & Secure opens provider settings; Open MultiWork opens the existing multi-task interface.

Enlarge screenshot

1 2 3 4 5 6 7 8 9 10

1. IAM workspace
2. Document task
3. Source scope or search query
4. Workflow
5. Output format — XLSX
6. Generation — exact catalog operation
7. Worksheet enumeration — exact catalog operation
8. Read saved content — exact catalog operation
9. IAM.Core connection
10. Check IAM.Core

MultiWork: failed prerequisite tasks

If a required prerequisite in the Rust Enterprise Director fails or its worker crashes, tasks that depend on it are skipped and do not execute their actions. Independent tasks can still finish: failure in one branch does not establish success or stop every other branch.

Inspect each task result and the completed, failed and skipped counts. The existing timeline shows Run finished · N done / N failed / N skipped; the run phase is failed when at least one task failed. A DagCompleted event means graph processing has ended, not that every task succeeded. For example, one failed prerequisite can leave one independent task completed, one task failed and two tasks skipped. Fix the cause, review actions that already ran and prepare a new run; do not treat skipped actions as completed or repeat external writes without checking their receipts.

Community 0.1.4 candidate: dependency teams

The Teams panel was introduced in Community 0.1.4; the reviewed 0.1.5 archive below also includes it. You need an open workspace session, a configured model and the parent’s permissions for the selected folder. The operator keeps IAM_HARNESS_HOME outside IAM_AGENT_WORKSPACE to separate the dispatch journal from normal working files. This is not an absolute filesystem boundary: children retain native parent permissions, including operator-selected Full Access. Changing a connection, model, access preset, sandbox or operator limits invalidates the previous graph review.

1. In the workspace session, click Teams. Loading Saved graphs reads the journal without invoking a model.
2. Under Task graph JSON, set title, concurrency, deadlineMs and a nodes array. Each node needs a unique id, exact prompt and dependsOn list containing required prerequisite IDs. Do not add credentials, URLs, a model or a preset to this JSON.
3. Click Prepare graph review. A cycle, missing dependency, duplicate ID or invalid limit is refused before dispatch. Up to 16 nodes, concurrency 1–4 and a deadline up to 10 minutes are allowed; the operator can reduce concurrency and the deadline.
4. Review the normalized graph, exact Review SHA256, dependencies and effective limits. Check the separate execution approval, then click Approve and run once. Native DSH children inherit the current parent’s model, permissions, preset and sandbox; the graph cannot widen them.
5. Click Refresh exact graph. A failed prerequisite makes its dependent descendants skipped without starting them; an independent branch can still finish. 1 done / 1 failed / 2 skipped means graph failure, not overall success. Child output is labelled as untrusted.
6. To stop, check the separate approval to cancel this graph’s owned children, then click Cancel owned team. Confirmed cleanup and unknown remain different. Earlier file changes are not undone; Close only closes the panel and does not stop accepted work.
7. After restart, open Teams → Saved graphs, select the exact receipt and inspect its statuses. unknown/needs_review after process loss or a lost acknowledgment never automatically replays the accepted graph or its remaining nodes. Inspect the original DSH sessions and files first; uncertainty is neither success nor confirmed termination.

Node count, directly managed children, concurrency and time limits are enforced. Aggregate token and turn budgets are not implemented. Candidate local acceptance uses the actual rc.2 runtime with a scripted loopback provider; it does not qualify live multi-model quality or Windows. A clean installation of this archive was checked on macOS and Linux; the minimum Node.js 22.19.0 was checked on Linux. Coordinated documentation publication remains a separate gate.

Enlarge screenshot

1 2 3 4

1. Check review SHA256
2. Prepared locally without execution
3. Separate execution approval
4. Run unavailable before approval

Documents: from a request to verified output

1. Under Documents & knowledge, enter a Document task. Preparation requires a nonempty task.
2. Set Source scope or search query to permitted collections or a subject. Choose a Workflow: Generate a document, Review a document, Compare documents or Research with sources.
3. Choose DOCX, PDF, XLSX, PPTX or Markdown under Output format. Select only permitted IAM.Docs and IAM.Mind under Requested sources.
4. Inspect Export and verification tools for the selected format. Generation, Read saved content, Visual rendering and additional checks appear separately. In catalog means the exact tool and required operation are advertised by its schema; Not in catalog means the required capability was not discovered.
5. Click Prepare in Cowork. The application merges structured instructions into your existing Cowork draft and opens it. It does not automatically send a request, search or create a file.
6. Review the merged draft, sources and available tools, then send the task separately in Cowork. Configure any missing service first: selecting a source checkbox does not connect its database.

Specify the output format, permitted iamdocs collections, subject, audience and allowed Mind use. For example: “Using the educational collection, prepare a DOCX draft, cite source versions and mark unsupported statements.” Keep private material out of unqualified environments.

Expected operations depend on the selected format:

The catalog matches exact IDs and schema op.enum values rather than a service name. Remote proxies display their complete mcp__…__documents.write or mcp__…__documents.read ID. Generation alone does not establish readback, recalculation or rendering. If the catalog is loading or unavailable, wait or open the desktop application and click Refresh catalog; unknown availability is not a confirmed missing tool.

Refresh the catalog after adding a server. When verification tools are incomplete, the agent must identify omitted checks and provide a draft instead of promising a finished file. Even a complete In catalog set does not establish installed runtime dependencies, permissions, successful export or review of every page. For XLSX, check recalculated values and formula errors; for PPTX, review the count and readability of every slide; for DOCX, inspect pages, tables, citations and clipping. Markdown presentation needs a separate viewer check: text readback and link checks alone do not establish visual verification.

The existing Rust engine contains DOCX/XLSX/PPTX operations and PDF reading. Execution depends on Python, the required libraries, LibreOffice for preview/recalculation and build options. Connecting MCP does not install these dependencies. The direct workflow below has independent real-service educational staging checks in both editions. It creates a new Docs document; no version-replacement API is advertised. This does not establish all-platform or every-account readiness.

Before using output, inspect the artifact, source references and access permissions; review rendered pages, tables and recalculated formula values. A saved task or draft text is not a created and verified document. Publish, replace a version or send it only after checking the corresponding operation result.

Generate directly from Docs and Mind evidence

The administrator connects Core to the actual IAM.Docs REST API and binds your exact Core identity to a delegated Docs account. Core verifies /auth/me on every operation; Docs retains ACL enforcement. Retrieval needs docs:read, while uploading separately needs docs:write. A failed live connection never falls back to fixture JSON data. Docs search scans a bounded lexical window of the authorized catalog; coverage metadata does not mean semantic full-corpus retrieval.

1. Fill the document goal and source query in Documents and knowledge. In Document generation, enter Document title, then choose Get authorized sources. Retrieval alone does not invoke a model or upload a file.
2. Review excerpts, identifiers, versions and coverage limits. Choose Create editable outline. This action sends authorized source text to the configured Router provider.
3. Edit section headings and instructions and select cited sources. Every paragraph must reference existing evidence. Unknown references, changed documents or withdrawn access block reuse: retrieve fresh evidence.
4. Generate the selected format. The host writes and independently reads the local file, then performs available recalculation and rendering. Readback, rendered pages and pending human visual review have separate statuses. Citations establish traceability, not factual entailment.
5. Open the artifact and actual pages. Review every page/slide, source reference, table and calculated value. A PDF needs its own extracted-text check rather than relying only on its DOCX source.
6. Separately choose Create new IAM.Docs document for the desired format. Uploading verified bytes also requests ingestion. pending or processing does not mean completion.
7. Choose Check processing and readback. Completion requires completed plus matching full paragraphs and source references. Upload SHA identifies submitted bytes; this path does not compare remote original-file bytes.

Saved document run reopens a private snapshot after restart. Changed credentials invalidate the binding; retrieve fresh authorized sources. An uncertain upload cannot be retried automatically: retain the known document ID and reconcile Docs before creating another file. If ingestion start fails after accepted upload, keep the ID and diagnostic rather than uploading again. No version replacement API is advertised.

For remote readback, the client checks the authenticated complete extracted text, its declared basis and SHA-256, and refuses truncated or incomplete-page results. Search chunks can omit headers or footnotes and therefore cannot alone prove complete file content. Extracted document state can be edited by authorized Docs operations; this is not an immutable comparison of downloaded original-file bytes.

If Preview file access timed out appears, check OS access to the selected local workspace folder. Resolve access before reopening the saved run; restart the application if the original OS file-read request is still waiting. Do not repeat a document upload to repair a local preview permission error.

Enlarge screenshot

1 2 3 4

1. Open DOCX
2. Open PDF
3. Preview page 1
4. Actual generated document page 1

The same workflow in Community

Open ▤ IAM.Docs / Mind from the composer. Fill Document title, Goal and constraints, Source query and Output format, then Retrieve sources. Review Read evidence excerpt and Coverage details. Edit sections, Instructions and Evidence IDs, choose Save reviewed outline, then Generate local artifact.

View actual pages, Previous and Next show real PNG pages. Before publishing, check I reviewed the cited sources and actual artifact, enter Reason for saving, and choose Save new document and process. Check the existing document ID with Verify saved document until completed and readback verified: true. Resume existing run → Load run restores a host-minted local UUID; that UUID grants no access to another workspace or account.

The operator separately enables writes with IAM_DOCS_ALLOW_WRITE=1. The panel uses IAM_CORE_MCP_URL/TOKEN for Docs, IAM_MIND_MCP_URL/TOKEN for Mind and IAM_ROUTER_URL/API_KEY/MODEL for generation. IAM_DOCS_MCP_URL registers a general upstream MCP connection and does not by itself configure the panel’s REST profile. Never publish credentials or the complete token-bearing DSH sign-in URL. Real-service educational staging checks do not qualify every operating system, model or customer account.

Enterprise HTTP now negotiates supported protocol versions/session IDs and receives JSON or bounded SSE until the matching response. Use the administrator-issued official IAM.Mind /mcp/legacy endpoint for classic mind_memory_recall/get with protocol 2025-11-25. The primary 2026-07-28 protocol requires its corresponding connector: this app does not manufacture native proofs or widen memory access.

Enlarge screenshot

1 2 3 4 5 6

1. Document title
2. Goal and constraints
3. Source query
4. Output format
5. Section 1
6. Evidence IDs, separated by commas

Enlarge screenshot

1 2 3

1. Readback / rendered / visual status
2. View actual pages
3. Actual generated document page 1

Enlarge screenshot

1 2 3 4

1. I reviewed the cited sources and actual artifact.
2. Reason for saving
3. Verify saved document
4. IAM.Docs completed readback receipt

Run an installed IAM.Market / Hosting agent

This native REST connection is separate from the optional Market MCP binding. Obtain the exact environment origin and an account credential from your administrator. The account must already have an authorized installation; this panel does not purchase or install an agent.

1. Under IAM.Market / Hosting, set Marketplace HTTPS origin and Marketplace credential, then Save native connection. After saving, a blank credential keeps the existing value. Changing origin requires a replacement credential or Remove native credential. The saved credential is masked and is not stored in browser storage.
2. Choose List my hosted agents, then select Hosted agent. This lists account-authorized installations without starting a task.
3. Fill Hosted task and Reason, then Prepare reviewed task. Review the locally saved intent and agent identity; preparation does not invoke the remote agent.
4. Separately choose Invoke reviewed task. An accepted asynchronous request is initially running. Use Read status and transcript until the real run is completed, failed or aborted; review its response and artifacts.
5. Saved hosted task restores a private intent after restart. It is bound to the local workspace and exact account configuration. Credential rotation or a different workspace can hide/refuse an old intent; this does not cancel its remote run.
6. Wake selected agent and Resume selected agent are explicit remote changes requiring a reason. Resume recovers the backend’s quota-paused installation when quota is available. There is no generic pause operation in this client.

The native ledger consumes an intent before sending it. Restart or an unknown network outcome never automatically repeats the invocation. Reconcile an uncertain run in IAM.Market history before preparing a different task. The client does not guess remote run IDs or follow arbitrary transcript URLs. Community exposes the same installed-agent list/invoke/transcript routes through iam_market_list, iam_market_run and iam_market_transcript; the operator separately enables invocation with IAM_MARKET_ALLOW_RUN=1.

Enlarge screenshot

1 2 3 4

1. Saved hosted task
2. Status: completed
3. Read status and transcript
4. Agent response

Record speech and add its transcript to a task

1. In IAM workspace, connect IAM.Speech or IAM.Core and confirm the selected server publishes speech.transcribe. The IAM.Speech binding takes precedence; IAM.Core is used when no Speech binding is selected.
2. Under IAM.Speech, enter IAM tenant ID and optionally Language hint (optional). The tenant does not override bearer-token authorization. Current Core accepts the language hint as a compatibility field but does not forward it to its ASR backend.
3. Click Record audio, allow microphone access, then Stop recording. Capture is limited to 60 seconds and 8 MiB. Alternatively use Select audio file with a nonempty file up to 8 MiB. Recording and selecting a file do not upload audio.
4. Check the local-audio-ready status and click Transcribe with IAM.Speech. Only this action uploads audio to the selected MCP server. Wait for the response. Discard local audio is disabled during processing and does not cancel an already dispatched remote request.
5. Edit Transcript, then click Add transcript to task to append it to Document task. Separately choose Prepare in Cowork, review the draft and send it to continue.
6. Use Discard local audio to clear the local clip and previous text. If recording is unavailable in the runtime, use an authorized audio file. For microphone refusal, check OS permission; for transcription failure, check MCP connectivity, tenant and roles.

This panel belongs to the new Enterprise source build. The existing composer microphone continues to use browser SpeechRecognition; recording in this panel does not change that route. A separate educational staging service check completed real Voice synthesis followed by Speech recognition. It does not qualify microphone hardware or recognition quality on every OS; the historical screenshot below remains a synthetic transport fixture.

Enlarge screenshot

1 2 3 4

1. IAM tenant ID
2. Transcribe with IAM.Speech
3. Transcript
4. Add transcript to task

Enlarge screenshot

1 2 3 4 5 6 7 8

1. Prepare in Cowork
2. IAM tenant ID
3. Record audio
4. Select audio file
5. Transcribe with IAM.Speech
6. Discard local audio
7. Transcript — synthetic transport only
8. Add transcript to task

Community preview: based on deepseek-harness

Community is distributed as the separate application-root archive iamgroup-agent-community-harness-0.1.5.tgz; this is distinct from the existing Community Tauri application. Node.js 22.19.0 or newer and npm are required. Obtain the reviewed archive and its SHA256 from the operator, verify the hash and extract into a new empty folder. Do not install it globally, through npx or as a dependency in another npm project: that layout can ignore overrides and select vulnerable nested SDK/ZIP dependencies.

Reviewed development archive SHA256:

f17c97db9295b3c9320a76bc19593fa541d3c1755a55033adc7d0b396a5525f6

mkdir iam-agent-community-0.1.5
tar -xzf iamgroup-agent-community-harness-0.1.5.tgz -C iam-agent-community-0.1.5
cd iam-agent-community-0.1.5/package
npm ci --omit=dev
npm run doctor
npm run compatibility
npm start

The launcher, doctor and IAM plugin startup check the versions actually resolved: DSH 0.2.0-rc.2, MCP client/core 2.2.0, LibreOfficeKit 0.1.5 and every used fflate 0.8.3. If Unsupported dependency graph appears, stop and extract the reviewed archive into a separate new folder, then run npm ci --omit=dev; do not repair another project with npm audit fix --force. Startup never installs or downloads packages. On Windows, open the extracted package folder in a terminal and run the same npm commands. For development, the source directory apps/iam-agent-community/harness must also be a separate application root: run npm ci, then npm run build.

Open the local URL printed by the runtime. It may contain an access token: do not share it. Upstream onboarding offers Continue and Configure later; the workspace then includes New session, workspace/access-mode/model selection, the composer, Settings and Plugins. IAM branding displays based on deepseek-harness.

Before starting, set environment variables through your system’s approved secret-management method:

IAM_EXTERNAL_CLI_ALLOW and IAM_MARKET_ALLOW_RUN only enable the tools. Each model-initiated iam_external_agent, iam_market_run or iam_speech_transcribe call separately requires native DSH approval for the displayed provider, task, cloud run or audio file. Reject the request if the provider or task differs from your intent; a headless session without an approval handler refuses execution. The IAM.Speech browser panel continues to send audio through the separate Transcribe with IAM.Speech button.

Starting with Community 0.1.5, native chat and cited document generation send X-IAM-Secure-Strict: true. The header alone does not enable DLP: inspection requires the configured Secure endpoint and its key. A strict Secure block remains an HTTP error and does not produce a generated document. Model selection alone does not prove which hardware ran a request; compare actual Router attribution and audit. The browser bundle is byte-identical to 0.1.4, shown in the original reviewed Teams capture above.

doctor reports configuration indicators without keys; it does not test services. compatibility checks upstream profile composition rather than live IAM execution. The runtime is pinned to published 0.2.0-rc.2; the compared local source snapshot 0.2.1-alpha.3 differs. Full compatibility with that snapshot and functional parity with Enterprise remain unqualified.

Connected servers dynamically provide the MCP tools permitted to the account. Additional tools include installation listing through iam_market_list, transcript reading through iam_market_transcript, opt-in cloud execution through iam_market_run, local audio-file transcription through iam_speech_transcribe, and explicitly enabled external CLIs through iam_external_agent. An accepted cloud request is not a completed run: inspect transcript/status and artifacts. Do not blindly repeat a write request after a network failure.

Community DeepSeek: IAM.Speech candidate panel

The operator starts the host with IAM_CORE_MCP_URL, IAM_CORE_MCP_TOKEN and IAM_TENANT_ID. The endpoint, backend token and tenant remain host-side; the browser panel has no tenant field or backend-credential editor. Use the authenticated local interface opened by the preview launcher.

1. In the composer, click ◉ IAM.Speech. If IAM.Speech is not configured appears, ask the operator to configure Core and its tenant; do not paste credentials into the conversation.
2. Click Record audio, allow microphone access, then Stop recording, or use Choose audio file. Preparation stays local: the original file is limited to 16 MiB and audio duration to 120 seconds. The browser converts audio to 16 kHz mono PCM16 WAV before a separate upload.
3. Under Recognition language, choose Detect automatically, Русский or English. Click Transcribe with IAM.Speech only when ready to send audio to configured Core. Stopping capture or selecting a file does not upload it. A language hint does not guarantee the current ASR backend will force that language.
4. Review and edit Reviewed transcript, then separately click Add to draft. Text enters the unsent composer; this action never clicks Send. Inspect the draft before sending it yourself.
5. Cancel / discard audio clears prepared audio/text and aborts waiting for the current request. Close closes the panel and cancels its current operations. Late results from cancelled operations cannot enter the draft. This does not confirm that already started server-side processing has stopped.

The file picker offers audio/* and WAV, MP3, M4A, OGG, WebM and FLAC extensions; decoding an individual file depends on browser codec support. If decoding fails, use a short file supported by that browser. Recording requires a secure browser context and MediaRecorder. These limits differ from the Enterprise panel’s 60 seconds / 8 MiB.

A real browser check used an owned 2.6-second synthetic WAV from IAM.Voice and the actual Core/Speech staging service: Choose audio file → separate Transcribe with IAM.Speech → Reviewed transcript produced “Это учебная проверка голоса и речи.”. A separate Add to draft action inserted it into the unsent composer; Send was not clicked. This qualifies file input, real ASR and draft insertion for that example. Hardware microphone capture and its OS permission flow remain unqualified; responsive browser UI is not a native iOS/Android app.

Enlarge screenshot

1 2 3 4 5

1. Choose audio file
2. Prepared WAV — local until Transcribe
3. Transcribe with IAM.Speech
4. Reviewed transcript — real staging ASR
5. Add to draft — never Send

The historical captures below retain their synthetic Core transport fixture: they demonstrate preparation, editing and unsent insertion, without real speech recognition.

Enlarge screenshot

1 2 3 4 5 6 7 8

1. Record audio
2. Choose audio file
3. Recognition language
4. Transcribe with IAM.Speech
5. Cancel / discard audio
6. Reviewed transcript — synthetic only
7. Add to draft — never Send
8. Close

Enlarge screenshot

1 2 3 4 5 6 7 8

1. Record audio
2. Choose audio file
3. Recognition language
4. Transcribe with IAM.Speech
5. Cancel / discard audio
6. Reviewed transcript — synthetic only
7. Add to draft — never Send
8. Close

Finished public native installers and complete Enterprise parity remain unqualified. Separate native Community and Enterprise mobile companions now have iOS/Android development builds: bounded local PDF, OCR, DOCX/OpenXML, WAV and text processing, protected storage and receipt restoration were tested on Simulator/Emulator. They are separate apps; the responsive browser capture above does not substitute for them. On-phone model execution, hardware microphone capture, physical devices and store publication are not qualified. A source package and local interface do not establish production publication.

Document session scope and actual model provenance checks are described in the IAM.Docs guide. Qualification of that document staging stand does not establish a production update. For an expired or revoked connection, sign in normally with a current session; the previous local journal stays bound to the old connection and is not automatically rebound. Read the exact known ID/UUID to verify an outcome; repeating a write is not a way to recover a lost receipt.

In Community 0.1.3, dynamic MCP calls from the configured iam_core, iamdocs and iammind connections also require native review of the exact operation and arguments, even if a broad upstream rule permits the tool. Existing denials and pending approval requests remain in effect. In headless without an available answerer the operation is refused before dispatch; connecting a service does not authorize unattended writes.

Real Speech dialogue access through Core and the verified IAM.Identity sign-in are described in the Speech guide. This is a staging candidate with a short session and separate permissions; it does not enable a durable connection for every account.