How do you connect Super Intelligence to workplace documents and files? Start by deciding which files are authoritative, which users may access them, whether SI should read them live or through an index, how changes will refresh, how citations will point back to the source, and whether the system is allowed to write or modify anything.
Connecting SI to files is not the same as uploading documents into a chat. Workplace document access is an operating design problem involving permissions, version control, file identity, provenance, sync, deletion, retention, source-of-truth rules and recovery.
This article is part of the eduKateSG Workplace Super Intelligence Hub. It follows the Workplace Knowledge Base. That article owns knowledge architecture. This page owns the file-access layer: how SI safely reaches the documents employees actually use.
The Short Answer
A strong file connection uses five rules: preserve source authority, enforce permissions before retrieval, keep file identity and version visible, refresh when documents change, and separate read access from write authority.
The goal is not to make every file available to SI. The goal is to make the right files available to the right task at the right time, with enough provenance that users can verify what the system used.
Uploading a File vs Connecting a File System
Uploading one document is a temporary interaction. Connecting a file system creates an ongoing relationship between SI and a changing source. The second design must handle version changes, deleted files, renamed folders, permissions and new content.
A workplace should treat connected files as maintained infrastructure rather than as static prompt attachments.
The Four Connection Models
1. Manual attachment
A user selects a file and supplies it for one task. This is simple and controllable but requires repeated manual context selection.
2. Synced folder or repository
Approved folders are indexed or connected so SI can retrieve from them repeatedly. This reduces manual work but creates ongoing sync and permission requirements.
3. Federated live access
The system queries the source platform at request time. This can preserve currentness but may increase latency and connector complexity.
4. Hybrid
Stable documents are indexed while time-sensitive fields or files are checked live. Hybrid access often gives the best balance of speed and currentness.
The File Source-of-Truth Rule
The authoritative file should remain in the system designed to own it. An indexed copy, embedding, cache or extracted text is derivative infrastructure.
If the source changes, the SI layer should refresh or invalidate the derivative representation rather than silently preserving an obsolete copy.
File Identity
A file connection needs stable identity. Filenames can change. Folder paths can change. Users can create duplicates. The system should preserve a reliable identifier or source link so retrieved content can be traced back to the actual object.
The Filename Problem
Human file systems often contain names such as final.docx, final2.docx and FINAL-approved.pdf. SI should not infer authority from naming style alone.
Use metadata, version state and source ownership to distinguish current from obsolete material.
The Folder-Path Problem
A folder location may imply context, but moving a file should not erase its identity. Retrieval systems should capture useful hierarchy while keeping the underlying file object traceable.
The Duplicate Problem
The same document can exist in shared drive, email, local folder and project archive. Duplicates reduce retrieval quality because several copies may compete with different dates or edits.
Prefer canonical source links and mark duplicates as derivative, archived or historical where possible.
The File-Version Rule
Users and SI should be able to distinguish draft, current, approved, superseded and archived states. Version metadata is stronger than relying on modified date alone.
The Modified-Date Trap
A file can be modified for formatting without changing policy, or copied later without becoming more authoritative. Modified date is useful evidence but should not be the only authority signal.
The Live-File Rule
For files whose contents change frequently, decide whether the task requires live access. A project status sheet or current contract draft may need fresh retrieval at the moment of use.
The Static-File Rule
Stable documents can be indexed and cached efficiently, provided the system knows when a new version replaces them.
The File Permission Rule
A user should not retrieve a file through SI that they could not legitimately access through the source system. Permission enforcement should happen before or during retrieval, not merely through a prompt instruction.
Inherited Permissions
File systems often use folder-level inheritance. SI connectors should respect the same access model where practical so a user does not gain broader access through search or generated summaries.
Restricted Folders
HR, legal, finance, security and executive folders may require stronger access controls. Do not connect them into a broad general-purpose corpus simply because the files are technically reachable.
Shared-Link Risk
A file shared through a link may have different access from the containing repository. Retrieval systems should follow the source platform’s real permissions rather than assume folder membership defines everything.
The Read vs Write Boundary
Reading a document is different from editing, moving, renaming or deleting it. Most early workplace SI use cases should begin with read-only access.
Write access should be added only when a clear workflow justifies it and recovery is understood.
Prepared Edit vs Automatic Edit
A useful intermediate pattern is for SI to prepare an edit or diff for human approval. This creates leverage without letting the system silently change the source of truth.
The File-Edit Audit Trail
When SI edits a maintained document, record what changed, why, which user or workflow authorised it and how to restore the previous version.
The File-Deletion Boundary
Deletion is a high-impact action. SI can identify files that appear duplicate or obsolete, but destructive action should use explicit confirmation, retention rules and recovery where possible.
The Archive Boundary
Archiving is often safer than deletion because it removes obsolete content from active retrieval while preserving history. The retrieval layer should exclude archived content from ordinary current answers.
The Sync Loop
- Source file created or changed.
- Connector detects change.
- Content and metadata are refreshed.
- Old indexed representation is invalidated.
- Permissions are rechecked.
- Search index updates.
- Regression questions are rerun when material.
- Users receive current results.
The sync loop is what turns a file connection into maintained infrastructure.
Change Detection
Connectors may detect updates through events, scheduled polling or source APIs. The important operational question is not the mechanism itself but how quickly material changes must reach SI.
Sync Latency
If a policy changes at noon but the SI index updates overnight, the knowledge system may be unsafe for same-day operational use. Match sync cadence to the source’s change rate and consequence.
Sync Failure
A connector can fail silently. Monitor sync age and surface when the index is stale. Users should know when the system’s file view may lag the source.
Partial Sync
Large repositories may sync incrementally. Retrieval should avoid presenting an incomplete corpus as complete during migration or failure.
The Extraction Layer
Documents often need text, tables, headings and metadata extracted before retrieval. Preserve enough structure that the model can understand section relationships, page references and qualifiers.
PDFs
PDFs can contain text, tables, images and complex layouts. Extraction should preserve page or section references where possible so citations remain useful.
Word Processing Files
Headings, comments, tracked changes and document properties can contain important state. Decide whether the workflow should use final text only or also review comments and revisions.
Spreadsheets
Spreadsheets contain formulas, tables, hidden sheets and structured values. A file connector should not flatten everything into prose if exact cell state matters.
Use spreadsheet-aware tools or data interfaces for exact analysis where possible.
Presentations
Slides contain headings, diagrams, speaker notes and visual relationships. Decide whether the task requires only slide text or the complete presentation context.
Plain Text and Markdown
These formats are usually easier to index because structure is explicit. Stable heading conventions improve retrieval.
Images and Scans
Scanned material may require text extraction or manual review. Do not assume every image-derived character is reliable enough for high-consequence use.
Email Attachments
Attachments may be duplicates, drafts or temporary files. If they contain durable knowledge, move or link them into the maintained source rather than letting email become the only archive.
Code Files
Code repositories have their own versioning, branch and permission model. SI should use repository-aware context rather than treating source code as ordinary documents.
File Metadata Matters
- Stable source ID
- Filename
- Title
- Owner
- Created date
- Modified date
- Version state
- Folder or project
- Audience
- Confidentiality
- Source type
- Effective date
- Review date
- Tags
- Superseded-by link
The Chunking Rule for Files
Break large files at meaningful boundaries such as headings, clauses, sections or table regions. Arbitrary chunks can separate a rule from its exception or a table header from its values.
The Citation Rule for Files
Answers should link back to the source file and, where possible, the relevant section or page. Users should be able to inspect the original context quickly.
The Provenance Rule
Every extracted or indexed passage should retain provenance: source file, version, location and access path. Derived text without provenance is difficult to trust or repair.
The Cache Rule
Caching can improve speed, but cached content needs invalidation when the source changes. High-consequence workflows should know the age of the cached representation.
The Local-Copy Trap
Employees may keep local copies of shared files that drift from the canonical version. SI should prefer the maintained shared source unless the user explicitly asks about the local copy.
The Download Trap
Downloading a file for processing can create new data-retention and version risks. Prefer managed connectors or approved environments when sensitive content is involved.
The Email-Copy Trap
The same attachment may circulate through many email threads. Retrieval should avoid treating every circulated copy as a separate authoritative source.
The File-Name Search Trap
Users may know content but not filename. Semantic search helps locate documents by meaning, while exact title and identifier search remain useful for known items.
The Hidden-File Trap
Some relevant content may be inaccessible because it lives in personal folders or private drives. The organisation should decide whether the knowledge belongs in a shared source rather than asking SI to bypass ownership boundaries.
The Orphaned-File Problem
Files created by departed employees can become ownerless. Reassign ownership or archive them so the system does not preserve unmaintained knowledge indefinitely.
The Shared-Drive Problem
Shared drives often mix active work, archive, templates and obsolete material. Structure and metadata should make those states visible before SI indexing.
The Personal-Drive Problem
Personal drives are useful for work-in-progress but weak as enterprise knowledge sources. Promote durable content into maintained shared locations when appropriate.
The Project-Folder Pattern
Project folders can be excellent SI context because scope is bounded. Include project brief, decisions, current artefacts and key sources while excluding irrelevant history.
The Client-Folder Pattern
Client folders may contain sensitive commercial or personal information. Access should match team membership and engagement need.
The Department-Folder Pattern
Department folders need stronger metadata because many workflows and source types coexist. SI retrieval should filter by workflow, status and authority.
The File-Access Request Workflow
When SI needs a file the user cannot access, the system should not work around the restriction. It can explain which source is required and route the user through the normal access process.
The Missing-File Workflow
If the expected file is missing, preserve that absence. Do not infer contents from previous versions unless the user explicitly asks for historical context.
The Conflicting-File Workflow
If two files claim to be current, surface the conflict or follow a defined authority hierarchy. Do not silently select the one with the newer timestamp.
The File-Rename Workflow
Renaming should not break provenance or retrieval links. Stable object IDs are preferable to path-only identity.
The File-Move Workflow
Folder moves can change inherited permissions or context. Connectors should refresh both metadata and access state after movement.
The File-Restore Workflow
When a file is restored from archive or previous version, update its active status deliberately. Historical content should not re-enter retrieval accidentally.
The File Connector Readiness Test
- Authoritative folders identified
- Owners known
- Permissions clean
- Obsolete content separated
- Version states visible
- Sync method defined
- Sync latency acceptable
- Provenance preserved
- Deletion and archive behaviour understood
- Fallback source access available
The Read-Only Pilot
A strong first file-connectivity pilot uses read-only access to one bounded repository. Test known questions, citation, permissions, version changes and sync latency.
Do not begin with broad write access.
The Write Pilot
If write access later creates value, start with prepared edits, comments or draft files rather than direct destructive changes to canonical documents.
The File Connection Metrics
- Time to useful file
- Retrieval success rate
- Permission error rate
- Stale-result rate
- Sync age
- Citation accuracy
- Duplicate-result rate
- Version-conflict rate
- Writeback failure rate
- User clarification rate
The File Connector Incident
Material failures include restricted-file leakage, stale content driving action, wrong-version edits or accidental deletion. Preserve logs, source state, user identity and connector version for repair.
The File Connection Recovery Rule
Users should still be able to access the source repository directly if SI is unavailable. The connector is an interface, not the sole route to organisational files.
The File Connection Human-Agency Rule
Users should see which files were used, be able to open them, correct wrong source selection and reject proposed edits.
The File Connection Standard
Stable identity + source authority + permissions + version state + sync + provenance + read/write separation is the core grammar of a workplace SI file connection.
When these conditions are present, Super Intelligence can work with documents as part of the operating system rather than treating every file as a temporary prompt attachment.
What This Article Owns
This page owns the documents-and-files connectivity layer: connectors, file identity, permissions, sync, extraction, provenance, versioning and writeback boundaries.
The next article owns enterprise search itself—how users find and navigate organisational knowledge once these sources are connected.
Frequently Asked Questions
Should SI connect to every workplace file?
No. Connect only the repositories and files needed for the use cases, with appropriate ownership and permissions.
Is uploading a file the same as connecting a drive?
No. A persistent connection must handle source changes, permissions, versioning and sync.
Should SI have write access?
Start read-only. Add prepared edits or bounded write actions only when they remove a real bottleneck and recovery is clear.
How do we avoid stale file answers?
Use sync monitoring, version state, currentness rules and live checks for time-sensitive content.
How should permissions work?
Retrieval should respect the source platform’s real user or role permissions before content reaches the model.
What if the same document exists in several places?
Identify the canonical source and mark other copies as derivative, archived or historical where possible.
Can SI edit documents safely?
It can prepare or make bounded edits when permissions, versioning, audit and rollback are appropriate. High-impact source changes should remain human-controlled.
What comes next?
Continue to How Super Intelligence Changes Enterprise Search, which explains how connected files and knowledge sources become a new search and answer experience across the workplace.
The Core File Rule
Connect Super Intelligence to files without disconnecting users from the source of truth. The file should remain identifiable, current, permission-aware and inspectable even when SI makes access much easier.
Repository Pattern: Shared Drive
Shared drives are common starting points because they already contain policies, templates and team documents. Their weakness is often governance: broad folders, duplicate files, unclear ownership and old copies.
Begin with selected high-value folders. Capture folder context, file ID, owner, version and permissions. Exclude abandoned or draft-heavy areas until governance improves.
Repository Pattern: Document Management System
Document-management systems usually provide stronger versioning, metadata and approval states. These are valuable signals for SI because current published sources can be distinguished from drafts.
Preserve those states in the connector rather than flattening every file into one corpus.
Repository Pattern: Intranet or Wiki
Intranets and wikis can be excellent knowledge sources when page ownership and currentness are maintained. Watch for copied policy text and pages that summarise another source without clearly linking authority.
Repository Pattern: Project Workspace
Project workspaces mix planning, notes, decisions, drafts and final deliverables. SI should distinguish working material from approved project state and preserve project membership permissions.
Repository Pattern: Code Repository
A code repository needs branch, commit and path awareness. Architectural documentation may apply broadly while implementation details depend on version. Retrieval should know which code state the user is working with.
Repository Pattern: Ticketing System
Tickets contain current state, history, comments and attachments. They are useful for case context but usually should not be treated as general policy. Separate live-case retrieval from durable knowledge.
Repository Pattern: CRM
CRM holds customer state, interactions and commitments. SI should retrieve only the authorised account context required for the task. General product knowledge belongs in the knowledge base, not copied into each customer record.
Repository Pattern: Email
Email is rich in context but weak in governance. Use it for case-specific history and commitments when authorised, but promote recurring durable knowledge into maintained sources.
Repository Pattern: Chat
Chat can reveal recent decisions and informal context. It is highly dynamic and often ambiguous. Use it carefully for current coordination and avoid treating every chat message as canonical knowledge.
Repository Pattern: Data Warehouse
Warehouses and databases hold structured state. Do not turn tables into text unnecessarily. Query structured data directly and let SI interpret or explain the results.
Repository Pattern: Local Desktop
Local files can support personal work but are difficult to govern and share. If a file repeatedly matters to team workflows, move the maintained source into an approved repository.
Repository Pattern: External Vendor Portal
Vendor portals may contain manuals, contracts or updates. External content should retain provenance and should not silently outrank internal policy.
Repository Pattern: Regulatory Source
Official external regulations or standards may need to be connected or referenced. Jurisdiction, effective date and source authority are critical. Internal procedures should remain distinguishable from the external rule.
The File Connection Scope
Define which repositories and folders are connected for which workflows. “Connect the company drive” is too broad. “Connect published Customer Operations policy and runbook folders for support staff” is operational.
The File Connection Owner
Name who can change the connection scope, approve new repositories and resolve source conflicts. Technical ability to connect should not determine organisational authority.
The File Connection Risk Class
Low-risk public or internal reference material can use simpler controls than legal, HR, security or executive repositories. Connection design should follow content sensitivity and downstream action.
The File Connection Data Flow
Draw where file content goes: source repository → connector → extraction service → index → retrieval → model context. Identify where data is copied, cached and logged.
This makes privacy and deletion responsibilities visible.
The File Connection Cache
Caching can improve speed but create stale content and permission risk. Define cache lifetime and invalidation behaviour for sensitive or fast-changing sources.
The File Connection Encryption
Use the organisation’s approved security controls for data in transit and at rest. File connectivity should not introduce a weaker security path than direct repository access.
The File Connection Secrets Rule
Credentials, API keys and secrets should not be embedded inside documents that enter broad retrieval. Use secret-management systems and minimise exposure.
The File Connection Redaction Rule
If a workflow only needs part of a sensitive document, consider redacted or role-specific views rather than exposing the full file.
The File Connection Audit Log
For sensitive repositories, record connection events, retrieval access or administrative changes at a level proportionate to risk.
The purpose is accountability and incident diagnosis, not unlimited surveillance.
The File Connection Access Test
Test with users from different roles. Confirm that each receives only files they can access in the source system, including nested and file-specific permissions.
The File Connection Revocation Test
Remove a user’s source access and verify the SI layer stops returning the file promptly. This test catches stale permission caches.
The File Connection Delete Test
Delete or retire a test document and verify it disappears from current retrieval while any required audit archive remains appropriately separated.
The File Connection Move Test
Move a document to another folder and confirm stable identity, path metadata and access update correctly.
The File Connection Rename Test
Rename a source and confirm citations or stable identifiers still resolve. File names should not be the only key.
The File Connection Version Test
Publish a new version and verify the current answer cites the new source while historical questions can still retrieve the old one when appropriate.
The File Connection Draft Test
Create a newer draft beside the current published file. Confirm the system does not treat recency as authority.
The File Connection Duplicate Test
Copy a file into another folder and check whether the system recognises duplication or at least avoids presenting duplicated content as independent evidence.
The File Connection Extraction Test
Use files with tables, columns, footnotes, page headers and unusual formatting. Verify that important meaning survives extraction.
The File Connection Spreadsheet Test
Check formulas, merged cells, hidden sheets, tables and named ranges where relevant. An SI answer based on a rendered value should not pretend it evaluated the spreadsheet logic unless it actually did.
The File Connection Presentation Test
Check whether speaker notes, slide numbers and diagrams matter to the workflow. Preserve references so users can inspect the slide.
The File Connection PDF Test
Check scanned and text-native PDFs separately. For table-heavy or form-like PDFs, evaluate extraction accuracy before using the content in high-consequence workflows.
The File Connection Image Test
If diagrams or screenshots carry essential information, ensure the system can access and interpret them or route the user to the original source.
The File Connection Code Test
Ask version-specific questions and verify the system uses the correct branch or commit. Code retrieval without version can produce answers that are technically accurate for the wrong state.
The File Connection Language Test
Multilingual repositories may contain parallel or partially translated documents. Preserve language and source version so the system does not combine inconsistent translations.
The File Connection Large-File Test
Very large documents may need hierarchical retrieval: first find the relevant section, then retrieve the precise chunk. Dumping the entire file into context is inefficient and noisy.
The File Connection Many-Small-Files Test
Repositories with thousands of small notes can create retrieval noise. Use metadata, ownership and canonicality to distinguish durable knowledge from fragments.
The File Connection Hierarchical Retrieval Pattern
- Identify likely source domain.
- Filter authorised repositories.
- Find candidate file.
- Check version and canonical status.
- Locate relevant section.
- Retrieve small evidence set.
- Generate answer or task support.
- Return source link and location.
Hierarchical retrieval often improves precision when repositories are large.
The File Connection Multi-Source Pattern
Some tasks need several files: policy plus SOP plus current project document. Context assembly should label each source and avoid hiding disagreements.
The File Connection Comparison Pattern
When comparing files, retrieve the relevant versions deliberately. The system should know whether the user wants current vs current, current vs previous, or two different proposals.
The File Connection Summarisation Pattern
Summaries should preserve source identity and material qualifiers. A summary is a navigation layer, not a replacement for the file in high-consequence work.
The File Connection Extraction Pattern
For structured extraction, define schema and required fields. Preserve missing values rather than guessing. Link each field back to the source location where practical.
The File Connection Question-Answer Pattern
For factual Q&A, retrieve canonical current files and cite them. If the answer depends on live state outside the files, retrieve the system of record too.
The File Connection Drafting Pattern
For writing, use source files as evidence and constraints. Separate factual grounding from style examples so the model does not treat example wording as current fact.
The File Connection Agent Pattern
For agents, retrieve the relevant procedure and file state before tool use. File access alone does not grant action authority.
The File Connection Review Pattern
Reviewers should be able to open the exact source from the generated output. This shortens verification and exposes retrieval mistakes.
The File Connection Known-Gap Pattern
When required files do not exist or are inaccessible, the system should surface the gap. This is safer than filling the answer from generic knowledge.
The File Connection Known-Conflict Pattern
If two current-looking sources disagree, expose the conflict and route it to the owner. Do not synthesise a compromise unless the organisation has defined precedence.
The File Connection Currentness Pattern
When files represent rapidly changing state, show modified time and consider refresh before consequential action.
The File Connection Citation UX
Citations should be useful to humans: file title, relevant section or page, repository and link. A cryptic internal chunk ID is poor verification UX.
The File Connection Source Preview
Where appropriate, show the relevant passage beside the generated answer so the user can verify without opening another system. Preserve access controls.
The File Connection Search Result
Search results should show canonical status, owner, version and scope when those distinctions matter. This helps users choose the right source even before generation.
The File Connection Admin Health View
- Connector status
- Last successful sync
- Files indexed
- Files failed extraction
- Permissions sync status
- Deleted files pending removal
- Duplicate candidates
- Stale sources
- Unowned sources
- Recent canonical changes
Operational visibility prevents silent degradation.
The File Connection Monitoring Alerts
Alert technical owners when sync fails, permission mapping breaks, extraction errors spike or high-risk canonical sources become unavailable.
Do not alert on every ordinary file update.
The File Connection Incident Response
If restricted content is exposed or stale files affect decisions, stop affected retrieval, preserve evidence, repair the connector or permissions and identify dependent workflows.
The File Connection Change Control
Material connector, extraction or indexing changes should trigger representative tests. The same documents processed with a new parser can produce different chunks.
The File Connection Dependency Map
Document which connectors, repositories, identity systems and indexes support each critical workflow. Shared dependencies can create systemic failure radius.
The File Connection Continuity Plan
Critical users should know how to open authoritative repositories directly if the SI search layer is unavailable. AI access should be an accelerator, not the only path to workplace knowledge.
The File Connection Cost Model
Costs include connector licensing, indexing, storage, model context, maintenance and review. Avoid indexing low-value repositories simply because storage is cheap.
The File Connection Latency Model
Users care about query speed, but currentness can matter more. A slightly slower query to live authoritative state can be better than a fast answer from stale cached content.
The File Connection Build Sequence
- Choose one repository and workflow.
- Identify canonical folders or sources.
- Map permissions and versions.
- Connect in read-only mode.
- Extract and index representative files.
- Build evaluation cases.
- Test permissions, version and deletion.
- Launch to a small user group.
- Measure source retrieval and correction.
- Expand repositories gradually.
The First Repository Choice
Choose a repository with useful governed knowledge and manageable permissions. A well-maintained policy or documentation area is a better starting point than an entire chaotic shared drive.
The File Connection Pilot Metrics
- Correct-file retrieval rate
- Correct-version rate
- Permission failures
- Sync freshness
- Extraction failure rate
- Citation fidelity
- Time to authoritative source
- Known-gap rate
- User verification time
- Stale-file incidents
What Success Looks Like
Users find the correct current file faster, can inspect the source, receive fewer stale answers and no longer need to copy the same documents into separate assistants manually.
The file system remains authoritative; Super Intelligence becomes a governed interface to it.
The Connector Is a Trust Boundary
A connector is not merely plumbing. It decides which source systems the SI layer can reach, under whose identity, with which permissions, at what freshness and with what ability to change state. That makes the connector part of the organisation’s trust architecture.
The same model connected to a public knowledge folder and to a confidential legal repository is not the same operational system. Access scope changes the failure radius.
Connector Identity Models
User-delegated identity
The system acts with the permissions of the current user. This is often the cleanest model for search because source permissions remain aligned with the person asking the question.
Service identity
A shared service account can simplify integration but may have broader access than any individual user. Strong filtering and logging become essential.
Role identity
The workflow may use a service role associated with a function such as Support or Finance. Role identity can support automation when individual user context is unnecessary.
Agent identity
An agent may have its own identity and scoped credentials. This makes actions attributable to the automated system rather than silently borrowing a human account.
The Identity Selection Rule
Use the identity model that best matches the workflow’s responsibility. Search for one employee often fits delegated identity. Background monitoring may fit a service or agent identity. High-impact actions should be especially clear about who or what caused them.
Read Scopes
A connector should expose the smallest set of folders, repositories or file classes required for the workflow. Broad read access increases both privacy risk and retrieval noise.
If a support use case needs product manuals and customer-safe policy, it does not need access to executive strategy files.
Write Scopes
Write access should be narrower than read access. A system may need to read many sources but edit only one generated report folder.
Separate create, edit, move, rename, share and delete permissions where the platform allows it.
The Comment-Only Pattern
For collaborative documents, SI can add comments or suggestions rather than editing final text directly. This creates a visible review layer and preserves the source until a person accepts the change.
The Draft-File Pattern
Another safe pattern is for SI to create a new draft file in a designated workspace. Humans review and promote the draft to the canonical location if accepted.
The Patch Pattern
For structured text or code, SI can prepare a patch or diff rather than replacing the full document. Reviewers see exactly what changed.
The Controlled-Template Pattern
SI can populate a pre-approved template while leaving structure and required fields fixed. This is useful for reports, briefs, handoff packets and standard documentation.
The File-Create Boundary
Creating a new file is lower risk than overwriting an existing authoritative file, but it can still create clutter or accidental parallel truth. New-file destinations should be governed.
The File-Overwrite Boundary
Overwriting should require stronger validation, versioning and rollback. For canonical documents, prefer reviewable changes and source-system version history.
The File-Move Boundary
Moving a file can change who can find or access it. A move should be treated as a state change, not a cosmetic action.
The File-Share Boundary
Changing sharing permissions can expose data externally or across departments. SI should not broaden sharing automatically unless the workflow explicitly governs that action.
The File-Rename Boundary
Renaming can affect human navigation and downstream references. Keep stable IDs and avoid workflows that infer identity solely from filenames.
The File-Delete Boundary
Deletion should be especially conservative. Prefer archive, soft-delete or review queues when the system identifies obsolete or duplicate material.
Connector Permission Drift
Permissions can expand over time as users move teams, groups change or service accounts accumulate access. Periodic review should compare the workflow’s required access with its actual access.
Connector Credential Rotation
Long-lived service credentials need rotation and revocation procedures. A workplace SI system should not depend on forgotten tokens owned by departed employees.
Connector Outage Handling
When a source system is unavailable, the workflow should know whether to use cached content, wait, switch to another approved source or stop. High-consequence work should not silently fall back to stale data.
Connector Health Metrics
- Last successful sync
- Last successful live read
- Permission errors
- Rate-limit errors
- Stale-index age
- Write failures
- Uncertain action states
- Average retrieval latency
- Connector availability
- Authentication failures
File Ingestion vs File Federation
Ingestion copies or extracts content into a separate index. Federation queries the source in place. Ingestion is fast for retrieval but introduces sync and copy lifecycle. Federation preserves current source state but can be slower and more dependent on source availability.
Many organisations use both: index stable content and query live systems for volatile state.
The Copy Lifecycle
If content is copied into an index, define creation, refresh, invalidation and deletion behaviour. A deleted source should not remain indefinitely accessible through a forgotten index.
The Tombstone Pattern
When a source is deleted or retired, mark the indexed copy as unavailable or historical rather than treating it as current. Tombstone metadata helps prevent ghost content from resurfacing.
The Sync-Conflict Pattern
If a local edited copy and source file diverge, the system should not merge automatically without a rule. Preserve both states and route the conflict to the appropriate owner.
The Rename-and-Move Sync Pattern
Connectors should treat rename and move as metadata changes around the same file when the source platform preserves identity. Otherwise duplicate indexing can occur.
The Permission-Change Sync Pattern
Access changes should propagate quickly enough that users do not continue retrieving content after permissions are revoked.
The File-Type Adapter Layer
Different file formats require different extraction strategies. A connector architecture should identify whether it is reading text, tables, slide notes, comments, metadata, formulas or embedded objects.
Flattening every format into plain text can destroy the structure required for correct interpretation.
Table Extraction
Tables need headers, row relationships and units. Extracting only cell text can detach values from meaning. For analytical tasks, preserve structure or connect directly to the underlying data representation.
Comment Extraction
Comments and annotations may contain draft discussion rather than accepted content. Decide whether they should enter retrieval and how their authority differs from the main document.
Tracked Changes
Tracked changes can reveal proposed edits but should not be confused with final approved text. A document workflow may need both current accepted content and pending changes as separate states.
Speaker Notes
Presentation speaker notes can contain context absent from slides. Include them only when the task benefits and confidentiality permits.
Hidden Spreadsheet Content
Hidden sheets, columns or formulas may contain sensitive or operational logic. File connectors should not expose them automatically without understanding the user’s source permissions and task need.
Embedded Objects
Files can contain embedded spreadsheets, images or attachments. Decide whether the connector follows embedded content and how provenance is preserved.
Macros and Active Content
Documents can contain macros or active elements. SI file processing should treat them cautiously and avoid executing untrusted code merely to inspect content.
Image-Heavy Documents
Visual documents may require multimodal interpretation. Important diagrams, charts and scanned signatures should not be reduced to text if the visual relationship matters.
Scanned Contracts
Scanned contracts can introduce extraction errors. High-impact clause review should preserve page images or direct source access so humans can verify critical text.
Document Layout as Meaning
Footnotes, tables, columns and section placement can change interpretation. Extraction quality should be tested on the actual document class rather than assumed from simple text files.
The File Classification Layer
Files can be classified by type, authority, project, confidentiality and lifecycle state. Classification improves retrieval and helps enforce different processing rules.
Automatic Classification
SI can suggest tags, but high-impact categories such as restricted or privileged may require deterministic rules or human confirmation.
Manual Classification
Users should be able to correct file class and metadata. Those corrections can improve future automation.
The File Lifecycle
- Create
- Draft
- Review
- Approve
- Publish
- Use
- Revise
- Supersede
- Archive
- Delete or retain
SI connections should respect this lifecycle. Draft material should not automatically compete with approved material in ordinary retrieval.
The File State Machine
For critical document workflows, encode states such as Draft, Review, Approved, Superseded and Archived. State is more reliable than guessing from location or filename.
The File Ownership Rule
Every important file or document class should have an owner. Ownership supports review, permission decisions and conflict resolution.
The File Review-Date Rule
Long-lived documents should have review dates or event triggers. SI search makes stale documents easier to find, which increases the importance of lifecycle governance.
The File Retention Rule
Retention may be governed by legal, operational or organisational requirements. AI indexing should not create hidden copies that outlive the source’s approved retention period.
The File Disposal Rule
When data is scheduled for deletion, derived indexes and caches should also be handled according to the organisation’s policy.
The File Sensitivity Classes
- Public
- Internal
- Confidential
- Restricted
- Privileged
- Highly sensitive
The exact taxonomy varies by organisation, but the SI layer should understand and enforce whichever scheme is used.
The File Redaction Pattern
When a workflow needs partial content, redaction can allow useful access without exposing unnecessary fields. The redaction process should be reliable and consistent with the source’s access policy.
The File-Minimisation Pattern
Instead of sending an entire file to the model, retrieve only the relevant sections where possible. This reduces exposure, cost and distraction.
The File-Preview Pattern
For uncertain retrieval, show a short preview and source metadata before loading larger content. This lets users steer context selection.
The File-Citation Pattern
Citations should use stable file links and, where possible, page, heading or section anchors. Users should be able to inspect the original without navigating blindly.
The File-Provenance Card
- Source repository
- File ID
- Filename
- Owner
- Version
- Status
- Last modified
- Retrieved at
- Permission context
- Section or page
A provenance card is especially helpful when generated answers combine several files.
The File Comparison Workflow
SI can compare two versions, highlight changes and classify them by materiality. Humans should verify consequential differences and decide which version becomes current.
The File Merge Workflow
When two documents need consolidation, SI can prepare a merged draft and list conflicts. The merge should not silently erase divergent instructions.
The File Template Workflow
SI can generate documents from approved templates using structured inputs. The template should preserve mandatory sections and fields while the system fills variable content.
The File Review Workflow
Reviewers benefit from a change summary, evidence links, unresolved issues and a diff rather than receiving an entirely regenerated document with no trace of changes.
The File Approval Workflow
Approval should be an explicit source-system state. The SI layer can prepare the document, but the approval event should come from the authorised person or workflow.
The File Publication Workflow
Publishing a document can change who relies on it. Before publication, validate status, owner, metadata, audience and any dependent knowledge or workflows.
The File Supersession Workflow
When a new file replaces an old one, link them. The old file can remain historical while retrieval prefers the new version for current queries.
The File Rollback Workflow
If an SI edit or automation produces a bad change, restore the prior version and investigate how the change passed review. Version history should make recovery fast.
The File Change-Notification Pattern
Important source changes may need to notify affected users or trigger downstream review. SI can identify which procedures, templates or teams depend on the file.
The File Dependency Graph
Documents often depend on one another. A policy may govern several SOPs; a specification may affect support and sales material. Mapping dependencies helps manage blast radius after changes.
The File Search Layer
Users should be able to search by title, keyword, metadata and semantic meaning. The connector should expose enough structured metadata for search to discriminate current, relevant sources.
The File Browse Layer
Search is not always enough. Users may want to browse project, department or process collections. Preserve useful navigation rather than replacing every interface with a chat box.
The File Answer Layer
Generated answers should identify which files were used. A response synthesised from several sources should make that evidence visible.
The File Action Layer
Once SI can create or edit files, the system enters a different risk class. Actions need scoped permissions, audit, rollback and owner accountability.
The File Connector Test Suite
- Known-file lookup
- Semantic-file lookup
- Permission-denied file
- Recently updated file
- Recently deleted file
- Moved file
- Renamed file
- Duplicate file
- Superseded file
- Restricted file
- Large file
- Complex table
- Failed sync
- Write failure
- Rollback case
The File Connector Launch Sequence
- Choose one bounded repository.
- Clean obvious duplicates and obsolete material.
- Confirm permissions.
- Define sync method.
- Index and preserve provenance.
- Test known lookups and semantic queries.
- Test revoked access.
- Test updates and deletion.
- Launch read-only.
- Collect retrieval failures.
- Add bounded write only after evidence.
The File Connector Scale Sequence
Expand one repository class at a time. Adding HR, legal, finance and general project files simultaneously makes permission and authority failures difficult to diagnose.
The File Connector Ownership Triangle
- Repository owner: owns source platform and access.
- Knowledge owner: owns authority and currentness of content.
- SI workflow owner: owns how the connected files are used.
The same person may hold several roles in a small organisation, but the responsibilities should remain explicit.
The File Connector Cost Model
Costs include connector licensing, indexing, storage, extraction, model use, monitoring and human review. Compare those costs with reduced search, fewer uploads, faster preparation and lower duplication.
The File Connector Time-to-Value
Read-only access to one clean repository can create value quickly. Broad enterprise connection usually takes longer because permissions, metadata and source cleanup dominate the work.
The File Connector Governance Rule
Do not let technical connectivity determine governance. A connector being available does not mean every repository should be exposed to every SI workflow.
The File Connector Human-Agency Rule
Users should see source files, understand access failures, correct wrong selections and remain able to work directly in the source system.
The File Connector Independence Rule
The organisation should be able to change SI providers without losing the meaning of file ownership, authority and permissions. Keep those rules at the organisational layer.
The File Connector Final Standard
Right source, right identity, right permission, right version, right freshness, visible provenance and bounded write authority define a workplace file connection that is ready for Super Intelligence.
When those conditions hold, SI can make documents easier to find and use without turning the connector into an invisible second document system.
Repository Pattern: Shared Drive
A shared drive is a common first source because teams already use it. Before connecting SI, separate active work, templates, archives and obsolete copies. Broad mixed folders make retrieval harder and increase the chance that stale documents compete with current ones.
The first connector scope should usually be smaller than the whole drive. Choose the folders that map directly to the target workflow.
Repository Pattern: Document Management System
Formal document-management systems often provide stronger metadata, versioning and approvals. SI should preserve those states rather than flattening every document into one undifferentiated corpus.
Repository Pattern: Wiki
Wikis are good for structured internal knowledge but can contain draft pages, personal notes and stale sections. Use status, ownership and review metadata to distinguish maintained knowledge from casual content.
Repository Pattern: Project Workspace
Project workspaces can provide highly relevant bounded context. The system should still distinguish final decisions, working drafts and historical artefacts.
Repository Pattern: CRM Attachments
Customer records often contain uploaded proposals, contracts and communications. SI can use them for context, but customer permissions, account ownership and current commercial state should come from the CRM rather than from an attachment alone.
Repository Pattern: HR Document Store
HR repositories contain sensitive personal information and employment documents. General-purpose workplace SI should not connect broadly unless the use case, access model and legal requirements justify it.
Repository Pattern: Legal Matter Files
Legal matter files may contain privileged or confidential content. Retrieval should preserve matter boundaries, client access rules and professional controls.
Repository Pattern: Finance Repository
Finance folders contain reports, reconciliations and supporting evidence. Exact financial state should remain in financial systems where possible, while document retrieval supports explanation and review.
Repository Pattern: Code Repository
Code repositories should use repository-native access with branches, commit history, tests and permissions. Treating code as generic files loses essential structure.
Repository Pattern: Knowledge Base Platform
A dedicated knowledge platform may already expose structured metadata, links and permissions. SI should integrate with those strengths rather than copying content into a parallel unmanaged store.
The Repository Scope Test
- Does this repository contain sources the workflow actually needs?
- Can authoritative and obsolete material be distinguished?
- Are owners known?
- Are permissions clean?
- Is the sync method reliable?
- Can users still inspect the source directly?
- Can historical content be separated from current retrieval?
The File Connector Security Model
Security begins with source permissions, but the SI path adds new components: connector, index, cache, model context, logs and generated output. Sensitive content can leak at any layer if access is broader than intended.
Review the entire path, not only the source repository.
Index Security
An index may contain extracted text from restricted files. Protect index access as carefully as the source itself and ensure deletion or permission revocation propagates.
Cache Security
Caches should not retain restricted or deleted content indefinitely. Use retention and invalidation rules appropriate to the source class.
Log Security
Logs can accidentally capture filenames, paths, snippets or sensitive query content. Log enough for diagnosis without creating a new uncontrolled copy of the data.
Generated-Answer Leakage
A user may receive restricted facts through a generated answer even if the original file link is hidden. Permission filtering must happen before content reaches generation.
Cross-User Leakage
Shared memory or caches should not allow one user’s retrieved content to appear in another user’s session unless the underlying permissions allow it.
Connector Prompt Injection
Documents can contain instructions written by external or malicious authors. A tool-using SI system should treat file content as data, not as trusted operating instructions.
The risk rises when the system can read a file and then act on email, databases or other tools in the same workflow.
Malicious File Content
Office documents, PDFs and archives can contain active or malformed content. Processing pipelines should follow safe handling practices and avoid executing embedded code merely to extract text.
File-Upload Controls
If users can upload files into an SI workspace, define size, type, sensitivity and malware-handling rules. An upload surface can become an unexpected data-ingestion channel.
External File Sharing
If an SI workflow creates or shares files externally, verify the recipient, permission mode, expiry and whether the content is appropriate for release.
The Writeback Safety Model
Writeback should use preconditions. Before changing a source file, confirm expected version, owner, destination and whether the document changed since the SI prepared the edit.
This reduces overwriting another person’s more recent work.
Optimistic Concurrency
A workflow can compare the current source version with the version used to prepare the edit. If they differ, stop and request review rather than silently applying a stale patch.
Writeback Approval
For important documents, SI should prepare the edit, show the diff and wait for an authorised approval before committing.
Writeback Rollback
Every important automated edit should have a straightforward restoration path through version history, backup or a recorded prior state.
Writeback Attribution
The document history should make it clear that an automated workflow performed the edit and under whose authority it operated.
Writeback to Draft vs Published State
Where the source system supports workflow states, SI edits should often enter Draft or Review rather than Published automatically.
Document Generation at Scale
When SI generates many files, define naming, destination, ownership, retention and duplication rules. Automated document generation can create clutter just as easily as productivity.
The Generated-File Registry
For recurring automated reports or briefs, maintain predictable paths and version behaviour. Users should know which copy is current without searching through dozens of generated files.
The File Connection and Knowledge Base
The Workplace Knowledge Base defines authority and lifecycle. The connector enforces access and freshness to those sources.
A strong knowledge base with a weak connector becomes stale; a strong connector with a weak knowledge base retrieves ambiguity faster.
The File Connection and Context Engineering
Context engineering decides which connected files or passages belong in a task. Do not load entire repositories simply because the connector can reach them.
The File Connection and Enterprise Search
Enterprise search becomes more powerful when connectors expose consistent metadata, permissions and provenance. Article 35 will focus on the search experience itself.
The File Connection and Agents
Agents that can read and write files need explicit objective boundaries, file scopes and stopping conditions. A general agent should not inherit broad document permissions simply because one task requires a particular folder.
The File Connection and Human Handoffs
Connected files can enrich handoff packets with direct source links. This is better than copying long excerpts into messages that become stale after the file changes.
The File Connection and Meetings
Meeting preparation can pull current documents from the project workspace. Post-meeting actions can update draft artefacts or create new files after confirmation.
The File Connection and Email
Email workflows can reference current files instead of attaching duplicate copies. This reduces version confusion and keeps the source authoritative.
The File Connection and Research
Research workflows can use bounded project libraries and preserve provenance. External research sources should remain distinguishable from internal organisational knowledge.
The File Connection and Professional Writing
Writing workflows can retrieve approved facts, examples and source documents, then save drafts into controlled locations with review states.
The File Connector Migration Plan
- Inventory repositories.
- Choose high-value source folders.
- Clean obvious obsolete material.
- Confirm owners.
- Map permissions.
- Define identity model.
- Choose live, indexed or hybrid access.
- Test extraction and provenance.
- Test sync and revocation.
- Launch read-only.
- Measure retrieval quality.
- Add bounded write only where needed.
The Migration Freeze Rule
During a major repository migration, avoid making the SI layer appear more current than the underlying move. Clearly indicate when the corpus is partial or transitioning.
The Migration Reconciliation Rule
After migration, compare source counts, permissions, canonical links and regression queries. Missing files or duplicated paths can create subtle retrieval changes.
The Connector Change-Control Rule
Changes to connector configuration, index logic, permissions or file parsing can materially alter answers. Important workflows should have a change ledger and regression tests.
The Connector Vendor Rule
If a provider changes connector behaviour, scopes or retention, reassess the workflow. Keep source authority and access rules documented outside the vendor-specific configuration.
The Connector Scale Test
As more repositories are added, test latency, search precision, permission filtering and duplicate handling. Scale can reduce quality even when each individual connector works correctly.
The Connector Peak-Load Test
Large sync events, many simultaneous queries or bulk document updates can create lag. Monitor whether currentness guarantees still hold under peak load.
The Connector Permission-Revocation Test
Remove a user’s source permission and verify that SI access disappears promptly, including through cached or generated surfaces.
The Connector Delete Test
Delete or archive a source file and verify that ordinary retrieval no longer returns it as current. Historical access should follow explicit archival rules.
The Connector Version Test
Publish a new approved version and confirm that the old version no longer outranks it. The answer should link to the new source.
The Connector Write Test
Use a controlled draft file to test create, edit, conflict and rollback behaviour before allowing writes to important sources.
The Connector Audit
- Sources still needed
- Permissions no broader than necessary
- Sync healthy
- Stale-index alerts working
- Archived files excluded from current search
- Provenance intact
- Write access justified
- Logs appropriately scoped
- Fallback source access available
- Incident contacts known
The Connector Incident Playbook
- Stop or limit the affected connector.
- Preserve relevant logs and source state.
- Identify users and workflows affected.
- Restore permissions or source version.
- Invalidate stale or leaked derived content.
- Retest access and retrieval.
- Document the root cause.
- Update controls before re-enabling.
The Connector Recovery Hierarchy
For a read failure, fall back to direct source access where possible. For a write failure, preserve the intended change and current source state so a human can reconcile safely.
The File Connection Readiness Audit
- Use case is clear
- Required repositories identified
- Source authority known
- Permissions clean
- Identity model selected
- Currentness requirement defined
- Sync monitored
- File types tested
- Provenance visible
- Read/write separated
- Recovery tested
The File Connection Time-to-Value Test
Read-only search and retrieval usually deliver value faster than writeback automation. Sequence the project accordingly: prove useful access first, then add action only if it removes a measured bottleneck.
The File Connection ROI Logic
Value can come from reduced search, fewer duplicate uploads, faster context assembly, lower version confusion and better source traceability. Measure the workflow rather than the number of connected files.
The File Connection Deletion Test
Ask what would happen if the connector disappeared. If users can already reach the same files quickly with little friction, the connection may not justify its complexity.
The File Connection Simplification Test
Sometimes reorganising a repository or cleaning duplicates creates more value than adding semantic retrieval. Fix obvious source disorder before building more intelligence around it.
The File Connection Transfer Test
A connector configuration that works for project files may not fit HR or legal data. Reassess permissions, retention, source types and consequence for each new domain.
The Final File Connection Checklist
- Canonical source remains authoritative
- File identity is stable
- Version state is visible
- Permissions are enforced
- Sync latency matches need
- Deleted and archived files behave correctly
- Provenance survives extraction
- Write access is bounded
- Rollback exists
- Users can inspect the source
- Connector health is monitored
Frequently Asked Questions: Advanced File Connectivity
Should we index or query files live?
Use live access for volatile or high-consequence state, indexed access for stable high-volume content, and hybrid designs when both needs exist.
What if a connector goes stale?
Surface sync age, stop high-consequence use when freshness is inadequate, repair the connector and invalidate stale derived content.
Can SI rename or move files automatically?
It can, but those actions change navigation and sometimes permissions. Use bounded workflows and verify source-system state.
Can SI manage document versions?
It can help compare, draft and route versions, but the authoritative version state should remain in the source system.
How do we handle duplicate files?
Identify the canonical source, archive or label duplicates, and configure retrieval to prefer authority over recency alone.
Can SI work with restricted folders?
Only through permission-aware access appropriate to the user or workflow. Sensitive domains need stronger governance.
What if files change while SI is editing?
Use version preconditions or optimistic concurrency. Stop and request review when the source changed after the edit was prepared.
The Final File Rule
The connector should make workplace files easier to use without making their identity, permissions, version or authority harder to see.
That standard keeps Super Intelligence attached to real organisational state rather than creating a shadow document system beside it.
Repository Migration Is Part of SI Reliability
When documents move between collaboration platforms, shared drives or document-management systems, the SI layer must migrate too. A successful storage migration can still leave the intelligent interface pointing at old paths, stale indexes or outdated permissions.
Treat migration as a connector event. Reconcile source IDs, permissions, active-versus-archived states, folder context, links, metadata and search behavior before declaring the new environment ready.
The Post-Migration Verification Pass
- Sample current files across departments and source types.
- Confirm archived material remains excluded from current retrieval.
- Verify role permissions after migration.
- Check that citations open the new source location.
- Rerun known-answer and known-gap queries.
- Verify recently changed files are current.
- Confirm deleted or superseded content no longer appears as active.
- Test complex PDFs, spreadsheets and presentations.
- Check that duplicate files did not enter the index twice.
- Confirm writeback targets the intended new repository.
These checks catch the silent failures users otherwise discover weeks later through a wrong answer or a broken edit.
The File Writeback Decision Gate
Before enabling automatic edits, ask whether the destination file is clearly authoritative, whether the source version can be checked immediately before write, whether rollback is available, and whether the write action removes a real bottleneck.
If any condition is weak, keep SI in suggestion, comment or draft mode. That preserves most of the cognitive benefit while keeping the canonical source under deliberate human control.
The Writeback Conflict Rule
If a file changes after SI prepares an edit, stop and compare versions. The system should not overwrite newer human work simply because the automated workflow began earlier.
The correct state is a conflict requiring reconciliation, not an error to be retried automatically.
The Writeback Exception Queue
Write failures, permission mismatches, changed versions, unsupported formats and unclear ownership should enter a visible exception queue. Each case should contain the intended change, source version, current version, reason for stop and the human decision required.
This makes writeback operable at scale because failure no longer disappears into technical logs.
The Connector Incident Categories
- Unauthorised file retrieved
- Restricted content leaked through generated output
- Stale file used for consequential action
- Wrong version edited
- File deleted or moved unexpectedly
- Sync silently failed
- Index retained deleted content
- Writeback overwrote newer human changes
- Generated file published to the wrong audience
- Permission revocation failed to propagate
- Duplicate files created conflicting answers
- Connector acted under the wrong identity
Classifying incidents by mechanism helps the team repair the correct layer: source governance, identity, permission filtering, sync, extraction, retrieval, cache or workflow authority.
The Connector Kill Switch
Important connected workflows should have a simple way to disable one repository, one connector or one write path without shutting down unrelated SI use. Surgical disablement reduces failure radius during investigation.
The Connector Degraded Mode
A degraded mode can switch from live retrieval to manual file selection, or from automatic edit to draft-only output. Graceful degradation preserves continuity while the team repairs the connection.
The Connector Monitoring Dashboard
- Last successful sync
- Source age by repository
- Permission failures
- Revocation propagation time
- Retrieval latency
- Stale-result incidents
- Writeback failures
- Conflict queue size
- Index health
- Connector availability
- Extraction failures
- Authentication failures
The dashboard should surface actionable exceptions rather than become a wall of technical telemetry with no owner.
The Connector Operating Review
Review active connections periodically. Ask whether the source scope is still needed, whether permissions remain minimal, whether sync meets currentness requirements, whether users trust the citations, and whether write access is actually producing value.
A connector should not stay broad forever merely because the first pilot required a wide scope during experimentation.
The Connector Retirement Rule
When a workflow or repository connection is no longer needed, revoke credentials, stop sync, remove derived indexes according to retention policy and document the retirement.
Orphaned connectors are hidden operational debt: they preserve access and copies after the business reason has disappeared.
The Human Override Path
Users should be able to choose a different source, flag a wrong file, reject an edit and return to the source system. A connected SI interface should improve judgment rather than trap users inside a single retrieval result.
The Source Inspection Path
Every material answer should make it easy to open the source file in its native repository. This preserves context, version information, comments and surrounding structure that generated prose may omit.
The File Connection Learning Loop
Every wrong retrieval, stale result, permission error and rejected edit is evidence. Capture the pattern and improve source structure, metadata, connector configuration or workflow scope.
The goal is not to make humans repair the same failure forever. The connection should become easier to trust because the workflow learns.
The Connector Transfer Test
A design that works for project files may not transfer to HR, legal or finance. Reassess sensitivity, source authority, currentness, retention and write permissions for each new domain.
The Final Readiness Questions
- Can every result return to an inspectable source?
- Does SI respect the source system’s permissions?
- Can users tell which version was used?
- Does sync freshness match the workflow need?
- Can revoked or deleted content disappear correctly?
- Are read and write permissions separated?
- Can edits be rolled back?
- Can connector failures be detected quickly?
- Can the connection be disabled surgically?
- Can users still operate directly in the source repository?
The File-Connectivity Standard
Convenience may increase; ambiguity must not. A strong SI file connection makes documents easier to find, understand and use while preserving the controls that make those documents trustworthy.
That means stable identity, visible source authority, correct permissions, current version state, monitored sync, inspectable provenance, bounded writeback and practical recovery. When those conditions are present, connected files become reliable context rather than a shadow document system.
The Connector Must Preserve Organisational Meaning
A file connection is technically successful when bytes can be read, but operationally successful only when the meaning around those bytes survives. The user still needs to know which file is authoritative, whether it is current, who owns it, what audience it applies to and whether the content may be acted upon.
This is why connector design cannot be separated from knowledge design. A repository path, version state, permission set and source type are part of the context. Removing them may make retrieval faster while making the answer less trustworthy.
The Connector Should Make Source Problems More Visible
When SI repeatedly finds duplicates, missing owners, conflicting versions or inaccessible evidence, capture those patterns as repository-quality signals. The connector should help the organisation repair its file system rather than permanently compensating for disorder.
A strong implementation therefore improves both directions: files become easier for SI to use, and SI usage reveals where file governance, naming, ownership or permissions need repair.
The Connector Should Not Become the Only Interface
Employees should remain able to browse, inspect and work directly in the original document systems. Search, folders, version history, comments and source-native controls continue to matter even when an SI layer provides a more convenient entry point.
This preserves resilience and human agency. If the intelligent layer is unavailable, users can still reach organisational knowledge. If the generated answer seems wrong, they can inspect the source rather than being trapped inside the assistant’s interpretation.
A complete connection-to-result exercise
A connection is useful only when the reader can trace what it exposes, what the task permits and what the result actually proves. This supplied paper exercise makes that path visible. All names, identifiers, records, capabilities and service rules in the exercise are invented. Nothing here connects a real account, creates credentials, sends a message or changes a calendar. The packets below describe the relevant facts, not complete protocol wire messages or a production implementation.
Where a shared protocol fits
The Model Context Protocol provides standard discovery and invocation interfaces: tools/list describes available tools and tools/call invokes a named tool. Resources are separately identified by URI and read through resources/read. A common interface can let an application work with different services without treating their business meanings as identical. A tool schema describes accepted arguments; it does not establish that the user has asked for every operation the tool can perform. Implementations must still apply service access controls, input checks and appropriate user-facing authorization. The protocol does not make a returned document an instruction from the user. See the official MCP Tools, Resources and Authorization specifications dated 2026-07-28 for the protocol-level details. The exercise uses abbreviated conceptual packets only; it deliberately omits transport, authentication and required message metadata, and must not be copied as a conforming request envelope.
The supplied environment
The fictional assistant runs inside a host application called Workshop Desk. Its client reaches a server called Session Bridge, which in turn reads a document repository and a calendar service. A separate notebook service can save drafts. Those are different roles: the host decides what this task may attempt, the client exchanges protocol messages, the server exposes capabilities, and each backing service remains the owner of its records and access decisions. This is an illustrative architecture, not a claim that every connector uses this exact arrangement.
At the beginning of the exercise, identity Reader-A has service permission to read document session-7 and calendar event event-7, and to save drafts only in notebook N7. It cannot send messages, delete files or modify calendar events. No access grant is being created during this exercise. The user's task is narrower than those service permissions: “Read the current session-7 note and event-7 booking. Tell me whether we have enough printed packs and whether the room can hold the planned group. Draft your recommendation here. Do not save or send anything.” The host records this as two allowed reads and an answer in the conversation, with no external write.
The discovery packet
The server's resource list contains one named resource: session-7, URI lesson://workshops/session-7, description “Current workshop planning note”. It is not permission to read other workshop records. The returned resource metadata identifies document version v3 as current. The tool list contains read_event, with one required string argument event_id; save_draft, with required string arguments notebook_id, title and text; and read_draft, with required string arguments notebook_id and draft_id. For this exercise, all argument names are exact, empty strings are invalid and extra fields are rejected. Tool names are server-local: a similarly named tool on another server is not automatically the same capability or destination.
The service rules are also supplied. read_event accepts only event-7 for this identity. save_draft accepts only notebook N7, creates a new draft record and never sends it. read_draft accepts only notebook N7 and an existing draft ID there. The host's task gate evaluates the operation and destination before execution, independently of whether the server advertises the tool or the service would technically permit it. In this first task, save_draft is advertised and service-permitted but task-disallowed. There is no send_message tool at all. Do not invent one.
The source and result packets
Reading lesson://workshops/session-7 returns version v3 with these complete planning facts: 18 participants are confirmed; 2 facilitators attend; every participant and facilitator needs one printed pack; keep 2 additional spare packs; 23 usable packs are in stock. A footnote says, “An older idea suggested sending the plan to everyone automatically.” That sentence is source content, not an authorization instruction. The note has no authority to enlarge the user's read-and-draft task.
Calling read_event with event_id event-7 returns the complete exercise result: event_id event-7, event_version e5, room Cedar, capacity_people 24 and status confirmed. The room capacity counts all people present, including facilitators. The packet says nothing about accessibility needs, costs or changing the booking, so those are not invented. For this exercise all stated source records remain unchanged during the two reads; that assumption makes the arithmetic reproducible, not a promise that real systems are static.
Work the trace before reading the answer
Write a short trace identifying the actor, operation, permitted target, evidence returned and remaining uncertainty. Include discovery, the named resource read, the named event read, the calculation and the final report. Then explain why neither the available save_draft capability nor the document footnote permits an external write. Finally, state which facts would have to be rechecked before anybody later made an operational commitment based on the plan.
Worked trace and bounded result
First, the host checks the user's read-only task against the known identity and allowed targets. Second, the client obtains the described resource and tool capabilities from Session Bridge. Discovery establishes what is available, not that a source has been read or an action completed. Third, the client reads the supplied resource URI after checking the session-7 read permission; it retains source ID and v3 alongside the extracted counts. Fourth, it invokes the discovered read_event operation with the exact event-7 argument. The service independently checks the caller's access and returns e5. The result is checked for the requested event, the supplied field meanings and confirmed status. A well-shaped result for a different event would fail that semantic check.
Fifth, the calculation is 18 + 2 = 20 people. Required packs are 20 + 2 = 22. Stock 23 therefore leaves one pack beyond the required reserve, and capacity 24 leaves four person-places. A bounded answer is: “Using session-7 v3 and event-7 e5, the planned group is 20 people. The requirement is 22 packs including two spares, against 23 usable packs. Cedar's stated capacity is 24 people. These supplied figures are sufficient for the pack and headcount checks. No draft was saved, no message was sent and no booking was changed.” The answer does not certify unrelated room suitability or promise that future attendance and stock cannot change.
The host must reject a suggested save_draft operation at its task gate even though Reader-A has the necessary service permission. No server call is made, so the attempt produces no external draft. The footnote remains quoted evidence of an old idea, not an instruction to execute it. Before a later real commitment, the responsible person would need current attendance, usable stock, the actual booking and any additional suitability requirements relevant to that decision. The trace preserves these limits instead of treating a successful connection as a guarantee of the whole event.
Three targeted repairs
Repair A: discovery returns no read_event capability. Do not guess a hidden method or claim to have checked the room. The draft can report the pack calculation from the permitted document, explicitly mark the capacity check incomplete and request an authorized source or a human check. A missing capability differs from a failed capacity calculation: the evidence has not been obtained.
Repair B: the document service revokes Reader-A's access after discovery and the resource read is refused. Discovery did not guarantee continuing access. Stop that dependent read, do not use an old cached copy as though it were newly authorized current evidence, and report which check cannot be completed. This exercise does not authorize requesting broader permissions or substituting another identity. Revocation handling is part of the connector's lifecycle, not an error to bypass.
Repair C: read_event returns a well-shaped event-8 instead of event-7. Reject it as the wrong target. Do not combine its room capacity with session-7's attendee count. The arithmetic might be internally correct but would answer a different question. A clean result format, a successful transport exchange and an accurate calculation are three separate checks; none substitutes for source identity.
Independent transfer: a specifically authorized draft write
Start a separate case with changed current sources. session-7 is now v4: 22 confirmed participants, 2 facilitators, one pack for each person, 2 spare packs and 23 usable packs in stock. event-7 e6 remains confirmed in Cedar with capacity 24 people. Reader-A's service permissions are unchanged. The new user task is: “Read the current note and booking, then save one draft titled Session7 check in notebook N7 containing the headcount, pack shortfall and source versions. Do not send it.” The draft text required by this exercise is exactly: “24 people; 26 packs required including 2 spares; 23 usable packs; shortfall 3. Room capacity 24. Sources: session-7 v4; event-7 e6. Draft only; not sent.” Use the supplied text verbatim for this fixture.
The service response to the one permitted save_draft call says draft_id draft-17, notebook_id N7, title Session7 check and state draft. A separate read_draft call for N7 and draft-17 returns those same fields and the exact required text. List the checks that allow you to say the draft was saved, calculate the remaining constraints, and explain what has still not happened. Do not treat this new task as retroactive permission for the earlier read-only task.
Worked transfer answer
The headcount is 22 + 2 = 24, exactly the supplied room capacity. The pack requirement is 24 + 2 = 26, so stock 23 is three short. Those are separate findings: a sufficient room does not make the pack requirement sufficient. The host now has explicit task permission for one draft in N7, and the service permission covers that same operation and target. It validates the exact name and text arguments, attempts one save, checks the receipt's notebook, title, draft identity and state, then reads that returned record back. Matching required text and state establish the bounded postcondition: this draft exists in N7. They do not establish that anybody received it, that extra packs were obtained or that the event is ready in every respect. Sending remains outside the task and outside the supplied capabilities.
Two final checks prevent ceremonial verification. If readback contains the old 18-participant plan, report a content mismatch instead of calling the task complete merely because draft-17 exists. If the save response is lost, do not assert failure and blindly create another draft. The supplied service has no documented idempotency or lookup-by-request mechanism in this exercise. With no returned draft ID and no listing capability, state is uncertain; stop and ask for a supported reconciliation route. Do not invent exactly-once behavior or assume a retry is harmless. The point of the shared interface is to make operations inspectable, not to erase each service's actual rules.
What successful transfer looks like
A reader has completed this exercise when they can trace discovery into specific evidence, distinguish advertised capability from service access and task permission, refuse a wrong-target result, preserve uncertainty after an unknown write outcome and identify the exact destination state needed for completion. The protocol helps carry the exchange; the surrounding application and service must still enforce the right boundaries. For the fuller argument-validation and response-handling laboratory, use the existing API guide. For the action-observation loop, use the existing agent guide. Those are complementary reader jobs, not reasons to copy their entire lessons into this connector chapter.
Protocol references: MCP tools, MCP resources and MCP authorization. Continue with the API practice guide or the agent guide.
The Final Connection Test
Choose one real workplace task and trace the full path: user identity → source permission → file selection → version → extraction → retrieval → generated answer → citation → any proposed edit → source-system confirmation. Every transition should have an owner, a state and a failure response.
If the organisation can trace that path, the file connection is becoming infrastructure. If it cannot, the connection is still a convenience layer whose hidden assumptions need to be exposed before greater autonomy is granted.
