Connect a data source

A connector mounts an external source read-only into your project's /workspace/connectors/<mount_prefix>/. You register it once, refresh it to pull content, and from then on any agent on the project reads the files with sh. The connection lives in the core — scoped to the project and audited like everything else — not scattered across scripts. For the concepts behind it (project scoping, how auth is handled), see About connectors.

Register and materialise

connector.add registers the instance; it does not fetch. connector.refresh materialises it into the workspace. For a GitHub repo:

connector.add {
  "account_slug": "acme",
  "project_slug": "demo",
  "connector_name": "github",
  "mount_prefix": "app-repo",
  "config": { "owner": "acme", "repo": "app", "ref": "main" },
  "credentials_ref": "acme-app-gh"   // resolves to a stored credential
}

connector.refresh {
  "account_slug": "acme",
  "project_slug": "demo",
  "mount_prefix": "app-repo"
}

The agent can now read the tree immediately:

sh "ls /workspace/connectors/app-repo/"
sh "cat /workspace/connectors/app-repo/README.md"

A Postgres source uses the same shape with connector_name: "postgres"; it dumps schema and tables as CSV into the workspace so the agent reads them without a live database connection.

Connect an OAuth app (Notion, Linear, GitHub, Slack, …)

SaaS tools connect with a sign-in, not a credential you paste. Two ways to start one:

• From the dashboard — /a/<slug>/p/<project>/connections → Add connection → pick the provider. The provider's sign-in opens in a new tab; finish it there and come back — the Connections page notices the completed sign-in by itself and shows the new connection as active. No callback to wait for, no reload.
• From Zero — say "connect Notion". Zero creates the connector and answers with a card that carries Continue to Notion; the sign-in opens in a new tab and, once it lands, the conversation says Notion is connected. Asking again later mints a fresh link (a sign-in link expires); it never creates a second connector.

A connector whose sign-in has not happened yet shows on the Connections page under Awaiting your sign-in with an Authorize button, so nothing is ever left "pending" somewhere you cannot see. Once connected, every agent on the project can use it and Zero lists it as authorized; the connection's sync state — whether its content has been materialised into the workspace yet — is separate from its authorization and shown on its card.

Connect X with your own X app

X bills the app that calls it, per call, and gives one developer account three subscriptions in total — so connect0 uses your X app rather than a shared one. Add connection → X opens a short intake that walks you through these steps in the X developer console:

1. Create an app. Open Projects & Apps and create an app, or open the one you already have. X bills this app for every call connect0 makes.
2. Turn on OAuth 2.0. In the app, under User authentication settings, choose Set up. Set App permissions to Read and write (Read is enough if the account only monitors) and Type of app to Web App, Automated App or Bot.
3. Paste the callback URL and your website. Under App info, set Callback URI / Redirect URL to exactly the address the intake prints, and Website URL to your company site. Save.
4. Copy the OAuth 2.0 Client ID and Client Secret. X shows them once, when you save; Keys and tokens regenerates them. Paste both into the intake — they are stored encrypted and never shown again. The API Key, API Key Secret, Bearer Token and Access Token on the same page are not used.
5. Choose the scopes. Every scope says what it buys; the only one you can drop is tweet.write — untick it if this account only monitors, and the posting skills are never offered to an agent.
6. Continue to X and sign in as the account you want connected.

Afterwards the connection page shows what X has been observed to cost this month; X's console is the authority. Mentions of the connected account reach your agents every two minutes; content X removes is removed here within a day.

Posting. An agent never posts on its own: a post, a reply or a deletion appears on the connection page as a proposal — the exact text, the cost (a post with a link costs X $0.20 instead of $0.015) — and a person posts or rejects it. An account owner may mark one connection a trusted publisher: original posts then go out unattended, at most a set number a day, while replies and deletions are still confirmed, and the same text cannot be posted twice in 24 hours from any of your X connections.

Keyword rules. An owner or admin can watch a keyword — a term, a brand, a product or your own handle — and every public post that matches reaches your agents within seconds through X's Activity API (X charges $0.005 per delivered post; three rules per connection). Rules that track individuals or monitor events are not allowed under X's terms and are refused.

What you get

• One place for the connection. Register once; every agent on the project reads the same materialised view.
• Read-only by default. Connectors pull in; the source is never mutated.
• Governed. Access is scoped to the project and audited. Check what's mounted anytime with connector.list.

Where to go next

• Create an agent that acts on the source you just connected.
• The public MCP server to run the connector.* tools from an external MCP client.