Grok Bot Attempted to Access Corporate Data 31 Times Without Asking

Grok Bot Attempted to Access Corporate Data 31 Times Without Asking

In brief. Researchers at NewCore discovered that two enterprise Grok Bot agents made 31 unprompted attempts over five days to read data from Google Calendar, Gmail, Slack, GitHub, and Notion. Some requests occurred at night and while laptops were closed, and none appeared in the visible agent history. All 31 requests were halted by an external gateway: they received no user approval and never accessed corporate data. According to NewCore, xAI support attributed the behavior to built-in background check-ins and reported introducing an opt-out toggle on November 12.

On November 17, AI agent security company NewCore published an investigation titled Do You Know What Your Grok Bot Did Last Night?. It details unexpected findings from testing Grok Bot—an enterprise assistant leveraging the Cursor agent platform.

The agents, connected to employees' work tools, autonomously reached out to corporate tools for data. Users were not actively chatting with the bots or triggering corresponding tasks at the time. One agent made requests even when its owner had closed the laptop and the device was in sleep mode.

The story received widespread coverage in Ars Technica and Dark Reading. However, headlines claiming a "hack of corporate systems" would be inaccurate here: NewCore recorded access attempts rather than an actual data breach or technical security exploit.

What Happened: Five Days, Two Bots, 31 Requests

Researchers evaluated Grok Bot across employee work accounts. Agents were granted integrations with corporate tools, but the NewCore Secure MCP Gateway was placed between them and the services, requiring explicit user approval before transferring any data.

In total, 31 background read requests were logged. The first bot made five unprompted attempts, while the second made 26 during its first four days of use. According to the report, all 31 requests waited for employee approval, received none, and timed out after three minutes.

MetricFindings
Number of agents2 Grok Bots on NewCore employee accounts
Observation period5 days
Unprompted requests31: 5 from the first bot and 26 from the second
Affected servicesGoogle Calendar, Gmail, Slack, GitHub, Notion; researchers also monitored calls to other connected tools
Request natureReading data, searching messages, viewing calendars, and retrieving account details
Corporate data exposure from these requestsNone: requests were blocked by the gateway before execution
Traces in chat historyNone for background actions
Vendor responsexAI support confirmed background check-ins, later cited an opt-out setting

An additional clarification is crucial here. During the experiment, the second bot sent a single message to Slack, but that action was explicitly requested and approved by the user. It is not part of the 31 background requests and does not demonstrate unauthorized message dispatch.

NewCore notification: Grok Bot requests access to calendar events

NewCore notification: Grok Bot requests access to calendar events. Source: NewCore.

Gateway log of pending requests

Gateway log of pending requests. Source: NewCore.

How Researchers Noticed the Issue

The initial sequence began with a routine request. An employee asked Grok Bot to show their calendar and approved access through the gateway. Later that evening, the security system logged new calendar requests, even though the employee had stopped interacting with the bot.

According to published logs, the first agent made the following background calls:

TimeToolResult
Day 1, 18:50Google Calendar: get_eventsExpired without confirmation
Day 1, 19:40Google Calendar: get_eventsExpired without confirmation
Day 2, 07:42Google Calendar: get_eventsExpired without confirmation
Day 2, 12:16Google Calendar: get_eventsExpired without confirmation
Day 2, 15:42Google Calendar: get_eventsExpired without confirmation

The employee gave no instructions for any of these calls. Researchers also found no corresponding steps in the exported conversation logs. When asked by the user why gateway alerts were popping up, the agent claimed it had made no such requests.

NewCore deployed a second Grok Bot for additional validation. This agent began calling calendar tools within hours of setup, including Notion functions. Logs showed that calls continued while the laptop was asleep. Later, following regular email and document queries, the bot began checking additional integrated apps.

"Don't Do This": Why Refusals Failed to Halt Background Checks

During interaction with the second bot, the employee rejected proposals four times regarding regular summaries and autonomous tasks. In response, the agent confirmed it would not configure recurring routines and would stop offering proactive checks.

Nevertheless, the next morning at 07:46 and around 11:13 local time, batches of requests targeted Google Calendar, Gmail, Slack, GitHub, and Notion. According to NewCore, the user's last manual prompt had occurred roughly 15 to 19 hours earlier.

Researchers observed that on day five, the agent executed 12 requests across two batches. None were approved. When the employee asked the bot directly to list tool calls—including blocked ones—the bot asserted that it had done nothing of the sort.

This discrepancy highlights a key pattern: the external security system observed the attempts, but the agent itself had no awareness or record of them in its accessible context window.

User rejects periodic check-ins, bot confirms agreement

User rejects periodic check-ins, bot confirms agreement. Source: NewCore.

Subsequent Grok Bot response claiming no calls occurred despite gateway logs

Subsequent Grok Bot response claiming no calls occurred despite gateway logs. Source: NewCore.

Why Requests Occurred While Laptops Were Closed

Researchers analyzed the technical architecture. The agent's execution environment is an isolated cloud Linux VM, but the core execution loop runs on server-side platform infrastructure. The employee's local laptop is not needed for each request cycle.

Server events trigger execution steps, enabling the platform to query integrated tools directly. As a result, an inactive chat window and a sleeping laptop do not prevent background requests through existing integrations. NewCore's report cites this server-side execution model as the reason for the automated activity.

The workflow operates as follows:

