Agentboard: A Task Collaboration Framework That Lets AI Agents Work the Board Themselves

A Kanban Board with an Autonomous AI Running Behind It

A developer with 17 years of experience shared on Bilibili an open-source agent framework he's been building — Agentboard. At first glance it looks like an ordinary kanban board, something like Trello's card-based task management. But the real difference lies in the backend: an AI agent that proactively picks up cards at the right moment and completes tasks on its own.

The author's core vision is clear — the best way for humans and AI agents to collaborate shouldn't involve staring at a chat window all day. Instead, it should work like managing a team member: put tasks on the board, let the agent pick them up, execute them, and report back. This repositions AI from a "conversational tool" to an "async collaborative teammate."

Every card has a timeline at the bottom that records everything humans and the agent have done: messages exchanged, status changes, actions taken by the agent — all timestamped. The author emphasizes that this timeline exists to give the agent "the right context at all times" — it knows what happened along the way, whether the status moved, what was said in comments, and what actions have already been taken. Even after a long gap, both human and AI can seamlessly pick up where they left off.

Five States, One Async Collaboration Flow

Agentboard's kanban design features five status columns — the skeleton of the entire collaboration model:

• Inbox: Where humans create new cards, essentially a backlog pool;
• Ready: Cards here wait for the agent to pick up on its next run;
• In Progress: Managed by the agent itself, indicating active work;
• Needs Input: Where the agent moves a card when it's stuck and needs information from a human;
• Review: The agent believes a task is done and wants a human to check it;
• Done: Approved cards are archived here.

The elegance of this state machine is that it makes "human intervention points" explicit. Humans only need to watch the Needs Input and Review columns — the rest of the time, the agent flows between Ready and In Progress on its own. The author repeatedly drives home the idea: "You don't want to be sitting at your computer all day."

Getting the agent to start working is dead simple — drag a card into the Ready column, or click the button and enter "start" as the reason. The next time the agent runs, it scans the Ready column, asks itself "which tasks need my attention," and picks up cards to begin working.

This five-state design is a textbook application of a Finite State Machine (FSM) in software engineering. FSMs specify that a system can only be in one well-defined state at any given moment, and transitions between states are triggered by specific events. Agentboard's elegance lies in separating "human-triggered" transitions from "agent-triggered" ones: moving from Inbox to Ready is triggered by a human drag; from Ready to In Progress, by the agent's scan; from In Progress to Needs Input, by the agent's own judgment. This makes responsibility boundaries crystal clear — the system never stalls because "it's unclear who should move things forward." By contrast, traditional conversational AI has no concept of state; every interaction starts from the current window, and context continuity depends entirely on the conversation history length limit rather than structured state records.

Context and Ops Cards: The Keys to True Agent Autonomy

The author spent considerable time thinking about how to make the agent "operate autonomously" rather than just passively execute. His answer is two mechanisms: a context system and Ops Cards.

Context is made up of plain Markdown files storing contacts, information, and connections the agent can access. The agent can both read and write these. There's also a dedicated area for storing secrets — these cannot be read in plaintext by the agent, but can still be used during its work. This design solves a long-standing pain point: how to let AI safely use sensitive credentials.

Ops Cards are a feature the author believes few tools on the market currently offer. They differ from regular "task cards" — task cards represent goals to be achieved, while Ops Cards are things the system itself needs: access permissions, decisions, context updates, or connection changes.

The most valuable scenario: when the agent hits a blocker during execution, it can create an Ops Card itself, temporarily blocking current work until someone provides the missing information. The video demonstrates three blocked Ops Cards all waiting on the same thing — GitHub access. The agent requests a token, the human adds it securely, and throughout the entire process the agent never sees the plaintext value of that key, yet can use it to access GitHub in subsequent work. This transforms an agent "getting stuck" from a dead end into a ticket that humans can resolve asynchronously.

Secure usage of secrets is one of the trickiest problems in deploying AI agents in production. Agentboard's approach is conceptually similar to Secret Manager patterns in cloud services — think AWS Secrets Manager or HashiCorp Vault: applications have permission to invoke secrets, but the plaintext never appears directly in runtime variables or logs. In Agentboard's implementation, the agent accesses sensitive credentials through a proxy layer. LLM-generated code or instructions can reference a secret by "name" rather than actual value, and the execution layer injects the real credential at runtime. This isolation prevents a common class of security risk: AI-generated content or logs inadvertently leaking secrets into readable output. For autonomous agents that need to connect to GitHub, third-party APIs, and similar services, this is essential infrastructure for moving from an experimental project to something actually usable.

A Real Example: Letting AI Fix Its Own CSS

The author demonstrates the full flow with a real example. Dissatisfied with the positioning of some text in the panel, he creates a task card describing the issue: when there are no cards in a column, the empty-state element isn't correctly positioned within the container margins.

After submitting, the card enters the Inbox. He types "start" to move it to the Ready column. Backend logs show a new AI session launching, loading prompts, browsing the board, deciding which tasks need attention — then the agent automatically moves the card to In Progress.

At this point the author can go do other things — reply to messages, send emails, handle another card. The agent works independently in the background, writing comments and logging milestones to the timeline as it hits them. When done, it moves the card to Review and reports back: it fixed a missing CSS issue for the empty card prompt on desktop, added one line based on the existing mobile styles, and submitted a pull request on GitHub. It also honestly noted it couldn't do a visual check in the browser, but that the local build process is configured to check CSS.

After the author confirms things look good, he gives the instruction "merge and create a new release." The agent runs through the same flow again: Ready → launch session → read context → execute → report, until the human approves in the Done state.

Worth noting: the tool's own Agentboard is connected to the GitHub repository holding its own code — the author creates issues, converts them to new releases, and pulls updates from his phone or computer at any time. In other words, this tool is using itself to build itself.

What This Vision Solves — and What Questions Remain

The thinking behind Agentboard addresses a pervasive frustration in current AI agent applications: conversational interaction demands constant human presence and constant responses — inefficient and fragmenting. The combination of kanban + timeline + state machine is fundamentally a redesign of human-AI collaboration into an async, traceable, containerized workflow.

The author summarizes several design values: each task is an independent unit; context accumulates and grows richer over time with more connections; all operations are timestamped, forming a complete project history that's both easy to review and lets the agent learn from past experience. His ideal picture: open your phone in the morning, glance at the Needs Input and Review columns, give a few answers, and the agent immediately picks up where it left off.

Of course, this framework is still a solo developer's daily-iteration open-source project. The author himself acknowledges that "there are probably already many similar ideas and solutions out there" — he's just building it the way that makes the most sense to him. For those watching from the sidelines, questions around the reliability of async collaboration, the boundaries of the agent's autonomous judgment, and scheduling across parallel tasks all still need real-world validation. But as a thought experiment on "how humans and AI should collaborate," Agentboard offers a remarkably concrete and implementable model.

The human-AI async collaboration model Agentboard explores is academically classified as a variant of Human-in-the-Loop (HITL) systems. Traditional HITL requires humans to synchronously confirm at every decision node, whereas Agentboard is closer to Human-on-the-Loop (HOTL) — humans set goals and boundaries, the agent executes autonomously, and humans are only pulled in asynchronously when predefined blocking conditions arise. The core challenge of this design: how to precisely define "blocking conditions" — when should the agent decide on its own, and when should it stop and wait? Define conditions too loosely and the agent constantly interrupts humans; define them too strictly and the agent may travel too far in the wrong direction before being caught. The Ops Card mechanism is the author's engineering solution, but the accuracy with which the agent autonomously judges "I need help" ultimately depends on the underlying model's capability ceiling and the quality of the prompt design.