Agents Kanban: A Jira Board Where AI Agents Do The Work

In October 2025, I participated in the {Tech: Europe} Munich Hackathon, a weekend event bringing together developers to build new projects. What emerged was Agents Kanban - a project management platform with a twist: the tickets don't just track work, they do the work.

Imagine a Jira board where you create a ticket describing a feature you want, and instead of assigning it to a developer, an AI agent picks it up, writes the code, runs the tests, and creates a pull request. That's Agents Kanban.

This isn't vaporware or a concept demo. It's a fully functional platform built in a weekend, combining real-time collaboration with autonomous AI development. And it actually works.

Agents Kanban board showing tickets in different stages with AI agent status badges

the problem: project management meets implementation

Traditional project management tools excel at tracking what needs to be done. You create tickets, assign them to developers, move them across boards, and eventually mark them complete. The process is well-understood and works for teams of all sizes.

But there's always been a gap between planning and execution. A ticket describes what needs to happen, but someone still has to do the work. For small features, repetitive tasks, or straightforward implementations, this feels inefficient.

What if the project management tool could understand the ticket description and implement it automatically?

That question led to Agents Kanban.

the vision: autonomous development workflow

Agents Kanban reimagines the development workflow by combining three powerful technologies:

Convex for real-time collaboration - Every change to a ticket, every status update, every agent action syncs instantly across all connected clients. Multiple team members can watch as AI agents work through the backlog in real-time.

OpenCode AI for autonomous implementation - AI agents that don't just generate code snippets, but execute complete development workflows: reading existing code, making changes, running tests, and creating commits.

GitHub integration for production-ready output - Every completed ticket results in an actual pull request, ready for human review before merging.

The result is a Kanban board that feels familiar but behaves radically differently.

how it works: from ticket to pull request

The workflow is straightforward from a user perspective:

1. creating a ticket

You describe what you want in natural language:

"Add a dark mode toggle to the application settings. The toggle should persist across sessions and apply to all components."

That's it. No need for detailed technical specifications or implementation instructions. Just describe the outcome you want.

2. the planning phase

When you move a ticket to the "Planning" column, an AI agent analyzes the description and generates an implementation plan:

  • What files need to be modified or created
  • What dependencies might need to be added
  • What testing approach should be used
  • Potential edge cases to consider

The plan is saved to the ticket and visible to the team. You can review it, request changes, or approve it to move forward.

3. the implementation phase

Moving the ticket to "In Progress" triggers the AI agent to start coding. This is where the magic happens.

The agent:

  • Clones your linked GitHub repository
  • Reads existing code to understand the architecture
  • Makes the necessary changes following your project's conventions
  • Runs tests and checks
  • Creates a commit with a descriptive message

All of this happens autonomously. The ticket updates in real-time with status badges showing what the agent is doing. You can watch as it progresses from "Planning" to "Implementing" to "Testing".

4. pull request creation

When the implementation is complete, the agent creates a GitHub pull request with:

  • All the code changes
  • A summary of what was implemented
  • Links back to the original ticket

The PR URL is added to the ticket, and it moves to the "Done" column.

At this point, a human developer reviews the PR just like any other code review. The AI did the implementation work, but humans maintain the quality standards.

the tech stack: choosing the right tools

Building Agents Kanban in a weekend required choosing technologies that prioritize developer velocity without sacrificing capability.

frontend: next.js + react

The UI is built with Next.js 15 and React 19, using the App Router for clean routing and server components. Tailwind CSS handles styling with a custom component library built on Radix UI primitives.

The Kanban board uses @dnd-kit for drag-and-drop functionality, providing smooth interactions as tickets move between columns.

backend: convex

Convex is the backbone of the real-time collaboration. Every ticket, every status change, every agent update flows through Convex's reactive queries.

The beauty of Convex is how it eliminates boilerplate. Define a schema, write serverless functions, and everything else - WebSocket connections, data synchronization, type safety - is handled automatically.

Example schema for tickets:

tickets: defineTable({
  title: v.string(),
  description: v.string(),
  status: v.string(), // "backlog" | "planning" | "in_progress" | "done"
  plan: v.optional(v.string()),
  pullRequestUrl: v.optional(v.string()),
  repositoryUrl: v.string(),
  agentStatus: v.optional(v.string()),
});

That's it. No migrations, no ORM configuration, no API endpoint definitions. Convex generates type-safe client code automatically.

ai layer: opencode sdk

The autonomous implementation is powered by the OpenCode AI SDK, which provides abstractions for AI agents that can interact with codebases.

Instead of building LLM orchestration from scratch, OpenCode provides agents that can:

  • Read and understand existing code
  • Make targeted edits while preserving code style
  • Run terminal commands and interpret results
  • Create structured plans from natural language descriptions

Integration is remarkably simple:

const agent = await opencode.createAgent({
  repository: ticket.repositoryUrl,
  task: ticket.description,
  model: "openai/gpt-5-codex",
});

await agent.plan(); // Generate implementation plan
await agent.implement(); // Execute the plan
const prUrl = await agent.createPullRequest(); // Ship it

The SDK handles the complexity of context management, tool usage, and error recovery.

