Comprehensive feature request: live integrations, secure sign-in, and low-latency computer use

[ivankoval921-bit]

Summary

Codex and ChatGPT should provide a first-class, continuously updated integration layer for the services and applications that users already use every day. The goal is a reliable online assistant that can work with current user-authorized information and complete approved tasks without repeated manual extraction, re-importing, copying, or fragile local workarounds.

1. Live Google integrations

Please support one or more user-selected Google accounts, including:

• Google Drive, Docs, Sheets, Slides, and shared folders
• Google Calendar
• Google Keep
• Gmail, when separately authorized

After the user grants access to selected accounts, folders, or services, Codex should automatically index existing content and keep the index synchronized with new, changed, moved, and deleted items.

The synchronization should be incremental and event-driven where possible. A new document, note, email, or calendar event should become searchable and usable for an approved task without the user having to extract it manually or import it again.

The system should show:

• which Google account and folder a result came from
• the source link
• the last synchronization time
• whether the information may be stale
• any synchronization error or missing permission

This should work across multiple accounts at the same time, with clear account-level and folder-level permissions. The user should not need to build custom watcher scripts or maintain a separate local database merely to keep the assistant up to date.

2. Trusted-device sign-in and credential-manager support

On a user-authorized personal device, Codex should be able to request autofill from Chrome or Google Password Manager, Bitwarden, Windows Credential Manager, and passkey providers.

The credential must remain inside the browser or password vault. The agent must never receive, display, store, or expose the raw password. The user should be able to approve autofill with a button, Windows Hello, a fingerprint, or another local device confirmation.

The sign-in flow should support:

• user-controlled login on a visible browser window
• saved-password autofill without exposing the password to the agent
• passkeys and security keys
• manual MFA or one-time-code entry by the user
• pausing and resuming the same task after MFA
• persistent, revocable authorization for a trusted device
• separate permissions for each site, account, and connector
• a clear sign-out and revoke-access action

If a login expires, the agent should pause at the exact step that needs the user and continue the existing task after the user finishes. It should not restart the whole workflow.

3. Low-latency computer control

Computer use should be optimized for the lowest practical latency while remaining transparent and compliant with the rules of the site or application.

The preferred order should be:

1. direct API
2. DOM and JavaScript
3. CDP or browser accessibility interfaces
4. Windows UI Automation and accessibility APIs
5. keyboard commands
6. mouse and visual interaction only when the other interfaces are unavailable

The agent should:

• batch independent safe actions
• wait for actual DOM, network, or application events instead of fixed delays
• capture only changed screen regions when visual inspection is needed
• maintain a compact state diff instead of repeatedly processing full screenshots
• reuse an authorized browser session instead of opening unnecessary duplicate sessions
• report why it selected a particular control method
• keep the cursor and visible window available when the user requests visible operation
• verify that a requested window is genuinely visible on the desktop, not merely open in a hidden background session

Local actions should complete in milliseconds where technically possible. Network and server delays should be handled by event-based waiting and clear progress reporting. The objective is fast, understandable, policy-compliant automation, not imitation intended to bypass anti-bot protections.

4. Reliable long-running tasks

Tasks should survive normal interruptions such as an expired login, an MFA request, a browser restart, a temporary network failure, or a computer restart.

Codex should save a safe checkpoint containing:

• the task goal
• completed actions
• the current step
• pending user approval
• the sources and permissions being used
• the reason for any pause or failure

After the user resolves the problem, the task should resume from the checkpoint rather than start again.

5. Safety, privacy, and user control

Every connector should provide least-privilege permissions and a readable audit trail. The user should be able to see and revoke:

• connected accounts
• selected folders and services
• active browser sessions
• stored authorization grants
• automations and triggers
• data retained in the index

Before sending a message, publishing content, deleting files, changing permissions, making a purchase, or performing another consequential action, Codex should show the exact final action and ask for confirmation.

Search results and generated answers should retain source references so the user can inspect the original document, note, email, or event. The assistant should distinguish current information from stale or unavailable information.

6. Cross-product and approved-agent interoperability

The same permission and connector layer should be usable by Codex, ChatGPT, and other explicitly approved assistants or applications. Sharing should happen through scoped, revocable permissions and source references, not by copying passwords or silently exposing an entire account.

The user should be able to choose:

• which assistant can use which connector
• which account, folder, or service is available
• whether access is read-only or can perform approved actions
• whether a new or changed item may trigger an automation

Expected outcome

This would turn Codex into a genuinely useful online knowledge and computer assistant. Users could connect their existing services once, keep the information current automatically, authorize sign-ins safely on their own device, and assign tasks that continue reliably. The system would be faster, easier to audit, and much less dependent on manual extraction and custom integration work.