DEV Community

Cover image for I Got Tired of Jira. So I Built an Agentic Project Management Tool — and Open-Sourced It
Joseph Mukorivo
Joseph Mukorivo

Posted on

I Got Tired of Jira. So I Built an Agentic Project Management Tool — and Open-Sourced It

#go #nextjs #typescript #webdev

I’m open sourcing FortyOne, an agentic project management tool built around a simple idea:

Most project tools are great at tracking work.

Very few help you move work forward.

FortyOne ships with Maya, an AI teammate that’s designed to work alongside you: drafting stories, helping shape sprint scope, connecting OKRs to execution, and surfacing what’s stuck before it becomes a fire drill.

If you just want to try it first, the hosted version is here: https://www.fortyone.app

Frontend repo: https://github.com/complexus-tech/fortyone.app

Backend repo: https://github.com/complexus-tech/api.fortyone.app

What I mean by “agentic project management”

There’s a lot of “AI for project management” content out there, and most of it is basically:

You ask a question → you get a summary.

That’s useful, but it’s not agentic.

When I say agentic, I mean the AI is built to help with action inside your workflow, not just commentary about the workflow.

A few examples of the kind of work Maya is meant to support:

  1. Turn rough thoughts into structured stories

    You give a messy paragraph, you get a story with a clear title, description, and the right structure to start execution.

  2. Help plan sprints using context

    Instead of guessing sprint scope from scratch, Maya can help propose a sprint plan based on backlog context and what your team is trying to ship.

  3. Connect OKRs to actual day-to-day work

    It’s easy to write goals. It’s hard to make sure the backlog reflects them. FortyOne is designed to keep that relationship visible.

  4. Surface risks early

    Work gets stuck quietly. The goal is to make “quietly stuck” obvious, so you can respond before deadlines do it for you.

That’s the “AI teammate” framing I’m pushing for: less chatbot, more “help me execute.”

What is FortyOne today

FortyOne is a modern project management platform that focuses on:

  1. Stories (task tracking with real workflows)
  2. Sprints (planning and velocity)
  3. Objectives and OKRs (goal tracking tied to execution)
  4. Real-time collaboration (your team stays in sync)

It’s designed to feel clean, fast, and easy to adopt.

What’s open source

FortyOne is split into two main codebases:

  1. Frontend (monorepo)

    Repo: https://github.com/complexus-tech/fortyone.app

  2. Backend API (Go)

    Repo: https://github.com/complexus-tech/api.fortyone.app

I’m sharing both because I want this to be genuinely useful for builders who want to learn from it, extend it, self-host it, or contribute features back.

Frontend overview (fortyone.app)

The frontend is a Turborepo monorepo built for a real product, not a demo. It includes:

  1. A marketing and auth app
  2. The main project management app
  3. A docs site
  4. A React Native mobile app (in progress)

The stack leans modern and practical:

  1. Next.js 15 + React 19
  2. TypeScript
  3. Tailwind CSS
  4. Radix UI + Framer Motion
  5. PostHog for analytics
  6. NextAuth for authentication

Monorepo structure (high level)

You’ll find a structure like:

  1. apps/
    1. landing/ (marketing + auth)
    2. docs/ (documentation)
    3. projects/ (core app)
    4. mobile/ (React Native)
  2. packages/
    1. shared UI components
    2. shared utilities
    3. icons
    4. shared configs

Backend overview (api.fortyone.app)

The backend is a Go application that powers the core product workflows.

It’s designed with a clear architecture so it’s easier to maintain, test, and extend.

Backend architecture (the important part)

The API follows a hexagonal/layered approach with a few clear layers:

  1. Transport layer

    HTTP, routing, input validation.

  2. Domain layer

    Business logic and interfaces.

  3. Data layer

    Storage implementations (PostgreSQL via SQLx).

  4. Platform / pkg layer

    Shared utilities and integrations.

There’s also a worker process for background jobs.

A few backend highlights

  1. Migrations with golang-migrate
  2. Database seeding for quick dev setup
  3. A worker process (useful for background work)
  4. Brevo integration for onboarding and transactional emails

Local development

I wanted the project to be something you can actually run locally without a week of archaeology.

Frontend: run locally

  1. Clone the repo
    git clone https://github.com/complexus-tech/fortyone.app

  2. Install dependencies
    pnpm install

  3. Copy environment files
    cp apps/landing/.env.example apps/landing/.env
    cp apps/projects/.env.example apps/projects/.env
    cp apps/mobile/.env.example apps/mobile/.env

  4. Start dev
    pnpm dev

Backend: run locally

  1. Clone the repo
    git clone https://github.com/complexus-tech/api.fortyone.app

  2. Copy env file
    cp .env.example .env

  3. Run the API (hot reload)
    make dev

  4. Run the worker (in another terminal)
    make worker

Migrations

Install migrate CLI if you want to work with migrations:

go install -tags 'postgres' github.com/golang-migrate/migrate/v4/cmd/migrate@v4.18.3

Then you can run:

  1. make migrate-up
  2. make migrate-down n=1

Seeding

If you want a working workspace quickly, the backend includes a seeder:

  1. Default seed
    make seed

  2. Custom seed
    make seed name="My Project" slug="my-project" email="me@example.com" fullname="Your Name"

Why I open sourced it

A few reasons, honestly:

  1. I want builders to learn from a real product codebase

    Not a “todo app,” but something with real trade-offs, real constraints, and real structure.

  2. I want contributions

    Not just PRs, but feedback on architecture, UX decisions, and what people want from agentic workflows.

  3. I want to build in public

    It’s easier to grow something when people can see it, use it, and improve it with you.

  4. I think agentic UX is the next big frontier

    We’ve had a decade of dashboards. The next step is software that can actually help you execute.

About the license

Both repos include a license file in the root.

The intent is:

  1. Free for personal and non-commercial use
  2. Commercial licensing required for larger businesses (as defined in the license)

If you’re building something commercial on top of it, read the license first and reach out if needed.

What I’d love help with

If you want to contribute, here are the kinds of contributions that are genuinely helpful:

  1. Bugs and rough edges (especially around local setup)
  2. UI/UX polish and accessibility improvements
  3. Better docs and examples for Maya-style workflows
  4. Integrations (GitHub, Slack, webhooks)
  5. Performance improvements and profiling notes
  6. Mobile app progress (React Native)

Even if you don’t want to write code, opening issues with clear reproduction steps and screenshots helps a lot.

Try it, star it, break it

If you’re curious about agentic workflows in a real project tool:

  1. Try the hosted version: https://www.fortyone.app
  2. Star the repos if you want to follow progress
  3. Open an issue if something feels off
  4. If you have ideas for what an “AI teammate” should do inside a PM tool, I want to hear them

This is the direction I’m betting on: project management that helps you ship, not just report.

See you in the issues.

Top comments (0)