Hand a card to NEO

There is one action for getting work done on a card: assign it to NEO. Pick NEO in the card’s assignee picker. That is the run — there is no Run button, no Enrich button and no Generate button. NEO reads the card, decides which squad should do the work, hands it over, and writes an account of what the squad did onto the card’s timeline.

To run a card again, take it back from NEO and hand it over again. Re-assigning a card that is already NEO’s does nothing, on purpose: a save that happens to repeat the assignment must not start a second run.

What NEO does with a card

NEO never does the work itself. It classifies the card and rephrases what it asks into one objective for a squad:

The card asks for…	Squad	What you get
something to find out, compare, read, write or summarise	research — plan → work → an independent review	the answer, and the reviewer’s verdict on it
a change to code	coding — reads the repository, writes the change, reviews it	a draft pull request, linked on the card
something that must happen later or repeatedly (“every Monday…”)	workflow	a workflow saved switched off, linked on the card for you to review and arm

Some cards have exactly one squad, and skip NEO’s reading step entirely:

• a captured link is read, summarised and tagged;
• a contact is looked up on LinkedIn and filled in;
• a text-to-speech card is rendered to audio.

Those three are created already assigned to NEO, so a link you capture or a contact you file is worked on straight away.

If NEO cannot tell what a card wants — or a coding card names no repository — it does not guess: it writes the one question that would unblock it onto the timeline. Answer it on the card, then hand the card to NEO again.

Coding: connect GitHub

A coding squad works through GitHub. It never runs anything on your machine or ours, and it never merges: it writes one draft pull request on a fresh viite/squad-… branch, and nothing but that branch.

It cannot build or test either, so it waits for the pull request’s own CI. If CI goes red, a fixer reads the failure and pushes a fix onto the same branch — at most two attempts. The write-up on your card says plainly whether CI ended green, red, or unknown (no CI, still running after 30 minutes, or a token that may not read checks).

1. On GitHub, create a fine-grained personal access token. Limit it to the repositories NEO may touch, and give it Contents: read and write, Pull requests: read and write, and Checks: read and Actions: read (so the squad can see its CI and read a failed job’s log).
2. In Business Studio, open Channels → New → GitHub — code changes, enter your GitHub username and paste the token. It is checked with GitHub before it is saved.
3. Name the repository on the card, either in its text or as a tag: repo:owner/name. If you work in one repository, set it once as the channel’s Default repository instead. A card that names no repository then goes there, rather than NEO asking which one. A card that names one still wins.

The coding squad sees the repository and nothing else: not your board, not other cards. Tell it what to change. For “fix the next bug on my board”, NEO first hands the lookup to the board squad, which reports the bug card. Hand that card to NEO to have it fixed.

The token is the boundary. A squad can reach exactly the repositories the token can, acting as you.

Blocking cards

A card can wait on other cards. Open the card: in the properties panel on the right, right under Status, the Blocked by field lists what it waits on. Type in Add blocker… and pick the card it waits on (any piece of work, or a deal, but not a contact or a company). The × beside a blocker removes it, and a finished blocker is struck through. The board then shows blocked by: [5b2, abc] beside the card’s id. Only the blockers that are not done yet are listed.

• A blocked card cannot start. Moving it to In progress, from the board or through Claude’s update_task, is refused and names what it waits on.
• It starts on its own when its last blocker is done. A card assigned to NEO then runs. NEO does not run a blocked card when you assign it: the card’s timeline says what it is waiting on. Any other card moves from To do to In progress.
• An archived blocker still blocks, because archived means set aside, not finished. Remove the link if the card should go ahead anyway.
• Loops are refused. If B already waits on A, A cannot also be blocked by B.

Claude can set the same link with link_records and the role blocked_by.

Grouping cards under a bigger one

A card’s Part of property puts it under one bigger card: a topic, or a user story. On that bigger card, Sub-cards lists everything grouped under it and how many are done, and adds more from a search.

• A card has one parent. To move it under another card, remove it from the first one.
• Only a task, a user story, a page or a custom card can hold sub-cards. Any card except a contact or a company can be grouped. A contact belongs to many topics at once; link it with Linked records instead.
• A card cannot be its own parent, and it cannot go under one of its own sub-cards.
• Grouping does not block anything. A sub-card can start or finish whenever you like. Use Blocked by if one card has to wait for another.

Claude can set the same link with link_records and the role part_of (the sub-card is fromId, the bigger card is toId).

What can hand a card to NEO

Handing a card to NEO is something you do on the board. Claude, through the MCP connector, can file a contact (which goes to the contact squad), but it cannot hand NEO any other card: a conversation that has just read an untrusted web page must not be able to turn text into a pull request on your repository.