Vercel released Board on November 18 across its plans. The experimental service gives a team a shared message store and task records that agents can access through the Vercel CLI or a JavaScript SDK. Teams can keep a task and its discussion in a thread, change structured labels, claim work for a limited time and connect conversations to Slack or a GitHub issue or pull request. Documentation also describes Linear sync. Vercel presents Board as infrastructure for teams that run their own coding agents and environments. The beta’s practical contribution is a shared place to find work, tell a colleague who is doing it and recover the context when responsibility changes. Vercel launch changelog · Board product documentation
A failed build shows where that helps. One person receives a report from a teammate. A local coding agent reproduces a flaky unit test in the project’s own test suite. Another worker may check the proposed fix after the first agent’s session ends. If each worker has only its own chat history, it is hard to tell who owns the issue and which test result is current. A shared thread can connect the original symptom, a commit and what reviewers still need to know. The valuable record is the part another person can act on. An appealing timeline by itself cannot tell whether the linked code was merged or the underlying application now works.
What the board adds to a thread#
Vercel models a board as channels containing threads. A thread consists of a root message and replies. Messages can carry labels, reactions, attachments and structured data. A post can create a channel, whose path represents a place where related work goes. A task adds managed state to a thread. That state can describe whether work is ready, claimed, blocked, dependent on another task or complete. The distinction lets a person read the conversation while a program handles the part that must be compared across workers. A reply that says a patch is ready and a task marked complete serve different purposes. Board concepts and components
The structure is useful when a team knows which labels carry decisions. A thread can have one label for project, one for task type and a link to a code review. A worker can use these labels to discover the relevant activity. Free-form writing is still appropriate for the findings, the reason a check failed and what was tried. Well-defined identifiers matter more than adding many fields. If two tools use different labels for a review state, another worker may assume a task can be taken before the previous stage has finished. A mapping between the board state and a repository or issue tracker should be part of the workflow. Vercel Board labels
Structured data has a narrower strength. A code review link is easier for another program to consume when the service validates where the link belongs in a message. Listing how long a test took as a field can make repeated runs easy to compare. The result is still only as reliable as the program that produced it. A valid field can contain a link to a stale branch or a timing from the wrong environment. Downstream consumers should verify the referenced artifact when it affects a decision. That separates a claim a worker made from a state an application can observe. It also makes the thread more compact because the important records can travel as links.
Records can outlive a worker process, which gives the channel a different role from memory inside an individual agent. A new worker can inspect the history and see what remains open. A person can look at the same context without running the same agent. A change may arrive hours after the work began, when the engineer is in a different time zone. The useful handoff has a concise statement of the issue, a reference to current evidence and a next step. A long stream of status updates is easy to generate and hard to inspect. Teams adopting a shared store still decide how often a worker should write and what constitutes an update worth passing along.
The thread should have a reason to exist alongside the issue tracker. An issue can retain the customer-visible account of a bug while the board keeps discussion about which work is underway. A repository remains the place to inspect the commits and review. Having multiple systems need not mean entering every note several times. A team can decide which identifier to share, which status to mirror and which events remain local. A useful trial starts with an issue that moves through both systems. It should let an engineer find the current patch from the board and the current explanation from the issue without relying on the worker who made the first link.
A claim protects work for a limited time#
Board task claims are leases. A worker can claim a ready task, renew its lease while working and attempt to finish under the current claim. Expiring leases help another worker take over when the original one stops responding. The task documentation says a lost claim cannot renew, complete, fail or block the task. A pool can also select ready items by channel and labels, subject to documented ownership and assignment rules. This is a stronger statement than a message from a worker that says it intends to take a job. Other workers can consult which claim is currently valid. Board task and lease documentation
Think through an ordinary retry. A first worker claims a task and starts testing a patch. Its connection stalls and the lease expires. A second worker takes over and reads the first worker’s test notes. If the first worker reconnects, the board prevents a stale claim from completing that task. The repository has its own state, however. The first worker may already have pushed a branch, and the second worker needs to check what exists before producing another change. The system that receives a side effect must have its own way to match the action to the task and refuse stale or repeated updates. An expired Board claim cannot by itself retract a push.
The same distinction applies to successful replies lost in transit. An actor can write a task update, lose the response and reconnect. A repeat write could duplicate the update or start additional work if the downstream process treats every new record as a new request. Board’s docs describe an idempotency key for creating tasks and posts. A practical application can also store identifiers for an associated branch, review or build. It can check what the target system already did before repeating a write. The point is to make retries observable as repeats of a known operation. A task history that is durable at the board does not establish that every event processed elsewhere had one effect. Creating Board tasks and idempotency
Task dependencies add a way to say that one thing waits for another. A repair task can wait for a reproducible test, and a verification task can wait for a patch. The task documentation explains that large written plans may be created over several requests. An item from an early write may become ready before later items are recorded. This can be fine for independent jobs and awkward when an operator assumes the complete plan will appear in one moment. A test should check what a worker sees immediately after a partial write and after the remainder arrives. If the order matters, the workflow needs to represent that reason in the dependencies or in another explicit readiness check. Task dependencies and plan writes
It also helps to define what completion means. A worker can complete a task after producing a candidate patch, while a team may need later evidence from tests and human review before the work reaches customers. The board can state each milestone clearly and carry links to later results. A patch waiting for review should have a different state in the workflow from an operational repair that has been verified. A case where a test passes locally and fails in CI is a good check of these definitions. The board record should let the next worker know which check was performed, which check still failed and where the authoritative result can be inspected.
A trouble-free handoff also depends on the granularity of a task. If a task bundles a reproduction, a patch and a broad review into one item, the replacement worker may see a long stream of activity and have to guess which part was finished. Several very small tasks can be equally difficult to follow if there is no shared outcome. An effective division follows the points where evidence changes hands. One task can produce a repeatable test, another a candidate patch, and the review can link them to the exact revision it examined. The size is useful if failure leaves a clearly inspectable checkpoint and a next step.
Notifications do not transfer authority#
Board has an ordered event stream. Workflows can follow it or use watchers triggered by matching changes, such as a message or a label. A scheduled post can bring an item back to the attention of a worker. Vercel’s launch example describes using a follow-up to return to a pending CI result. This is useful when a background process ought to resume after an external event without an employee holding an open agent session. The event still needs interpretation. A reply saying a test completed does not establish that it passed, and a changed label does not guarantee that the person who made the change has authority to approve the next operation. Events in Board · Vercel’s watcher and scheduling overview
A useful event consumer keeps enough information to recognize the work it already did. Suppose the team sees a follow-up after it has reopened a task for a different commit. It can compare the task and commit identifiers, find the current CI attempt and decide whether a check is due. The same issue can appear during delayed delivery or after a worker restarts and catches up on the event log. A team can measure duplicate follow-ups, stale references and the time required to recover a consumer. What matters is the behavior when sessions overlap and when delivery pauses, because those are the circumstances that make a persistent board desirable in the first place.
Some tasks need a person's reply before the next step. Board supports blocking a job while it waits. The team can give the authorized person a link to the pull request and the tests and let that person decide in the system where reviews are enforced. That reviewer may also leave an answer in the thread the worker follows. Keeping the two records connected is practical, particularly when the thread includes people who are responsible for different parts of the work. A message may contain useful instructions about how to continue. An approval mechanism needs to check the identity, target change and status it authorizes each time. Blocking tasks for human input
The mix of people and agents can make supervision easier and noisier. Two automation handlers may turn the same updated label into repeated follow-up messages. A bridge can add external conversations to a thread that already contains agent replies. Before activating those connections for busy channels, a team can decide which events should start work, which should only record progress and what conditions cause the wait to end. Measuring the number of human interruptions as well as task speed gives a clearer view of real cost. A scheduler that saves time for the first worker can still create work for the person who has to read all the resulting notifications.
The accessible copy determines who can read it#
Board’s docs describe different actors. A local session can write using the signed-in Vercel user. A deployment can act as its Vercel project. A profile gives an agent a displayed name with the underlying actor’s permissions. A board can grant access at channel paths, and team owners retain the ability to change grants. For engineering managers, that means they should examine the account or project under the profile when reviewing what a worker can read and post. Naming an agent for one duty can make its activity legible. Constraining its access requires a principal or channel grant that represents that duty. Board access controls
Sync has a different boundary. Vercel documents two-way sync for conversations joined to Slack, GitHub or Linear. People with access to the matching external conversation can read the corresponding content there under its rules. Inbound replies can appear in Board. For a public GitHub issue, this is a particularly concrete decision. A team may want to post a patch link and a short status while keeping its internal build notes elsewhere. The board’s grant is not applied to a copy on another service. Operators need to consider the widest place a message might appear. The vendor says deletion of copies that already synced is attempted on a best-effort basis. Board sync and visibility · Board data handling
Vercel says Board data is stored in the United States without a region selector. Teams need to review that before using it for work that has a specified storage location. The operational impact depends on what is attached to a thread. A commit identifier and test status are a different category from proprietary source files, production logs or customer records. A thread can stay useful with links that respect their own access rules. If every diagnostic is copied into an attachment, the service becomes a second store for the same information, with a separate access and retention model. Knowing where the complete record belongs helps a team decide what the board itself should contain.
There is an important ownership difference between writing in the board and directing the agent. Someone might be allowed to post a bug report in a channel without having the ability to send production changes. A workflow should preserve those distinct roles. It can treat the report as evidence for a triage step and rely on the permissions in the code or deployment system for changes. Board’s task docs also distinguish the ownership of tasks a worker can pick up. These details are most useful when roles are tested with realistic cases. A private trial can place a synthetic report and a candidate patch under different users and show how work can move forward without granting one user every role.
The same discipline applies when different organizations share a thread. A vendor working on a dependency may need a minimal test result and a description of the version involved. The internal team may need to read its complete staging logs and discuss impact. It is useful to maintain a single identifier to find both records without copying the underlying material into each channel. A reasonable integration can label the data category of a thread and limit sync to the people who should receive its contents. Testing the visible output from both ends is more relevant than checking permissions only in the configuration screen. Policies matter where a reader can actually see a copy.
There is a similar issue with offboarding. An engineer can leave the team while a local worker was acting with that engineer’s account. A project can stop operating while old threads still point to a branch it created. Maintenance needs a way to tell which actors remain active, who owns a task that waits for them and which records are retained after the grant is removed. Deleting a local artifact or changing its permission can also break a link from a long-lived thread. A short audit of open tasks after a permission change can show which handoffs are still feasible and which facts need recording before a repository or project becomes inaccessible.
What a cautious pilot can establish#
The first test should use work that has a clear result and an easy recovery path. A flaky test in a team-owned repository is a good example. A person files the original report. A worker claims it, records the input revision and link to a test, then opens a candidate patch for the usual review. Another worker can take over after a simulated interruption. The test should show how much context the second worker can recover, whether work is accidentally repeated and which service has the final record. This exercise can happen without changing the project’s normal deployment path, because the coordination feature being evaluated is the handoff.
Before relying on the beta, a team can compare the old and new workflows with the same tasks. Useful measures include time to first claim, time spent finding earlier results, duplicate patch attempts, stale tasks still displayed as ready, and clarification messages a person has to answer. An experiment should include an ordinary successful handoff and a failure after the issue or branch has already been updated. It should also test whether a worker can identify the proper upstream record after a sync link is removed or changed. These observations can demonstrate an operational improvement. The fact that several agents appear in one system tells little about how much useful work the team recovered.
The experiment should also record two different times. The first runs from a report to a worker finding the task. The other runs from a report to a reviewed change and verified result. Faster discovery helps if a duplicate attempt or an unnecessary review does not consume the savings. A team with one maintainer could gain little from an additional source of tasks. A team with many independent sessions could spend less time reassembling context. Testing with a known baseline makes those effects visible, alongside any effort spent managing grants, synchronization and a beta SDK. That gives the team a basis for deciding whether the extra record helps its actual users.
Board offers an interesting combination for groups that already use more than one coding environment. It puts an explicit task state beside the conversation that explains it. It can let a colleague find the thread without recreating a session, while code and deployment decisions still use their established systems. The benefit is likely to be strongest when a team already understands what counts as done, who can approve it and which effect can be retried. That is also what makes the beta test straightforward. The next meaningful result will be whether a team can recover an interrupted handoff with fewer missing facts and get to the same tested change.