Kernel MCP
Kernel MCP gives agents access to Kernel's cloud-browser infrastructure and browser automation capabilities through a hosted OAuth server.
Verdict
Common use cases
- Maintain project context across weekly check-ins
- Store client preferences for future reference
- Build a searchable team knowledge base
- Track decisions made in past conversations
- Resume complex tasks without re-explaining background
Integration
- Vendor
- Kernel MCP
- Category
- other
- Auth
- OAUTH2
- Composio slug
kernel_mcp
Tools
Setup
Setup guide
- 11. Open your Switchy workspace and navigate to Settings > Integrations. 2. Find Kernel MCP in the list and click Connect. 3. You'll be redirected to Kernel's authorization page where you'll log in with your Kernel credentials. 4. Grant the requested permissions — typically read access to memories and write access to store new context. 5. After approving, you'll return to Switchy with a confirmation that Kernel MCP is connected. 6. Open any Project and type '@Kernel' to invoke the integration. 7. Test the connection by asking it to store a simple note, then in a new message ask it to recall what you just saved. 8. If the AI successfully retrieves the stored information, the integration is working correctly.
What teammates see: by default, memories from Kernel MCP are scoped to the Project (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.
Works well with
Top models
Compatibility data appears once enough Projects have used this MCP together with a given model.
How Switchy teams use it
Starter prompts
Store Project Context
@Kernel store the following context from today's planning session: we decided to prioritize the mobile redesign over new features, target launch is Q2, and Sarah owns the design phase.
Retrieve Past Decisions
@Kernel what did we decide about the mobile redesign timeline and who was responsible for each phase?
Build Knowledge Entry
@Kernel save this as a reusable guideline: when onboarding new clients, always confirm their preferred communication channel and meeting cadence in the first call.
Search Team History
@Kernel search our past conversations for any mentions of budget constraints or cost concerns related to the Q1 campaign.
Resume Interrupted Work
@Kernel retrieve the context from our last discussion about the API integration project so we can pick up where we stopped.
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
@kernel analyze error logs from the past 24 hours and identify the top 3 failure patterns with recommended fixes
Analyzed 1,847 error entries. Top failure patterns: (1) Database connection timeouts (34% of errors) — recommend increasing connection pool size from 20 to 40 and reviewing slow queries. (2) Rate limit exceeded on external API (22%) — consider implementing exponential backoff or request queuing. (3) Null pointer exceptions in user profile handler (18%) — likely caused by missing validation on optional fields; add null checks before accessing nested properties. These three patterns account for 74% of logged errors.
This synthesis example combines log retrieval with AI reasoning. The MCP fetches raw log data; the AI performs pattern recognition and generates recommendations. OAuth2 scope must include log read access. Large log volumes may hit rate limits — Kernel MCP typically caps single queries at 10,000 entries. For deeper analysis, consider narrowing the time window or filtering by service.
Use-case deep-dives
When OAuth2 overhead matters more than the tool count
A 3-person founding team running weekly discovery calls with beta users needs to capture insights fast. Kernel MCP uses OAuth2, which means each teammate authenticates once and the workspace stays connected across sessions. The trade-off: OAuth2 adds setup friction on day one, but if your team cycles through 8-12 discovery sessions a month, that one-time auth cost pays off by week two. If you're running a single sprint retro or ad-hoc brainstorm, the setup overhead isn't worth it—use a simpler MCP or manual notes. But for recurring research workflows where the same 2-4 people need consistent access, OAuth2 keeps the workspace ready without re-auth noise. This MCP fits teams that treat discovery as a discipline, not a one-off event.
OAuth2 as the audit trail your legal team wants
A 6-person support ops team at a fintech startup logs customer feedback into Switchy during live chats. Kernel MCP's OAuth2 flow means every action ties back to a named user account, which matters when your compliance officer asks who accessed what customer data and when. The MCP doesn't expose tools yet, so you're trading tool breadth for auth rigor. If your industry requires per-user attribution (healthcare, finance, legal services), that trade-off makes sense. If you're a B2B SaaS team with looser audit needs, a simpler MCP with API key auth is faster to deploy. The threshold: if your security questionnaire asks 'do you log user-level access to customer data,' OAuth2 moves from nice-to-have to table stakes. Kernel MCP gives you that baseline without custom middleware.
When shared workspace auth beats per-person API keys
A 5-person marketing team plans quarterly campaigns in Switchy, pulling in freelance designers and agency partners for 2-week sprints. Kernel MCP's OAuth2 lets each contributor authenticate with their own credentials, so the workspace doesn't break when someone rolls off the project or a contractor's API key expires. The downside: OAuth2 setup takes 10 minutes per person, and with zero tools listed yet, you're betting on future capability. If your team is stable (same 3-5 people for 6+ months), API key auth is simpler. But if you onboard 2-3 external collaborators per quarter, OAuth2 prevents the 'whose key is this' archaeology when access breaks mid-sprint. This MCP fits teams where contributor churn is higher than tool complexity.
Frequently asked
What does Kernel MCP do in Switchy?
Kernel MCP connects your team's Switchy workspace to Kernel's memory and context management system. It lets AI agents store, retrieve, and reason over long-term context across conversations — think of it as giving your team's AI a persistent memory layer that survives beyond individual chat sessions.
Do I need special permissions to connect Kernel MCP?
You'll go through an OAuth2 flow that requires a Kernel account with API access enabled. Most Kernel plans include this, but check your subscription tier before connecting. The OAuth scopes typically cover read and write access to your Kernel memory stores, so whoever connects it should understand what context data your team wants indexed.
Can Kernel MCP search across all my team's past conversations?
It depends on what you've explicitly stored in Kernel. The MCP doesn't automatically index every Switchy message — it only accesses memory objects you've created in Kernel. If you want full conversation history search, you'll need to configure Kernel to ingest those transcripts first, either manually or via Kernel's own automation rules.
Why use Kernel MCP instead of just prompting the AI to remember things?
Prompting alone relies on context windows, which reset between sessions and hit token limits fast. Kernel MCP writes structured memory to an external store that persists indefinitely and can be queried semantically. It's the difference between asking someone to remember everything you said versus giving them a notebook they actually reference.
Who on my team should set up the Kernel connection?
Whoever owns your team's knowledge architecture — usually a technical lead or ops person who understands what context matters long-term. They'll need access to both your Switchy workspace settings and your Kernel account. Once connected, any team member can trigger memory operations if you've granted them the right Switchy permissions.