[ Your personal data layer. Sign in once. Every app inherits. ]
Integrator is the data + identity layer underneath the polistician.ai apps. Authorize each source — ChatGPT, Garmin, Google, your bank, your weather, your screen time — once against a layer you own. Every app you sign into with Integrator inherits scoped access. No per-app re-auth, no second subscriptions.
8 sources live · 5 apps inheriting · more sources soon
Three steps. One layer. Every polistician.ai app inherits scoped access automatically.
-
01
Sign up
You get a console — your data layer, owned by you, hosted on one box.
integrator.polistician.ai/console/signup.html -
02
Connect your sources
Each one authorizes once against the layer, not against every app.
integrator.polistician.ai/console/sources.html -
03
Sign into any polistician.ai app with Integrator
It inherits scoped access, automatically.
POST /api/v1/data/{provider}/{resource}· OAuth 2.1 + PKCE
Every app you use already wants the same data. You authorize the same integrations over and over. That’s backwards.
Today every fitness app rebuilds Garmin OAuth. Every Mac productivity app re-reads knowledgeC.db. Every nutrition app asks for a fresh Google grant. Every “AI” app asks you for an OpenAI API key — on top of the ChatGPT subscription you already pay for. The data is the same. The user re-authorizes endlessly. Every app keeps its own token vault, its own rate limiters, its own broken-source dashboard.
The inversion: you authorize once, against a layer you own. Apps subscribe to data streams from that layer. The OAuth, the polling, the encryption, the schema, the health monitoring — all in one place. Integrator already does this for your ChatGPT subscription, for Garmin, for Google, for Apple Screen Time. Token expires, the layer refreshes once. New integration ships, every Integrator-aware app gains it for free.
The status quo is a thirty-app permissions sprawl, with a parallel sprawl of API keys you mint and forget. Integrator is one place to look, one place to revoke, one place to see what is feeding what.
Sources on the left. Apps on the right. Integrator is the layer in between.
ChatGPT is the live source today. Pair your Plus or Pro subscription once on Integrator — HablaDaily, MacSweep, MacroDaily and VoiceType already broker chat completions through it, billing your existing subscription. The dimmed nodes are connectors that exist in the codebase (Garmin, Google, Screen Time, DKB, Supernote, Weather) but are not yet exposed to subscriber apps. They’ll come back online once the ChatGPT product surface is locked.
The Weather connector is 36 lines. That’s the bar. Drop it into connectors/; the system finds it; the data page renders it.
wc -l
1 """Weather — current conditions and daily forecast via Open-Meteo."""
2
3 NAME = "Weather"
4 DESCRIPTION = "Current conditions and daily forecast for your location"
5 CATEGORY = "environment"
6 MODE = "poll"
7 AUTH_TYPE = "none"
8 SCHEDULE = "every 1h"
9 DEFAULT = True # Always-on — no activation needed
10 TABLES = {
11 "current": "sight_weather",
12 "daily": "sight_daily",
13 }
14
15 DETAILS = {
16 "value": "SOMA knows your local weather — "
17 "temperature, sunrise/sunset, UV index. "
18 "It factors this into daily insights.",
19 "data_points": [
20 "Temperature (high/low)",
21 "Precipitation",
22 "Sunrise and sunset times",
23 "UV index",
24 "Weather conditions",
25 ],
26 "prerequisites": [],
27 }
28
29
30 def collect(credentials, since):
31 """Fetch weather data. Delegates to the existing weather module."""
32 from backend.integrations.weather import sync_weather
33 sync_weather(credentials.get("user_id", ""))
34 return []
35
36 def summarize(records): return ""
Every record looks the same. The shape is the contract; the connector’s job is to produce it.
{
"type": "sleep",
"timestamp": "2026-04-30T22:14:00Z",
"data": {
"deep_min": 92,
"rem_min": 68,
"light_min": 214,
"score": 78
}
}
Three keys. type, timestamp, data. Every record from every connector. Sleep, an email subject, a calendar event, a screen-time session, a portfolio balance — same shape, different data.
The shape lets the framework store records into the connector’s declared TABLES, compute health from the event bus, and serve a generic data view at /api/integrations/data/{source}?days=N — without the connector author writing UI code. Known schemas get optimised charts; unknown ones get a JSON+table renderer.
Tokens are Fernet-encrypted at rest in integrations/crypto.py. Connectors decrypt server-side to make API calls — by necessity. I do not claim end-to-end encryption.
Four states, derived from the event bus — not a last_sync timestamp.
A connector that runs hourly and silently returns zero records every time looks healthy by timestamp but is actually broken. The layer reads from the soma_events bus instead. Every collector run emits collector:<slug>:sync with a {records, error} payload. The four states fall out of joining that stream against the active connection.
Health is decoupled from the connector. A connector can fail to update its own state; if it emitted the error, the layer sees it.
| ok | stale | error | null | |
|---|---|---|---|---|
| poll | Garmin · 412 rec / 24h | Google · 0 rec, 28h | DKB · auth failed | Whoop · not connected |
| webhook | Calendar · 28 events | Calendar · channel expired | Calendar · 401 on push | — |
| push | Screen Time · 14m ago | Screen Time · macOS asleep | Screen Time · token expired | Screen Time · agent uninstalled |
| sync | Supernote · .note delta | Supernote · 5d quiet | Supernote · drive 403 | Supernote · not paired |
Three modes are wired today; sync is in the prototype as a fourth. poll for Garmin, Weather, Google. webhook for Calendar push. push for the Screen Time agent that reads knowledgeC.db and POSTs to an ingest endpoint, capturing macOS plus iOS via Apple’s Share-Across-Devices. sync is the Supernote pattern: a remote bucket the layer pulls from on a cadence.
The killer feature. Your apps call POST /chat/completions; Integrator brokers it through your ChatGPT subscription, no API key required.
# subscriber app (HablaDaily, MacSweep, your app, …)
POST https://integrator.polistician.ai/api/v1/chat/completions
Authorization: Bearer <integrator-app-token>
Content-Type: application/json
{
"model": "gpt-5",
"messages": [{ "role": "user", "content": "…" }]
}
↓ audit · scope check · per-app rate limit
# integrator → user's ChatGPT subscription (server-side)
POST https://chatgpt.com/backend-api/codex/responses
Authorization: Bearer <user's codex access token>
↓ bills user's existing Plus / Pro subscription
# subscriber app receives a vanilla OpenAI-shaped response
{ "choices": [{ "message": { "content": "…" } }] }
Eight sources live today. Each authorized once against your layer.
- chatgpt — Your Plus or Pro subscription, brokered.
- dkb_bank — Transactions and balances from your bank.
- garmin — Sleep, activity, body-battery, recovery score.
- google — Calendar events and Gmail threads.
- groq — Fast inference fallback for LLM calls.
- screentime — App usage from your Mac and iOS.
- supernote — Handwritten pages from your Supernote.
- weather — Local current conditions and daily forecast.
Five apps inherit from this layer today. Sign in once; they get scoped access automatically.
- MacroDaily — Food logging that reads your weight and activity.
- HablaDaily — Spanish drills that broker ChatGPT through your subscription.
- MacSweep — Screenshot triage using your subscription, not an API key.
- VoiceType — Mac-wide dictation routed through Integrator.
- SOMA — Personal analytics — the original consumer of this layer.
Where Integrator doesn’t sit: not workflow automation, not an LLM tool protocol, not a finance-only integrator, not your status-quo OAuth sprawl.
| Integrator | Zapier / Make / n8n | Anthropic MCP | Plaid | Status quo (every app rolls its own) |
|
|---|---|---|---|---|---|
| Primitive | Identity + data + LLM-subscription layer | Workflow automation | LLM tool protocol | Finance data | App owns OAuth + API key |
| ChatGPT subscription brokerage | Yes — the headline feature | No | No | No | No (each app re-mints API keys) |
| Who authorizes | The user, once, against a layer they own | The user, per zap | The agent | The user, per bank | The user, per app |
| Who owns the tokens | The user, Fernet-at-rest, your server | Zapier | The MCP server | Plaid | Each app |
| Cross-vertical | 7 sources · 6 categories | Generic | App-driven | Finance only | N/A |
| Connector authoring | Drop a .py file |
Web UI, vendor-built | Spec, vendor-built | Plaid only | Each app reinvents |
| Status | Live. 4 apps brokering ChatGPT today. | Mature | Mature | Mature | The status quo |
Zapier sits between apps to chain actions. Integrator sits underneath apps to serve the same data — and the same ChatGPT subscription — to all of them. MCP is how a model talks to a server; Integrator is how a person consolidates connections across apps. Plaid is the right shape, vertical-locked to finance; Integrator generalizes the pattern across body, mind, schedule, finance, social, environment, and your LLM subscription.
The honest list. I cut these on purpose; they aren’t on a roadmap I want to set right now.
- ×No public connector marketplace. The tier directories (
connectors/,connectors/community/,data/connectors/{user_id}/) exist by convention. The publishing flow does not. The marketplace is the path, not the present. - ×Not Zapier-like workflows. Different primitive. Integrator does not chain triggers and actions; it serves data streams. “When Slack message → write to Notion” is Zapier’s job.
- ×ChatGPT brokerage is subscription-auth only. That gives you
gpt-5. Whisper, DALL-E and embeddings still need an API key — we route those through BYOK as a fallback, but it is not the headline. - ×No Anthropic / Gemini brokerage yet. Codex is the only LLM subscription with a paste-URL OAuth shape we trust. Anthropic could ship one; we’ll wire it the day they do.
- ×No granular per-app scope UI yet. Per-source works today. “HablaDaily can see study time but not email” is wired in the protocol; the console toggles ship next.
- ×No end-to-end encryption claim. Tokens are Fernet-encrypted at rest. Connectors decrypt server-side to call APIs. That is the truthful claim.
Every app in my own portfolio was rebuilding the same Garmin OAuth, the same Google grant, the same OpenAI API key. So I wrote the layer once and lifted it out.
I run several apps for myself — SOMA, HablaDaily, MacroDaily, MacSweep, Sierra. Each wanted Garmin sleep data. Each wanted a Google grant. Each wanted to read my Mac’s screen-time database. Each wanted to call ChatGPT — and each kept asking me to mint another API key on top of the Plus subscription I already pay for. I rebuilt this stack three times before I admitted what was happening: identical tokens in different sqlite files, the same user authorising the same source over and over, three places to debug when an upstream hiccuped, two ChatGPT bills.
So inside SOMA I wrote the integrations layer once, with the explicit intent to lift it out. Then I lifted it out. Now four apps in my portfolio — HablaDaily, MacroDaily, MacSweep, VoiceType — broker their ChatGPT calls through it, against my one Plus subscription. That is the page you’re reading.