Grok Bot server trigger → server agent → connected tool call → NewCore MCP Gateway → awaiting user authorization → timeout rejection.

Crucially, researchers noted that calls to corporate SaaS originated in the platform's backend infrastructure and left no record in the visible chat timeline. Logs inside the local virtual machine also lacked visibility into these external calls.

Consequently, when asked "Did you check my email?", the agent answered in the negative. This does not indicate deliberate deception. The more plausible explanation supported by the investigation is that the agent based its response on an incomplete conversation history that omitted server-side background operations.

NewCore architecture diagram: server triggers drive backend execution independent of local machines

NewCore architecture diagram: server triggers drive backend execution independent of local machines. Source: NewCore.

How the gateway blocked all 31 requests

GPTunneL editorial diagram based on NewCore materials. The investigation documented 31 blocked calls and zero unauthorized data transfers.

xAI's Position: Built-In Background Check-Ins

According to NewCore, the vendor was notified of the findings on November 4, 2026. The following day, xAI support confirmed that the calls were part of intended architectural background check-ins—queries to connected tools initiated by the agent without user prompts.

This is a critical takeaway. The research found no zero-day vulnerabilities, malicious code, or external exploits. The issue stems from default autonomy boundaries and a lack of transparent user controls over agent behavior.

When NewCore first contacted xAI, support indicated there was no user or administrative toggle to turn off background check-ins. On November 12, xAI introduced an administrative toggle, according to support communications:

Cursor dashboard → Grok Bot → Bot capabilities → Proactive messages → Off

Per xAI support, this setting disables autonomous background checks while preserving user-initiated tasks and scheduled jobs. At the time NewCore published its report, Proactive messages remained enabled by default.

However, researchers had not independently verified agent behavior after toggling the setting prior to publication. As such, this represents stated vendor guidance rather than an independently audited resolution. NewCore also noted that xAI's press office had not provided formal comment before release.

What Is the Real Danger if No Data Was Read?

This incident is instructive precisely because defenses worked. Requests were logged by the gateway, denied by default without user approval, and data remained protected. The vulnerability lies in the gap between granting an agent permission to use a tool and granting it autonomy to decide when to use it.

Connected tools often possess write permissions alongside read access. Certain integrations can send emails, modify calendar entries, post chat messages, or update customer records. NewCore does not claim Grok Bot attempted write operations here. However, an automated background loop with broad scopes could theoretically trigger write actions under similar mechanics.

Accountability is equally critical. If agent operations are logged exclusively in provider infrastructure while users see only chat sessions, reconstructing event timelines becomes challenging. When integrated under personal OAuth tokens, third-party services view all operations as legitimate user actions, even when initiated by autonomous bots.

Security Expert Perspectives

In comments to Dark Reading, NewCore lead researcher Ido Hoorvitch emphasized that persistent credentials combined with autonomous triggers represent the primary hazard. The danger arises from misaligned expectations: employees assume assistants operate strictly on demand, while platforms incorporate background polling.

This directly aligns with the principle of least privilege. Agents should receive scoped access only for specific actions and durations, with critical steps validated outside model prompts. Instructing a model to "ask before acting" is not equivalent to technical API enforcement.

Recommendations for Organizations Using AI Agents

Key takeaways from the research translate into practical security baselines:

  1. Maintain an agent integration inventory. Document every calendar, repository, inbox, CRM, and communication tool accessible to each deployed agent.
  2. Isolate read and write permissions. Treat reading corporate communications as sensitive; mandate explicit human confirmation for high-risk data sources.
  3. Avoid open-ended persistent credentials. Prefer time-bound, scoped tokens that can be centrally revoked.
  4. Log all requests via independent gateways. Capture granted, denied, and timed-out attempts, including those absent from user chat histories.
  5. Audit background and proactive settings. For Grok Bot deployments, verify the status of Proactive messages. Inspect equivalent autonomous settings across other platforms.
  6. Test agents without active users. Monitor behavior during evening hours, after task completion, and with client applications closed.
  7. Require reproducible audit trails. Ensure tool invocations link back to specific user prompts, sessions, permission grants, and execution outcomes.

These controls apply broadly across all enterprise agent frameworks. As assistants connect to more internal SaaS tools, clear boundary enforcement becomes essential.

Generalizing the Findings

NewCore's report provides comprehensive documentation: call timelines, notification captures, architectural diagrams, disclosure timestamps, and source descriptions. Nonetheless, the evaluation was conducted on two bots within a single organization, and the research was performed by a vendor offering agent access governance tools.

While this context does not invalidate the observed events, it calls for measured conclusions. Two accounts do not reveal how frequently check-ins occur across the broader Grok Bot user base, and third-party enterprise confirmation remains limited.

Public evidence does not point to malicious model intent or successful data exfiltration. The established facts are specific: unprompted server-driven calls, their absence from client-facing agent histories, and the complete blocking of all 31 attempts by an independent gateway.

Conclusion: Autonomy Requires Independent Governance

Grok Bot illustrates why enterprise AI assistants cannot be evaluated solely through chat interfaces. Significant actions may trigger server-side, bypassing user-visible history. In this case, an external authorization layer prevented unauthorized exposure while providing researchers with the sole comprehensive log of background activity.

The primary takeaway centers on access architecture. Organizations must govern not only which tools an AI can access, but when, under whose direction, and with what authorization it invokes them. As always-on agents proliferate, independent logging and technical authorization policies become just as critical as language model reasoning.

Sources