EpicsAI is an enterprise-grade project management utility that ingests unstructured engineering communication—such as meeting transcripts and standup logs—and outputs structured, developer-ready Agile project artifacts directly synchronized to Linear.
The modern software development lifecycle suffers from severe engineering alignment decay. Organizations consistently leak capital through inefficient administrative overhead: high-salary engineers are trapped in multi-hour sprint planning sessions, while technical leads waste valuable cycles manually translating conversational meeting notes into actionable tickets. Inevitably, critical action items, edge-case considerations, and architectural decisions discussed in messy Zoom transcripts or daily Slack standups are dropped or mischaracterized during this manual translation. This results in poorly scoped tickets, costly context switching, and delayed shipping cadences.
EpicsAI solves this operational inefficiency by providing instant, highly structured extraction of Epics and nested task breakdowns directly from raw text payloads. By strictly enforcing organizational schemas and bridging unstructured human conversation with deterministic issue tracking, EpicsAI eliminates the administrative overhead of sprint planning. It guarantees that perfectly scoped, developer-ready tickets are generated and synced to your issue tracker with zero manual data entry.
EpicsAI is designed to handle high-latency LLM generation via a robust streaming and asynchronous queuing architecture.
[ Transcript Input ] (Raw Text / Audio Logs)
│
▼
[ Next.js BFF ] (Prompt Isolation & Context Injection)
│
▼
[ Anthropic API ] (Streaming API via client.messages.stream)
│
▼
[ Progressive Zod Verification ] (Schema Contract Enforcement)
│
▼
[ SSE Client Rendering ] (Real-Time Token-by-Token UI)
│
▼
[ Upstash Redis ] (Async Job Queueing & Rate Limit Handling)
│
▼
[ Linear SDK ] (Async Export & Ticket Generation)
epicsai/
├── src/
│ ├── app/ # Next.js 14 App Router
│ │ ├── api/ # API Routes (BFF)
│ │ │ ├── auth/ # NextAuth lifecycle endpoints
│ │ │ ├── extract/ # SSE streaming extraction endpoint
│ │ │ └── linear/ # Async Linear sync webhook receiver
│ │ ├── dashboard/ # Client views for workspace and extraction
│ │ ├── layout.tsx # Root layout and context providers
│ │ └── page.tsx # Marketing/Landing entrypoint
│ ├── components/ # UI layer separation
│ │ ├── global/ # Reusable shadcn/ui components (Buttons, Inputs)
│ │ └── extraction/ # Feature-specific extraction dashboard layouts
│ ├── lib/ # Foundational core logic
│ │ ├── ai/ # Prompt engine module and Anthropic wrapper
│ │ ├── db/ # Prisma client configuration and DB helpers
│ │ ├── linear/ # Integration client wrapper and mappers
│ │ └── queue/ # Upstash Redis background export workers
│ └── schemas/ # Single source of truth Zod contracts
│ ├── epic.ts # Epic/Task output schemas shared with LLM
│ └── workspace.ts # Configuration schemas
├── prisma/ # Database schema definition
│ └── schema.prisma
├── .env.example # Environment variables matrix
├── next.config.mjs # Framework configuration
├── tailwind.config.ts # Styling tokens
└── package.json # Dependencies and scripts
- Progressive Disclosure Team Roster Input: Intelligently maps mentioned names or handles in transcripts to actual engineering profiles in your workspace to automatically assign tickets.
- Real-Time Token-by-Token Progressive UI: Utilizes Server-Sent Events (SSE) to render the Epic and sub-tasks as they are being generated in real-time.
- Strict Structural Contract Enforcement: Utilizes Zod for recursive self-correction, ensuring that AI-generated payloads strictly adhere to required JSON schemas before hitting the database.
- Smart Workspace Profile Alignment: Context-aware mapping of the generated tasks to appropriate Linear projects, teams, and cycles based on historical data and user configuration.
- Multi-Tenant Async Linear Synchronization: Safely queues API requests to Linear to handle rate limits and avoid blocking the client, providing robust background sync.
| Layer | Technology Stack |
|---|---|
| Layer 1 (Frontend) | Next.js 14 App Router (RSC), Tailwind CSS v4, shadcn/ui, Zustand, TanStack Query |
| Layer 2 (BFF/API) | Next.js API Routes, NextAuth v5 (OAuth token rotation), Zod, Upstash Redis (Edge Rate Limiting) |
| Layer 3 (AI Engine) | Anthropic TypeScript SDK (SSE streaming via client.messages.stream()), LangSmith Tracking & Evaluation Datasets |
| Layer 4 (Data/Queue) | PostgreSQL, Prisma ORM, Upstash Redis Cache & Async Job Queue (BullMQ/Inngest), S3/Vercel Blob |
| Layer 5 (Infra/Ops) | Vercel Edge, GitHub Actions, Sentry, PostHog |
# 1. Clone the repository
git clone https://github.com/essiebx/epicsai.git
cd epicsai
# 2. Install dependencies
pnpm install
# 3. Configure the environment matrix
cp .env.example .env.local
# Edit .env.local to include your credentials:
# [Layer 2] NEXTAUTH_SECRET, NEXTAUTH_URL
# [Layer 3] ANTHROPIC_API_KEY
# [Layer 4] DATABASE_URL, UPSTASH_REDIS_REST_URL, UPSTASH_REDIS_REST_TOKEN
# [Layer 5] LINEAR_CLIENT_ID, LINEAR_CLIENT_SECRET
# 4. Run Prisma Database Migrations
npx prisma migrate dev --name init
npx prisma generate
# 5. Launch the development environment
pnpm devInput Transcript:
"Alright, for the checkout page redesign, Alice needs to update the Stripe elements to use the new payment intent API. Bob, you handle the backend endpoint for the webhook fulfillment. We also need to add a skeleton loader while the payment processes. Let's group this under the Q3 Payments Epic."
Extracted Output Structure:
{
"epic": {
"title": "Q3 Payments Redesign",
"description": "Implementation of the new Stripe payment intent API and corresponding webhook fulfillment for the checkout page.",
"summary": "- Upgrade checkout elements\n- Build backend webhook fulfillment\n- Add UX loading states",
"tasks": [
{
"title": "Integrate Stripe Payment Intent API",
"body": "Update frontend Stripe elements on the checkout page to utilize the new Payment Intent API.",
"effort": 3,
"priority": 2,
"assigneeIdentifier": "alice@example.com"
},
{
"title": "Implement Stripe Webhook Fulfillment",
"body": "Create backend endpoint to handle Stripe webhook fulfillment upon successful payment.",
"effort": 5,
"priority": 2,
"assigneeIdentifier": "bob@example.com"
},
{
"title": "Add Checkout Skeleton Loader",
"body": "Implement a skeleton loader state while the payment intent is processing to improve UX.",
"effort": 1,
"priority": 3
}
]
}
}- Why Progressive SSE Streaming over block fetching? Waiting for an LLM to generate a complex, multi-task Epic structure in a single block fetch can take 10-15 seconds. By implementing Server-Sent Events (SSE) and progressive UI rendering, we drop the perceived latency to under 2 seconds. The user sees value being generated immediately, significantly improving the human-computer interaction (HCI) experience.
- Why a BFF (Backend-For-Frontend) abstraction layer? The Next.js BFF acts as a secure intermediary. It shields the Anthropic API keys from the client, normalizes incoming requests, and allows us to inject system prompts and workspace context dynamically. This effectively mitigates client-side prompt injection attacks and ensures our AI engine operates within a strict boundary.
- Why Asynchronous Queueing for Linear syncing? Remote API synchronization (like pushing 10 tasks to Linear) is slow and prone to 429 Too Many Requests errors. By decoupling the Linear export from the client lifecycle and placing it in an Upstash Redis job queue, we ensure the user is not blocked waiting for a remote API. If a network failure occurs, the queue automatically handles exponential backoffs and retries.
- Token Boundaries on Massive Transcripts: One-hour meeting transcripts easily blow past standard context windows. We implemented a chunking and summarization pipeline prior to the final extraction phase to ensure the Anthropic model maintains high attention on actionable items without hallucinating due to context dilution.
- Non-Deterministic JSON Failures: LLMs occasionally stream malformed JSON (missing brackets, unescaped quotes). We built a progressive parsing buffer that attempts to sanitize and close incomplete JSON objects on the fly, allowing the UI to render the stream without crashing.
- Structural Validation Remediation: When the model outputs a structure that violates our Zod schemas (e.g., assigning a task to an unknown user), the BFF catches the exception and triggers a lightweight, automated self-correction prompt to the LLM behind the scenes before rejecting the request entirely.
- Automated Cross-Extraction Backlog Diffing: Before generating a new ticket, EpicsAI will vector-search the existing Linear backlog to prevent duplicate ticket generation across multiple standups.
- Cross-Transcript Multi-Epic Aggregation: The ability to ingest a week's worth of daily standup transcripts and synthesize them into a single, cohesive sprint retro and follow-up Epic.
- Bi-Directional Webhooks: Implementing listeners so that if a ticket's status is shifted in Linear, EpicsAI's internal metadata state updates to reflect the real-time velocity and completion metrics of the generated Epic.