# Objects and skill runs

A customer or a project, made of the items you link to it from your connections, such as a Linear project, a Notion page or a Trello card. A skill can then read those items through your own access and save a result that cites each one, with a receipt of the run. Open them in the dashboard under **Objects**.

This is early and small: two kinds (customer, project), links you add on purpose, `object-brief`, and your own skills that declare a brief (below). It is not a knowledge graph, it doesn't find or match records on its own, and it doesn't sync anything.

## How it goes

1. **Connect** the services, as usual ([Connections](/docs/connections)).
2. **Make an object and find the items.** In the dashboard, **Objects › New**; or an AI app connected to your bridge does it and looks for the items with the services' own tools.
3. **Link** them to an object: in the dashboard, **Link an item** (pick one of your connections and its read tool, give the item's id, **Check item** to see what it reads, say why it belongs, **Link**), or `bridge__object_create` and `bridge__object_link` from an AI app. Each link names the read tool and arguments that read that one item, and says why it belongs (`evidence`). 0bridge reads the item through your connection first, so only something you can read gets linked, and keeps its service, id, title, address and last update.
4. **Relate objects** when one belongs with another: on an object's page, **Relate an object** (pick another customer or project of the same workspace, say what it is to this one, such as `project` or `parent`, and why), or `bridge__object_relate` from an AI app. Both objects show it, each from its own side. Like a link, it needs a reason, and only objects of one workspace can be related. Whoever added it, or a workspace owner or admin, removes it (`bridge__object_unrelate`); both objects stay.
5. **Run a skill** on the object: **Run** on its page, or `bridge__skill_run skill=object-brief`. It reads each item again with its read tool, never with a tool that changes data, and saves one Markdown brief in the object's Drive folder (`<folder>/briefs/`).
6. **Check the record.** The run's receipt shows the skill's version and the skill's hash (object-brief: the sha256 of its built-in text; a skill of yours: the sha256 of its SKILL.md and files), the connections it needed, what it was allowed to do, what happened to each source, and the file it saved.

The dashboard runs the same tools as you, with the same checks. In Claude, ChatGPT and coding agents they are found with `bridge__search` and run through `bridge__execute` (reads) or `bridge__execute_write` (changes), like any other tool on your bridge. They aren't in the older one-tool-per-name lists.

## What stays out

- **Nothing is merged by name.** Making a customer that has the same name as one already there is refused until you say it's a different one (the dashboard's checkbox, or `same_name: true`), and a link needs a reason.
- **Your access, every time.** Reads go through the reader's own connections with the usual checks: tools you turned off, read-only connections, a token that only reads, the Free plan's calls. In a team workspace, an item another member linked through their own connection shows only that it's there and what it is to the object, not its title, address or id, and your runs list it as not read.
- **One file, nothing else.** `object-brief` saves its brief and changes nothing in your services. What the services return is quoted in the brief as data, not instructions.

## Your own skills on objects

A skill of yours, or your team's, runs on objects when its SKILL.md says what brief it makes, in its front matter:

```yaml
---
name: renewal-brief
description: What we know before a renewal call.
version: "1"
object-brief:
  kinds: [customer]            # objects it runs on (default: both)
  relations: [account notes]   # links it reads (default: all); the others are skipped
  sections:                    # a heading per relation, in this order
    account notes: Account
  quote: 300                   # characters quoted from each item, 100 to 2000 (default 1200)
---
```

It then shows under **Run a skill** on an object's page (team skills as `<team>--<name>`, for the team's members), and `bridge__skill_run` takes its name. The declaration is data: 0bridge runs the same brief with it, nothing in the skill is executed, and it can't add tools or writes. Each run's receipt names the skill and its hash (the sha256 of its SKILL.md and files), so an edited skill shows up as another hash. Quote `version` (`"1.10"`) so it stays as written. A skill without `object-brief:` stays instructions for your AI apps.

## Run outcomes

| Outcome | When |
|---|---|
| Done | Every linked item was read and the brief saved. |
| Partly read | Some items were read; the brief lists the others with why: no access, disconnected (the connection isn't in your list now, or its tools are off), refused, or failed. |
| Failed | Nothing could be read, or the brief couldn't be saved (a team whose subscription lapsed can read objects but not run them). |

Pass `key` (your id for the run, such as the chat message's id): the same key again returns the first run's receipt without reading again, but only to whoever ran it and while the skill's hash is the same; another member's run, or an edited skill, needs a new key. The dashboard sends a new key with each click.