A head of engineering opens ChatGPT on a Tuesday to sanity-check a migration plan. The plan is in a Google Doc, referenced in two Linear epics, tracked in a Jira migration board, and has five active Sentry incidents tagged against it. The question she wants to ask is simple and impossible for any one of those tools: "Against the commitments my team declared about this service last quarter, is the current migration plan still consistent, or have we quietly contradicted something?" Answering that question used to mean convening three people and reconstructing context from memory. Now it is a single ChatGPT conversation, because the tools have become connectors and the commitments are queryable.
The ask-across-tools pattern is what ChatGPT's MCP connector support unlocks. What makes it a real cockpit rather than a cross-tool search is whether the "against our commitments" dimension is present. That dimension is Ribo.
The cross-tool chat is a real workflow now
ChatGPT's MCP connector support, currently in beta under developer mode, has moved the chat from "ask the model" to "ask the model with everything the team uses plugged in." A single conversation can walk Jira to find the epics, Linear to find the tickets, Sentry to find the incidents, GitHub to read the diffs, and so on, composing across them to answer questions nobody could ask before.
The pattern works. It also has a quiet failure mode. A conversation that reads across five systems can produce a plausible answer that contradicts what the team actually decided, because none of the five systems stores "what the team decided." They store activity. Activity is not intent. Without intent as one of the connectors, every cross-tool answer is grounded in what has happened rather than in what was supposed to happen.
Ribo is the connector that supplies intent. Adding it to the ChatGPT connector list shifts the pattern from "ask across the tools" to "ask across the tools against your declared source of truth."
What changes when ChatGPT can read intent
Ribo exposes a small set of read tools over MCP: search declared artifacts, retrieve a specific artifact, list artifacts in a project, walk the relationships between them. Inside a ChatGPT conversation with Ribo among the enabled connectors, any question about operational data can be paired with a query about declared commitments.
Take the migration scenario. ChatGPT walks Jira for the migration board, walks Linear for the associated tickets, walks Sentry for the incidents tagged against the service. Then, with Ribo connected, it walks the intent and constraint artifacts for the service, finds the tradeoff artifact that declared why the team chose synchronous commits over asynchronous replication, and reads the contract artifact declaring the data-freshness guarantee the service owes consumers. The answer it returns is not a summary of activity. It is an audit: the migration's current plan preserves the synchronous-commit tradeoff, contradicts the data-freshness contract in one specific step, and leaves the constraint on backward-compatible APIs intact except in one Sentry-reported path. That is three specific, actionable findings, grounded in declared intent rather than inferred from tone.
The head of engineering reads the answer, knows which one step to fix, and the conversation that would have taken three meetings took fifteen minutes.
Role-appropriate projection for a cockpit user
ChatGPT's cockpit audience is product, engineering leadership, support leads, and compliance owners. They ask questions across systems and need enough of Ribo's declared identity to make the cross-tool composition meaningful, without needing the authoring-level detail a coding agent would require.
Ribo's DNA splits into thirteen layers: intent, contract, algorithm, evaluation, escalation, pace, monitor, glossary, integration, reporting, compliance, constraint, and tradeoff.
For ChatGPT cockpit use, expose seven: intent, contract, glossary, integration, constraint, tradeoff, and evaluation. Intent is why components exist. Contract is what they promise. Glossary is what the team's words mean. Integration is what external systems are part of the declared architecture. Constraint and tradeoff record what the system must not become and the decisions between competing options. Evaluation is how correctness is measured, which is the dimension most cross-tool questions want.
Withhold six: algorithm, monitor, reporting, pace, escalation, and compliance. Algorithm is authoring-detail, not cockpit-detail. Monitor, reporting, pace, and escalation are operational concerns, better held in an ops-specific cockpit if needed. Compliance can feel counterintuitive to exclude, but we recommend routing compliance questions to a separately-scoped cockpit session with its own token, so the audit log is clean and the trust surface is narrower.
Ribo mints a separate bearer token per integration. One cockpit user, one scoped token. The same organization can run multiple cockpit configurations with different projections, each audited independently.
How to wire it up
Two moves. First, mint the cockpit token in the Ribo console. Go to Agents, create an agent named after the user and their context (chatgpt-cockpit-<user>-<role>). Set scopes to artifact:read. Set projectIds to the Ribo projects this user is authorized to read. Set allowed_kinds to the seven-layer cockpit projection: intent, contract, glossary, integration, constraint, tradeoff, evaluation. Capture the bearer token.
Second, add Ribo to ChatGPT's connector list. A workspace admin needs to enable developer mode first, under Workspace Settings → Permissions & Roles → Developer mode. Once enabled, any user can open Settings → Connectors → Create and add a custom MCP server:
| Field | Value |
|---|---|
| Name | Ribo |
| Description | System DNA: declared intent, contracts, constraints (or your internal phrasing) |
| MCP server URL | https://mcp.ribo.dev/context/mcp |
| Authorization | Bearer token from the Ribo console |
Save the connector. The beta gates some capabilities behind plan tiers and gates write-capable MCP more strictly than read-only; consult OpenAI's connector help article linked above for the current eligibility matrix before rolling out. Admins control whether a connector is available organization-wide or only to its creator. Start with personal access for a pilot; widen to the org once the projection is validated.
Once saved, Ribo shows up in the tool picker at the start of any new chat. Enable it alongside the other connectors you use, and cross-tool questions can begin grounding against declared intent.
What kinds of questions the cockpit can now answer
The questions worth asking are the ones that require composition. A few patterns we see most often in pilots:
Roadmap vs. declared tradeoffs. "For this quarter's Linear epics tagged to the billing service, identify any that propose changes contradicting the tradeoffs declared in Ribo for that service." Output: a list with citations.
Support patterns vs. declared intent. "Among Zendesk tickets this month about export functionality, which are asking for behavior that contradicts the retention intent we declared in Ribo?" Output: a triage.
Incident vs. declared evaluation criteria. "For last week's Sentry incidents on the notifications service, which are happening in paths that declared an evaluation criterion the incident violates?" Output: a prioritized bug list.
Each of these is unanswerable by any one system and trivial for a cockpit that composes across them. Adding Ribo changes "composes across activity" to "composes across activity measured against intent."
What it's worth
The cross-tool chat cockpit is a pattern that has emerged from how teams now use AI tools day to day. It works because teams have more tools than anyone can hold in their head, and a chat that reads across them replaces a meeting that used to reconcile them. The pattern's ceiling is that without declared intent, the chat can only describe activity. Ribo lifts the ceiling by making intent queryable. The conversations that used to produce plausible answers now produce auditable ones.
ChatGPT composes across your tools. Ribo is the connector that turns composition into judgment the team can trust.