AI Troubleshooting Guide
AI Tool Access & Network Troubleshooting
A page won't load, features disappear after sign-in, or a response stops midway. Where should you look? Find the first point of failure, then check the route, permissions, or quota.
Haven't installed a client or imported a subscription yet? Start with the getting started guide and follow the steps to verify your connection. If you're connected but an AI tool still doesn't work, use the contents below. VPNI6 provides international routes; access to third-party tools still depends on their regional policies, account permissions, and current service status.
Assess AI tool Availability
Turn “it doesn't work” into a reproducible symptom
When troubleshooting, note the last action that worked and the first one that failed. For example, the product homepage loads, but sign-in gets stuck at the identity provider; or the account reaches the workspace, but a short prompt just sits there. “The internet works” doesn't narrow things down: a browser may load a cached homepage while the request that submits a task goes to a different address. Record the exact error, when it occurred, and which entry point you used. That gives you a consistent baseline for the next test.
Test a basic request with a short prompt that contains no personal information, such as asking for a one-line greeting. Don't upload files or enable search, tool use, or image generation yet. If the basic feature works, add the original features back one at a time. If text works but an attachment keeps failing to upload, check the upload route, format, and permissions. Changing the attachment, prompt length, and model all at once makes the result hard to interpret.
Region, identity, and transport are separate checks
A regional availability check involves more than looking up the location of an exit IP. A third party may separately check the product entry point, the account's market, payment details, or the organization's permitted usage. Follow its official guidance. Geolocation databases may also be out of sync across services. A lookup can show where a request appears to come from; it can't confirm that an account is eligible to use a product. If the official rules say the service isn't supported, use an available alternative or contact the provider rather than repeatedly changing exit routes.
Identity checks don't happen only when you enter a password. The sign-in page, identity provider, and app that receives the sign-in result each maintain their own session. If the first part uses the office network and the return to the app switches to another route, you may see a redirect loop or be asked to authenticate again. Keep the exit route consistent on a network you're authorized to use, then start the full sign-in flow from the product entry point. Don't paste an old callback link from another tab into a new environment.
Transport checks focus on whether a request can reach its destination and whether the response can keep coming back. DNS resolution failures, certificate validation errors, explicit service rejections, and a response body that stops partway through happen at different stages. They may all look like “Something went wrong,” but they need different fixes. If you get a clear response, read its error body first. If there's no response, check how far the connection got. Don't disable certificate validation just to make an error disappear. On a work device, ask your administrator to check the trust chain.
Keep a comparison for each test
Check the provider's status page first to see whether the same product, feature, or region is affected. No notice doesn't prove the service is fully operational; a localized incident may not have been reported yet. Next, use the same account, task, and entry point, changing just one condition. For example, keep the route and switch browsers, then try the original browser as a comparison. This helps separate browser session issues from network path issues. When switching devices, note whether the network changed too, or the result will reflect two variables.
Group results by stage: before connection, after sign-in, after submission, or during output. If only one workspace fails, check permissions and organization policies. If the same entry point can't connect on multiple devices, check the shared gateway or exit route. A reachable public entry point doesn't rule out a failure at a resource domain, but it does narrow the search. When you finish, record the conditions that worked rather than just writing “switching routes fixed it.”
How Common AI Tools Differ by Entry Point
Identify the product, then the entry point
A single brand may offer a chat website, API platform, desktop app, and organization workspace. Similar names don't mean they share the same eligibility requirements. First check whether you're using a personal or work account, and whether you're on the website, an editor plugin, or a developer console. Follow the help center guidance for the specific product, paying close attention to whether a regional availability list applies to your entry point. Don't rely on an old screenshot.
| Tool | Distinguish first | Check first | Minimal test |
|---|---|---|---|
| ChatGPT | Chat website vs. API platform | Workspaces, projects, and their individual requirements | Send plain text; test the API separately |
| Claude | Chat product vs. developer entry point | Regional availability and credential scope for the product | Send a short text request through the current entry point |
| Gemini | Personal entry point, developer tools, and organization environment | Selected identity, organization policies, and project settings | Verify the account, then test text features separately |
| Copilot | Workplace and code collaboration products | The actual sign-in identity and assigned entitlements | Trigger a basic feature in the target app |
| Midjourney | Task submission and result loading | Permissions, task status, and resource requests for the entry point | Submit plain text and check the result |
| Cursor | Editor process vs. terminal process | Editor sign-in, network settings, and feature permissions | Test chat in a blank project first |
Successful sign-in doesn't guarantee a successful API call
Verify ChatGPT and Claude web sessions separately from developer credentials. Seeing a model list on the website only means the current session can read that list; it doesn't mean a particular API key can call a model with the same name in a given project. If an API request fails, first check that the base URL, project, and model belong to the same product environment. Keep the working website as a comparison, but don't keep increasing API retries based on it or use web session details in place of API credentials.
Gemini may offer different features in personal and managed environments. If you're signed in to multiple accounts in a browser, the app may use a different one from the account you selected in another tab. Check the identity and organization shown in the app, then confirm with your administrator that the feature is enabled. In a work setting, switching to a personal account may show a different interface, but it isn't a substitute for handling organization data properly. Ask your administrator which entry point is approved.
With Copilot, confirm the full product name. An entry point in a work app and GitHub Copilot in an editor shouldn't be treated as the same authorization. In a code editor, completing sign-in in the browser doesn't mean authorization returned to the right editor instance. Check the extension status, the identity used by the editor, and the organization's entitlement assignment. If multiple windows prompt for authorization, close unrelated ones and restart from the window that failed. This makes it easier to see where the sign-in flow returns.
Separate task status from display status
Submitting, queuing, generating, and loading results in Midjourney are separate stages. If the interface says a task is complete but the image is blank, check resource requests and content filters on the device before submitting the same task again. If the task was never accepted, check the entry point, account status, and error message first. Keep the task ID for official support, but don't post the original prompt or unreleased material in public discussions.
Use a blank project in Cursor to isolate the issue. Test sign-in and ordinary chat first, then add file context, indexing, extensions, and remote development one at a time. If only one workspace fails, check workspace overrides, organization policies, and request size before changing global network settings. If chat works but requests from the editor's terminal fail, the terminal may not have inherited the editor's proxy settings—and the reverse can also happen.
When reporting an issue, specify which action failed in which entry point. If the website signs in but an organization project is unavailable, list organization permissions as something to check. If a task submits successfully but its result can't be read, include both the task status and the resource error. This is more useful than a screenshot of a blank page and avoids implying that one working feature means every feature in the product works.
International Routes and Split Tunneling
Choose a route based on the failure point, not its name
Before comparing routes, confirm that the account and usage region meet the target service's requirements, then choose a path suited to the task. VPNI6 covers 110+ countries / 210+ routes. See global locations for regions and route types. A route name can narrow down your options, but it can't predict how a third party will identify an exit. Even within a supported region, compare the full result for the same task rather than just how quickly the homepage loads.
| Route type | What to compare | Test |
|---|---|---|
| IEPL dedicated line | Whether changes in the cross-border segment affect long responses | Record whether the response body continues to completion |
| Relay | Whether connection behavior changes with a different relay path | Repeat the same sign-in flow and task |
| Direct | Performance without an additional relay | Use as a baseline path for a basic request |
If the beginning of a response arrives quickly but it often stops midway, focus on sustained data transfer, not just time to first token. If even the identity page won't load, check DNS and certificates first, then consider changing routes. A brief routing disruption can interrupt a long request, but browser sleep, a gateway read timeout, or server-side termination can produce the same symptom. Success after switching routes only confirms that something changed; repeat the test under the same conditions to narrow down why.
With rule-based routing, check the entire request path
With rule-based routing, check the client's connection logs to see which rule the app actually matched. Sign-in may redirect through an identity provider, and chat and attachments may use different service addresses. Identify the type of request that failed first, then add rules based on official documentation or organization-approved guidance. Don't add every domain you see to a broad matching rule: that could change how other services connect and make the next investigation harder.
Global mode can be useful as a brief, controlled comparison, but only for traffic the client actually handles. On a managed work device, confirm that this test is allowed first. If full sign-in works in global mode but fails on the redirect when you switch back to rule-based mode, check whether the identity entry point and callback are taking different routes. If both modes return the same permissions error, stop changing routing rules and check the account and service requirements instead.
Automatic route selection and smart split tunneling reduce day-to-day effort, but can add variables during troubleshooting. If the route changes during a session, the selected route name before the failure may not reflect the actual exit path. If permitted, pin the same candidate route for sign-in and testing, then restore your usual settings. Not sure about the terminology? Start with the guide to subscriptions, nodes, and routing terms.
An exit check only tells you about the current process
Open VPNI6's IP lookup in the browser where the problem occurs to check whether the exit shown for that page matches your expectations. But split tunneling may route traffic differently by destination, so this doesn't prove that AI requests use the same path, or say anything about a terminal, editor, or remote machine. Check the connection logs for the relevant process too. If your workplace uses a managed proxy, follow your organization's network rules and avoid changing the system proxy from multiple places at once; that can lead to conflicting results.
After testing, write down the smallest configuration that reproduces the result: device, mode, entry point, and action. Keep only the rules needed to resolve the issue; don't leave global settings enabled after using them for comparison. If failures are more common in the evening, repeat the same task at a similar time and note device network changes, service notices, and whether the output was cut off. This helps compare routes without blaming local settings for congestion at the provider.
Account Registration, Sign-In, and Region Checks
Keep your VPNI6 account separate from third-party tool accounts
VPNI6 doesn't require an email address. Create an account with a username and password. This account is for the VPNI6 user panel and is separate from third-party tool accounts, authorizations, and billing. Before creating an account with a third-party tool, check whether it's available for your region, account type, and intended features. Provide accurate information and use the account entry points listed by the provider. If no supported entry point works for you, check the policy or choose an appropriate alternative.
If your organization or school provided the account, check whether you're allowed to activate it yourself and who assigns features. Some products allow sign-in without enabling the feature you need. Common reasons include being signed in under the wrong directory, selecting the wrong organization, or not having an entitlement assigned by an administrator. Repeatedly creating accounts with the same identity won't change those conditions. Check the workspace shown in the app and ask an administrator to review the authorization records instead of switching back and forth between identities.
Locate the failure by where the redirect stops
If the flow stalls before reaching the identity provider, confirm the address is an official entry point, the page has fully loaded, and the managed network doesn't restrict access. If the identity page reports success but the app asks you to sign in again, check that you completed the flow in the same browser profile and window that started it. Browser storage settings, extensions, and organization policies can all affect redirects. Use an approved clean profile for comparison; don't disable global security settings and hope for the best.
Before clearing site data, save any unsent work and make sure you can access the account recovery option. Only clear data for the site involved, not your entire work environment. If desktop software uses browser-based authorization, confirm that the flow returns to the process that started it. Signing in to the same account on another device won't make the browser pass this session to that device. After the redirect, check the identity shown in the app before testing the feature.
If the browser works but an app keeps asking you to sign in, check the device clock, automatic time zone synchronization, and certificate trust status. Session credentials expire, and a clock that's out of sync can affect local checks. A certificate error needs the system trust chain reviewed according to your organization's requirements. Both issues can appear during sign-in, but neither is fixed by changing accounts. If you see an unfamiliar certificate warning or a login address that looks similar but isn't official, stop and verify the entry point before entering credentials.
Distinguish additional verification, regional restrictions, and suspensions
When asked for additional verification, first check whether the prompt comes from the provider, identity system, or office gateway. Follow the official verification process if there is one; repeatedly changing devices and networks can make the issue harder to reproduce. If the message clearly says your region or organization isn't eligible, follow the official rules instead of repeatedly changing exit routes. If the account is restricted or suspended, check official notices and recent activity, then appeal or recover it through official channels.
If you see an unfamiliar activity alert, review recent authorizations and sessions. Sign out of any suspicious sessions and reset credentials if the provider recommends it. Don't share full callback links, browser sessions, or authorization details from screenshots with unofficial support contacts. Troubleshooting requires the stage where the failure occurred and the error message—not reusable sign-in materials. Before sharing a screenshot, crop out identity details, identifiable workspace information, and private tabs.
After recovering an account, complete the full flow on a trusted device: confirm you're in the original workspace, send a short prompt with no business data, then test the feature that failed before. If sign-in works but that feature still doesn't, track its error separately rather than treating it as an unresolved sign-in issue. This avoids pointless repeated verification and lets whoever takes over focus on the right authorization step.
Web Apps, APIs, and Streaming
A page loading only verifies some requests
A browser may load a cached page; sending a prompt is what creates a new request to the backend. The client may also make separate requests to retrieve model lists, upload attachments, or fetch generated results. If history appears but new content won't generate, use the developer tools Network panel to find the request that appeared when the failure occurred and check its error category. For comparisons, use only test text that you can share publicly. Network logs may contain the original request and full response.
APIs authenticate with project credentials, and the caller must also select an endpoint and model, send valid parameters, read the response, and determine when it ends. An API can fail because the project lacks permissions, parameters aren't supported, or billing isn't set up, even when the website works. Build a minimal request from the official documentation without attachments, tool calls, or structured output. Once it succeeds, enable only the parameters you actually need, one at a time.
Check time to first output separately from gaps between chunks
Streaming sends a response in chunks as it's generated. If the first chunk takes a long time to arrive, the connection may not be established, the server may not have started generating, or a gateway may be buffering the response. If the response starts and then stalls, a proxy idle timeout, a client that closed the connection early, or an incomplete server response could be responsible. Record separately whether you received response headers, whether body data arrived in chunks, and whether you received the documented end-of-stream event.
If a service uses server-sent events, a chunk of bytes read from the network isn't necessarily a complete event. An event can span multiple reads, and a single chunk can contain multiple events. The parser should process complete content at event boundaries and preserve incomplete data between chunks. Otherwise, a route change that happens to alter chunking can look like a network problem when the issue is actually in the reader. Prefer the provider's maintained API client and its event-handling implementation.
| What to observe | What it tells you | How to compare |
|---|---|---|
| Connection timeout | Whether the connection needed for the request can be established | Use the same process to access an approved test address first |
| Read timeout | How long to wait for response data after connecting | Check the client's and gateway's read timeouts |
| Overall timeout | How long the entire task is allowed to run | Compare the runtime environment's limit with the application's own timeout |
| Output limit | Whether a parameter caused the response to end normally | Check the reason the response ended; distinguish it from a network interruption |
If a short, non-streaming request succeeds but the same task fails in streaming mode, focus on stream handling, gateway buffering, or response idle time. Conversely, non-streaming requests may wait for the entire response, so a long task could hit the overall timeout first. Don't set every timeout to a very high value. Shorten the test task and identify which stage hits its limit first, then choose appropriate values for normal workloads.
Account for what has already happened before retrying
A user cancellation, a partially received response, and a service-side failure aren't all the same as “not executed.” When a connection drops, the server may have received and continued processing the request, or it may have generated part of the result. Don't blindly resubmit tasks that write, publish, or incur charges. Check the task status and whether the provider supports idempotency. If you can't confirm, save any partial result, mark the task incomplete, and let the caller decide whether to submit it again.
If errors occur only with large attachments or rich media tasks, reduce the number of attachments and the context length to distinguish an incomplete upload from a processing or download failure. Reproduce the issue with a similar, non-sensitive sample; don't share the original file through support channels. Record comparable results—for example, whether a blank conversation works consistently, where a request with attachments stops, and whether the result was generated. That's more useful than copying a long, unsanitized browser log.
Network Settings for the CLI, IDE, and CI
First identify the process making the request
A terminal command runs in the current terminal environment; a desktop editor may be launched from the system UI, and a remote development extension may run on another machine. They may not share system proxy settings, environment variables, or certificate stores. Start by identifying which process is making the request: test from the environment where the command actually runs, then use the extension or app's diagnostics to confirm where it runs. Don't infer that a remote runner uses the same route just because the local browser does.
First test a regular HTTPS address approved by your organization, without credentials or business data. The example below sends a request to a public example site and reports timing by stage. It checks general access from the current command; it doesn't check the health of a third-party AI service. If you use a proxy, connection timing may reflect the connection to that proxy, not end-to-end latency to the destination.
curl --silent --show-error --output /dev/null \
--write-out 'http=%{http_code} dns=%{time_namelookup} connect=%{time_connect} first=%{time_starttransfer}\n' \
https://example.com/
If both the system environment and app support an organization-approved proxy, limit the test change to a single command. The example below works in compatible terminals. Run the second command only if APPROVED_PROXY_URL has already been configured through a managed environment; don't put the actual setting in a repository or ticket. When comparing it with the previous test, also check whether existing exclusion rules sent that address along a different route.
test -n "$APPROVED_PROXY_URL" && \
HTTPS_PROXY="$APPROVED_PROXY_URL" \
curl --silent --show-error --head https://example.com/
If the general test address is reachable, use the diagnostic entry point the official documentation provides for your specific product. Programs differ in how they read proxy variables, capitalization, and system settings; one successful command doesn't prove every tool will work. If your organization's gateway requires a managed certificate, import the appropriate trust chain as instructed by your administrator. Don't use options that skip certificate validation. When reporting a certificate error, include its category, not the full environment variables or certificate bundle.
In editors, distinguish local from remote extension hosts
An editor's webview, extension host, and integrated terminal may each have separate network settings. First confirm where the extension runs, then check whether user, workspace, or remote settings take effect. After changing settings, reload the relevant process as required by the app. Test a regular request in a blank workspace before opening the project. If only one repository fails, check project-level overrides and organization policies instead of repeatedly changing global settings.
Test CI on the actual runner
Connections from a continuous integration environment originate on the runner, not the computer that submitted the code. First confirm that the hosted or self-hosted runner meets the provider's regional requirements and your organization's outbound access policy. Have an administrator configure approved destinations and egress routes. Use the platform's secrets management to limit credentials to the projects and jobs that need them. Jobs running untrusted changes must not receive those credentials or print the execution environment in logs.
Check general connectivity, a minimal API call, and the business task separately, and report the stage at which each fails. Set an overall time budget for every job, limit concurrency and retries, and apply a suitable shared scheduling policy to batches of tasks. If failures occur only during scheduled batch runs, check whether many tasks start at once or compete for the same quota. A useful build report includes sanitized status, stage, and task ID—not full request headers.
If a pipeline fails but local testing succeeds, compare inherited environment settings, certificates, the selected project, and outbound rules on the runner. Don't rerun a production deployment immediately after changing network settings. Start with a diagnostic job that uses no production data. Once it passes, restore the normal workflow and document the configuration in a controlled deployment guide so future maintainers don't mistake temporary test settings for permanent requirements.
Rate Limits, Risk Controls, and Account Suspensions
Read the rejection reason before deciding whether to retry
A clear response from a service means that the request reached a layer able to return a response, though it may be an enterprise gateway rather than the target app. Read the error body, relevant response headers, and official guidance to distinguish invalid credentials, insufficient permissions, exhausted quota, a temporary burst limit, or an upstream outage. Don't switch routes just because the interface says “Try again later,” and don't apply the same retry policy to every error.
Short-term limits often depend on request frequency, concurrency, or the size of the input and output. Reaching a total usage or balance limit may require waiting for a quota reset or asking an administrator. Include background jobs and interactive requests for the same project in your investigation. You may click once in the interface while several automated jobs submit requests in the background. Pause nonessential jobs, check project usage and the scope of the limit, then decide when to resume.
If the service returns Retry-After, follow its guidance and include the wait in the overall task timeout. If no wait is specified and the provider allows retries for a temporary error, use progressively longer delays with random jitter so jobs don't all retry at once. Set a retry limit and return the error to the caller when the budget is exhausted. Fix credential or permission errors first; retries won't resolve them on their own.
Reduce overlapping requests
When investigating a sudden burst of requests, check whether the interface triggered an action more than once, the client and gateway are both retrying automatically, or a timeout led to the same task being submitted again. Centralize retry decisions in one layer, and stop downstream retries after a clear rejection. Use a task queue to limit concurrency and retain a correlation ID for repeated operations so you can check whether a task was already accepted.
For long-running tasks, reduce unnecessary conversation history and repeated uploads. Where appropriate, cache reusable static results that contain no private information rather than sending the same query through multiple concurrent jobs. For sustained workloads, use the provider's approved quota request or upgrade process. Don't evade limits with extra accounts, rotating exit routes, or shared credentials. Access routes and third-party API quotas are separate issues.
Handle account restrictions through verification and appeals
If you see an unusual sign-in alert, a request for additional verification, or a suspension notice, stop automatic retries and confirm the notice really came from the service provider. Unusual activity can be related to shared credentials, unintended automation, inconsistent account details, or use that violates the terms—but the error message alone can't confirm the cause. If the provider's official notice requests more information, follow its instructions. Don't create a new account to continue the activity that was suspended.
If you suspect credentials have been exposed, immediately pause related jobs and revoke or rotate the credentials using the provider's process. Check repository history, build output, and other places where they may have been recorded. Give official support a sanitized time range, request ID, and entry point; don't submit information that can restore a session. In a team environment, notify the project administrator too, so people don't take conflicting actions in response to the same incident.
Before resuming, confirm the restriction has been lifted and test with a small job at low concurrency. If the same rejection appears, keep the evidence and don't keep increasing request volume to verify it. Put actionable changes in the job configuration—for example, retry only transient errors, follow the provider's wait instructions, and pause the queue if entitlements change. Preventing repeated restrictions means controlling task behavior and following the rules, not hiding how the service is used.
Connection Verification, Review, and Issue Handoff
Create a verification record you can reuse across devices
For routine checks, work through the entry point, identity, task, and result in order. Open a supported product entry point and confirm the current account or workspace. Send a short request without sensitive information, confirm the output is complete, then test only the attachments, streaming, or editor features you actually need. Record what you observed rather than just checking boxes: for example, whether the right project appeared after sign-in, whether streaming reached its end event, and whether non-text results loaded.
When testing on another device, keep the test action unchanged and record the device's network and split-tunneling mode separately. VPNI6 supports Windows / macOS / iOS / Android / Linux, with unlimited simultaneous devices. This describes VPNI6's client and device support; it doesn't mean third-party accounts allow the same usage. In a shared work environment, everyone should use an authorized identity. Don't swap personal credentials for comparison tests.
If you haven't installed a client yet, follow the getting started guide to sign in to the user panel, get your subscription, and verify connectivity. If you're connected but route behavior differs significantly, check candidate routes on the global locations page and compare them using this guide's split-tunneling steps. If the issue concerns VPNI6 subscription traffic or billing periods, check the plans page for billing and traffic details. Don't confuse your VPNI6 subscription status with usage quotas on external AI platforms.
Find the right person to contact for each symptom
If the same device can't connect to multiple destinations, contact VPNI6 about the connection issue and include the platform, selected route type, mode, time of the issue, and comparisons you've tried. If only a work organization entry point or plugin is affected, ask your administrator to check authorization, gateways, and managed certificates. If one AI platform returns an account or quota error, contact that platform and include a request ID they can check. Don't ask VPNI6 support to change third-party permissions.
Sanitize screenshots and logs before sharing them. Keep the original error, the action you took, the displayed status, and whether the issue reproduces consistently. Don't attach full subscription URLs, API credentials, session data, private documents, or customer prompts. For internal code issues, try reproducing the problem with a minimal example. If it only happens in a real project, use a support channel approved by your organization's data-handling rules; don't upload the entire workspace just to reproduce it.
After a fix, rerun the same action
When you receive troubleshooting advice, first return to a clearly documented baseline, then make one suggested change. Rerun only the shortest failing action from your notes, then check the original workflow. If the original issue involved long output or batch concurrency, one successful short prompt isn't enough. Restore the workload gradually within the permitted limits and watch for failures at the same stage. If a new issue occurs elsewhere, record it separately instead of replacing the original description.
When a short-term comparison is done, remove temporary routing rules, debug output, and test credentials you no longer need. The useful long-term record for a team is approved configuration and verification steps—not a screenshot of settings that happened to work on one device. If a provider changes regional or permission requirements, update the relevant documentation so colleagues know when to check the provider and when to check their local environment. Record when a result was verified so an old test isn't mistaken for a current guarantee.
For remote collaboration, test the entry point your colleagues actually use; a chat website loading doesn't verify video meetings or file sharing. Different tasks are affected differently by packet loss and latency. Use the guide to choosing routes for remote work to create separate verification steps. If you need help with a VPNI6 connection issue, submit a support ticket through the user panel. Describe the first failure separately from your most recent retest.