github integration

Every project in Agents Kanban links to a GitHub repository. When an agent completes work, it pushes changes to a new branch and creates a pull request using the GitHub API.

Authentication uses GitHub personal access tokens, and the agent commits under a bot account to clearly distinguish AI-generated changes.

real-time collaboration: watching agents work

One of the most compelling aspects of Agents Kanban is the visibility into what's happening.

When an agent is working on a ticket, you see live status updates:

  • "Agent Planning" with a green badge
  • "Agent Implementing" with a blue badge
  • "Completed" or "Failed" with appropriate indicators

Multiple team members can be on the same board simultaneously. As agents complete tickets and create PRs, everyone sees the updates instantly. It creates a unique feeling of watching your backlog convert itself into pull requests.

The real-time aspect also allows collaboration between AI and humans. You might start an agent working on one ticket while manually implementing another. The board tracks both types of work at the same time.

what worked: lessons from a hackathon build

Building a functional AI project management platform in 48 hours taught important lessons:

1. use existing abstractions

We didn't build LLM orchestration from scratch. We didn't implement our own real-time sync. We didn't create a custom drag-and-drop library.

Instead, we chose tools that provide the right abstractions: OpenCode for AI agents, Convex for real-time data, Next.js for the frontend framework. This let us focus on what makes this unique rather than infrastructure.

2. real-time is a feature multiplier

The real-time updates transform the experience. Watching an agent work through a ticket feels completely different than submitting a job and checking back later.

Convex made this trivial to implement. Every mutation automatically triggers subscribed queries to refresh. No manual cache invalidation, no WebSocket management, no state synchronization bugs.

3. ai agents need structure

Early iterations gave agents too much freedom, resulting in unpredictable behavior. The breakthrough was adding the explicit planning phase.

By forcing agents to first create a plan that humans can review, we added an important checkpoint. The agent can't implement something wildly off-base because the plan would reveal that immediately.

This two-phase approach (plan, then implement) proved more reliable than single-shot execution.

4. github integration provides credibility

Having agents create actual pull requests makes the project feel real. This also uses existing workflows. Developers already know how to review PRs. We didn't need to build a custom code review interface.

the hackathon experience

The {Tech: Europe} Munich Hackathon provided the perfect environment to build Agents Kanban:

Time constraints force focus With only a weekend, we couldn't overthink decisions. Choose a database? Convex. Handle authentication? Simple GitHub tokens. Build a component library? Use Radix UI. These quick decisions kept momentum high.

Live demos create accountability Knowing we'd demo to other participants forced us to build something that actually works. No mock data, no fake workflows - real agents implementing real tickets.

Immediate feedback is extremely helpful Watching other developers try the platform revealed usability issues immediately. The importance of clear status indicators, readable plans, and error messages became obvious when someone unfamiliar used it for the first time.

Hackathon projects can be real projects Agents Kanban isn't a throw-away prototype. The architecture is sound, the code is maintainable, and the main idea has real potential. Starting as a hackathon project doesn't mean ending as one.

what's next: beyond the hackathon

Agents Kanban proves the concept works, but there's room for evolution:

Better agent customization Allow teams to configure agent behavior: which model to use, what testing frameworks to run, what code style to follow. Different projects have different needs.

Changes after review If a PR needs changes after review, allow commenting on specific improvements and having the agent revise. "Fix the TypeScript error in line 42" should trigger an agent update, not a full reimplementation.

Multi-agent coordination Large features might span multiple tickets. Agents could coordinate to ensure changes work together, sharing context about data models or API contracts.

Analytics and learning Track which types of tickets agents handle successfully and which require human intervention. Use this data to route work appropriately and improve agent capabilities over time.

Integration with existing tools Instead of replacing Jira or Linear, integrate with them. Let agents work on tickets in your existing workflow rather than requiring a new platform.

what's next for project management?

Agents Kanban represents a shift in how we think about project management tools.

Today's tools track work. Tomorrow's tools might do work.

This doesn't replace developers - the code still needs review, the architecture still needs design, the product still needs vision. But it changes what developers spend time on.

Instead of implementing every straightforward feature manually, developers can focus on:

  • Reviewing AI-generated implementations
  • Designing system architecture
  • Solving complex problems that require creativity
  • Building relationships with users

The mundane, repetitive coding work can be automated. The uniquely human aspects of software development become the focus.

try it yourself

Agents Kanban is open source and ready to use:

Repository: github.com/leoffx/agents-kanban

Quick start:

git clone https://github.com/leoffx/agents-kanban.git
cd agents-kanban
npm install
npx convex deploy --yes
# Configure your .env with API keys
npm run dev

Create a project, link your GitHub repository, write a ticket, and watch an AI agent implement it.

Building Agents Kanban in a weekend at the Munich Hackathon showed that autonomous development workflows aren't science fiction - they're achievable with today's tools and technologies.

The combination of real-time collaboration (Convex), autonomous AI agents (OpenCode), and familiar development workflows (GitHub PRs) creates something that feels both futuristic and practical.

Project management tools have helped us track work for decades. Maybe it's time they started doing some of it too.