ProductIntel: Technical Showcase

An AI-native product operations platform with two coexisting workflows: a daily-cycle workflow for agent-native teams, and a sprint-based workflow for traditional teams. Same data model, same AI infrastructure, different rhythm.

Built solo as a working product demonstrating multi-agent orchestration, RAG context engineering, AI-first UX design, and adoption-aware product judgment.

Why This Project Exists

Most AI tools are designed for the user the builder wishes existed. ProductIntel is designed for the user who actually shows up. Companies sit at different points on the AI adoption curve, and a product that only serves the destination fails the team using it today. So the platform ships with two coexisting workflows on shared infrastructure: a daily-cycle Today module for agent-native teams, and a sprint-based Work module for traditional teams. Each company picks its operating mode at install.

Underneath both modes, 21 specialized AI agents collaborate across 7 teams through a shared knowledge graph, with full telemetry, cost tracking, defect tracking, and audit trails on every LLM call. The Context Engine grounds every AI decision in product-specific context, scored across 7 categories of coverage. Every agent run, every inference, every retrieval is observable.

The thesis: companies adopt AI on a curve, not a switch. Mid-market teams currently spending $200K–$1M/year on disconnected enterprise tools (Jira, Confluence, ServiceNow, plus an AI-bolt-on layer) can replace that stack with a single platform that meets them at their current rhythm and lets them migrate as they go. AI token costs are dropping 100x while per-seat SaaS prices keep rising; the economics are flipping.

Built solo. The architectural decisions that don't show up in a 90-second demo are the ones that determine whether the product holds up on day 30.

1. Two Workflows, One Platform

ProductIntel ships with two distinct workflow surfaces backed by the same data model and AI infrastructure. A company-level work-mode preference (agent / dual / human) determines which surfaces appear and how they're presented across pages.

Today module: daily-cycle workflow

For agent-native teams. The day is the unit of work: capture an idea in the morning, refine it into a structured spec, plan it as decomposed work units, watch agents execute, and finalize before end of day. No sprints, no story points, no epic containers. Built on Idea + Work Unit primitives stored as artifacts via metadata tagging, which reuses the same pb_artifacts schema so smart-assign, spec-enrichment, and the agent execution pipeline all work unchanged across both modes.

Lifecycle: captured → refining → planning → in-flight → reviewing → delivered (plus terminal states failed and parked).

Work module: sprint-based workflow

For traditional teams. Backlog, AI Triage, Spec Pipeline, Kanban Board, Sprint planning, Completed views. AI assists where it helps (estimation, triage narrative, retro generation) but doesn't change how the team operates. The AI Triage panel is the daily entry point: an AI-generated narrative briefing recommending what to work on next, plus per-story Execute Now / Smart Assign / Schedule / Merge & Deploy buttons.

Adoption-aware design

Most AI tools require a workflow rewrite to adopt. ProductIntel doesn't. A traditional team can install in human mode and use AI as a triage assist. As they get comfortable, they switch to dual mode and start using Today for ideas they want agents to deliver. Eventually they may flip to agent mode entirely. The migration is incremental and reversible: no data migration, no surface rewrite, just a setting change.

This design choice is the argument: companies are on different points of the AI adoption curve, and a product that only serves the destination fails the user who shows up.

2. From Vague Input to Validated Code Change

The killer loop the platform demonstrates: a PM writes three sentences, and an agent ships a reviewable PR. Four mechanisms make that work end to end.

1. Spec Pipeline maturity gate (detailed in Section 10). Stories don't reach an agent until they've been promoted through Ideation → Ready for Refinement → Refined (Review) → Ready for Development. The execution gate enforces it. Vague input gets a refinement prompt instead of producing vague output.

2. LLM enrichment closes the spec gap. A 3-sentence story is enriched into an agent-ready spec: file paths, tables to touch, components to create or modify, acceptance criteria, negative constraints, and error handling. The PM never has to write a 2-page spec by hand. Single-story or batch.

3. Agent execution in an isolated worktree (detailed in Section 8). The Mac Mini worker creates a fresh git worktree from main, Claude Code implements the story against the enriched spec, runs build verification, commits, pushes, and opens a Pull Request. Activity logs stream every step. If the agent gets blocked, it asks a question; the PM answers, the agent resumes.

4. Verification before merge. Build status, test results, and Deploy Risk Assessment (build/test status, critical files touched, change size, open defects) are surfaced on the story before the human approves the merge. Every step of the loop emits telemetry into pb_agent_runs and pb_inference_traces, so the PM can audit why the agent made the calls it made.

The loop is what differentiates ProductIntel from product management software. Other tools manage the backlog. ProductIntel turns the backlog into shipped code with a verifiable audit trail.

3. AgentWeave: A Custom Multi-Agent Orchestration Framework

ProductIntel's AI backbone is AgentWeave, a purpose-built framework for orchestrating multiple LLM agents through a shared artifact graph.

What makes it different from LangChain or CrewAI:

Pointer-based context passing. Agents never pass full document content to each other. Instead, they exchange lightweight ArtifactPointer objects, each just a UUID and a 200-character summary. When an agent genuinely needs the full text, it explicitly calls fetchArtifact(). This lazy-loading pattern reduces token consumption by ~40x in multi-step pipelines compared to naive context forwarding.

// What agents pass to each other (cheap)
interface ArtifactPointer {
  id: string      // UUID reference
  summary: string // 200-char auto-generated summary
}

// What agents receive: never the full document
interface AgentInput {
  prompt: string
  pointers?: ArtifactPointer[]  // Summaries only
  trigger?: string              // Telemetry tag
  data?: Record<string, unknown>
}

Data-driven agent configuration. System prompts, model selection, tool permissions, and temperature settings all live in the database, not in code. An admin can change an agent's personality, swap its model from Claude Sonnet to Gemini Pro, or restrict its tool access without a deploy. Changes propagate within 60 seconds via a TTL cache.

Scoped tool access. Each agent has a toolsEnabled array that controls which tools it can call at runtime. The Discovery Agent can read artifacts and create graph edges but can't write new artifacts. The Product Owner can write stories but can't run vector searches. This follows the principle of least privilege: agents only have the capabilities their role requires.

Full reasoning trails. Every agent run logs the complete prompt, response, model used, temperature, input pointers, and output artifact to a JSONB column in pb_agent_runs. This enables post-hoc debugging ("why did the Analyst agent rate this finding as low-value?") and cost analysis per agent, per pipeline, per trigger.

The Five-Stage Pipeline

ProductIntel's core pipeline chains five agents, each consuming the previous agent's output as pointers:

Discovery → Analyst → Prototype → Persona → Product Owner

Discovery Agent scans recent artifacts and graph edges for patterns, contradictions, and gaps
Analyst Agent evaluates business value with a GO/NO-GO verdict and impact score
Prototype Agent generates a technical specification (architecture, data model, APIs, migrations)
Persona Agent runs multi-perspective evaluation (UX, Security, Sales, Engineering)
Product Owner Agent converts everything into developer-ready stories with acceptance criteria and story points

Each stage writes its output as a versioned artifact in the knowledge graph, creating a complete audit trail from discovery to implementation.

4. Unified Artifact Model with Knowledge Graph

Instead of separate tables for stories, documents, cases, and heuristics (the Jira/Confluence approach), ProductIntel uses a single pb_artifacts table with a type discriminator. Every piece of content is an artifact. Every artifact can connect to any other artifact via typed, directional edges in pb_knowledge_graph.

STORY   ←[IMPLEMENTS]→   DOC
CASE    ←[DERIVED_FROM]→ STORY
REQUEST ←[DERIVED_FROM]→ STORY
HEURISTIC ←[REFERENCES]→ API
DOC     ←[CONTRADICTS]→  DOC

Why this matters: When the Discovery Agent scans for patterns, it doesn't need separate queries for stories, docs, and cases. It queries one table, traverses one graph, and finds cross-cutting relationships that siloed tools miss entirely. A case report can surface a contradiction with a product spec, which triggers a finding, which generates a story, all connected through the same graph.

Six artifact types: STORY, DOC, CASE, API, HEURISTIC, REQUEST. The REQUEST type powers the customer-facing feature request pipeline. Today's Idea + Work Unit primitives ride on top of STORY via metadata tagging.

5. Context Engine: The RAG Foundation That Grounds Every AI Call

The Knowledge Base isn't a documentation feature. It's the RAG foundation that every AI capability draws from. Reframed as the "Context Engine," it's the single most important factor in AI effectiveness.

How it works:

Every AI recommendation, agent execution, and triage decision calls into shared utilities:

getRelevantContext(query), hybrid text search across the KB for any topic
getRecommendationContext(topic), lightweight context for AI services
getStoryContext(story), full context assembly for agent execution
formatContextForPrompt(context), formats retrieved docs for agent prompt injection

Quality scoring

getKBQualityScore() analyzes coverage across 7 categories (Architecture, Conventions, API Patterns, Business Rules, Testing Strategy, Deployment, Integrations) and returns a percentage score with specific gap recommendations. This drives the onboarding experience: users see exactly what's missing and why it matters.

Why this matters:

Without the Context Engine, AI agents are flying blind. They make generic suggestions that require constant human correction. With full context, they follow your team's actual conventions, API patterns, and business rules, reducing review cycles by an order of magnitude. The difference between ~70% and ~95% AI effectiveness is largely determined by Context Engine quality. Onboarding investment translates directly into AI quality.

6. Inference Inspector: "Why Did the AI Say This?"

Every LLM call captures a full inference trace to pb_inference_traces. This answers the question that no other product management tool can: why did the AI respond this way?

What's captured per trace:

User input: what was asked
Retrieved sources: which knowledge base articles matched, with similarity scores
Conversation history: prior messages that provided context
System prompt: base instructions given to the model
Assembled context: retrieval results formatted as prompt context
AI output: what the model returned
Performance: model used, tokens in/out, latency, estimated USD cost

Narrative explanation

Each trace includes a plain-English summary that non-technical admins can read:

"The AI drew from 3 knowledge base articles. It weighted 'API Rate Limits' most heavily (94% relevance), plus 2 others. The response used 847 tokens on Claude Haiku at an estimated cost of $0.001. Latency: 1.2s."

This is the differentiator from tools like Langfuse or Helicone. They show nested spans to engineers. ProductIntel shows a narrative explanation to non-technical stakeholders alongside the engineer view.

Stats dashboard

Aggregated views by source (Consumer Chat, AI Search, Co-pilot, AI Triage) and by model, showing total traces, token usage, cost trends, and average latency. Click any row to expand an inline narrative without navigating away.

7. Model Calibration: Right-Sizing LLM Costs

Most teams pick an LLM model once and never revisit it, even as cheaper models improve. ProductIntel's calibration system validates whether each agent is using the most cost-effective model for its task quality.

How it works:

Golden test cases: admin creates 3-5 representative inputs per agent with optional desired outputs
A/B comparison: select 2+ models (e.g., Sonnet vs. Haiku), system runs every test case through every model
Similarity scoring: cosine similarity between outputs and golden references via embeddings
Side-by-side review: admin sees outputs, token counts, latency, cost, and similarity scores for each model
Preference marking: "Mark as Preferred" buttons on each output for human judgment
One-click apply: selected model updates the agent registry immediately

Cost estimation

Per-model pricing baked into the comparison: each result shows estimated USD cost. Summary cards show total cost, average latency, and preference counts per model, making the cost/quality tradeoff visible at a glance.

8. AI Workforce Management: An Org Chart for AI Agents

A complete management layer for AI agent teams, the equivalent of HR + Ops for a virtual workforce.

Agent Roster & Profiles

Every agent has a "trading card" profile showing avatar, tier (Junior to Executive), specialties, model, success rate, badges, and defect history. Agents are created through a 6-step wizard or from 10 pre-built templates (Security Reviewer, Test Writer, Code Reviewer, DevOps Engineer, etc.).

Team Composition

Agents are assembled into teams with defined topologies:

Solo Agent: one agent handles everything
Supervised: a lead agent delegates to specialized members
Collaborative: peer agents hand off to each other
Hybrid: mix of AI agents and humans

Each team has goals, SOPs (Standard Operating Procedures), and performance metrics.

Agent Execution Pipeline

Stories assigned to agent teams can be executed directly from the UI:

Click "Execute with Agent" → job queued to Mac Mini worker
Worker creates an isolated git worktree (new branch from main)
Claude Code implements the story, runs build verification
Agent commits, pushes, and creates a Pull Request
Activity log shows real-time progress; agents can ask questions if blocked
Results (branch, PR, diff stats, work summary) written back to the story

Smart Assignment

A scoring algorithm recommends the best agent for each story based on 5 weighted factors: specialty match (35%), historical performance (25%), current workload (15%), model fit (15%), and defect history (10%). Bulk-assign an entire backlog in one click.

Real-Time Activity Monitor

A Datadog-style operations view polling every 5 seconds: active runs with elapsed time, queue depth, token burn rate, agent status grid (idle/active/error), and detailed execution logs showing every step the worker takes.

Performance Dashboard

Weekly AI-generated narrative briefing, key metrics with week-over-week deltas, agent leaderboard ranked by success rate, team standings, token distribution by agent, and project completion breakdowns.

Defect Tracking & Gamification

Every agent has a defect record (development bugs + post-deployment issues). Agents earn badges (First Run, Century, Zero Failures, etc.) and maintain streaks. Defect rates feed back into smart assignment scoring.

Team Strategy System

Each team has a configurable strategy profile:

Optimization modes: Quality / Speed / Cost / Security with radar chart visualization
Model hierarchy: team default provider/model with agent-level overrides
Supervisor configuration: 4 styles (Delegator, Coordinator, Director, Facilitator), delegation rules (by specialty, round-robin, availability, complexity), review behavior, escalation thresholds
Guardrails: safety rules injected into every agent's prompt
Team Creation Wizard: 6-step guided flow where AI analyzes a plain-English team description and recommends optimization weights, agent composition, guardrails, and risks

Training Arena: A/B Testing for AI Teams

Compare two team configurations against the same benchmark stories.

Create an experiment: name it, pick Team A and Team B, select stories
Both teams execute the same work (LLM-simulated for non-destructive comparison)
LLM-as-judge blind evaluation on completeness (30%), precision (40%), feasibility (30%)
Side-by-side comparison: tokens consumed, latency, quality scores, cost, cost efficiency (pts/$)
AI-generated narrative explaining which configuration won and why

This enables data-driven optimization of AI team structures.

Team Config Export

Export any team's configuration for use in external AI coding tools:

Claude Code: CLAUDE.md + .claude/skills/ per agent
Cursor: .cursorrules with team config and agent roles
GitHub Copilot: .github/copilot-instructions.md
Aider: .aider.conf.yml with model and conventions
Continue.dev: .continue/config.json
Raw JSON: full config for custom integrations

9. AI Triage: "What Needs Attention and Why"

The Work page opens with an AI-generated narrative briefing instead of a static list of stories. This is the core AI-first UX principle in action: every decision point presents an AI recommendation before manual controls.

What the triage panel shows:

AI narrative: natural language summary of what needs attention, why, and what to do
Recommended actions: specific stories with Execute Now, Smart Assign, Merge & Deploy, or Schedule buttons
Team status: active agents, queue depth, available capacity
Budget widget: monthly token spend, burn rate, projection, stories remaining
Deploy Risk Assessment: per-story risk analysis (build status, test status, critical files, change size, open defects)

Each recommended story includes an info popup showing estimated cost, development time, target environment, and risk level. The narrative is cached on a workload fingerprint so it regenerates only when the backlog state actually shifts.

Budget service:

Tracks monthly token spend from pb_agent_runs, calculates burn rate and projection, estimates stories remaining at current consumption rate. Returns a BudgetStatus with recommendation text that adapts based on spend trajectory.

10. Spec Pipeline with LLM Enrichment

Stories move through a 4-level spec maturity pipeline before they're ready for an agent to execute: Ideation → Ready for Refinement → Refined (Review) → Ready for Development. The pipeline lives in story metadata and is enforced by the agent execution gate.

LLM enrichment

A story written in 3 sentences gets enriched into an agent-ready spec: the LLM loads the original content + product context from the Context Engine, then generates file paths, tables to touch, components to create or modify, acceptance criteria, negative constraints, and error handling. The enriched spec is written back to the story, preserving the original in a collapsible details block. Single-story or batch enrichment, both via UI buttons.

Why this matters

Agents can't produce good code from vague specs. The Spec Pipeline forces refinement before execution, and the LLM enrichment step closes the gap between "PM wrote a sentence" and "agent can build it" without making the PM write a 2-page spec by hand.

11. Anti-Platform Architecture with Runtime Module Settings

ProductIntel is designed so that each company forks the repo and customizes organically: no multi-tenant complexity, no feature flag spaghetti, no plugin API to maintain.

Module Manifests

Every capability has a manifest declaring its metadata, file ownership, dependencies, and category:

{
  id: 'customer-features',
  name: 'Customer Features',
  category: 'optional',           // 'core' modules can't be disabled
  requires: ['consumer-chat'],    // dependency chain
  dataSources: ['native'],        // future: ['native', 'jira']
  files: {
    schema: 'src/lib/db/modules/customer-features.ts',
    services: ['feature-requests.ts', 'roadmap.ts', 'votes.ts'],
    apiRoutes: ['api/consumer-chat/feature-requests/', ...],
    pages: ['admin/feature-requests/', 'admin/roadmap/'],
  },
}

Three-layer configuration

Manifests (code), define what modules exist, their files, and defaults
Database (pb_module_settings), runtime overrides per deployment
Admin UI (/admin/modules), toggle modules on/off instantly

Core modules (Dashboard, Work, Knowledge, Admin) are always on. You can choose the data source (Native vs. Jira, Native vs. Confluence) but you can't hide them.

Optional modules (Cases, Strategy, Accounts, Intelligence Hub, Skill Wallet, Consumer Chat, Customer Features, Calibration, Inference Inspector) can be toggled off from the UI. Dependency validation prevents disabling a module that another enabled module requires.

Schema split for merge-friendly forks

Core tables in schema-core.ts (upstream-owned, never modified in forks). Module tables in modules/*.ts (fork-customizable). Thin schema.ts re-export index. Upstream adds new modules; forks merge them in with minimal conflicts.

12. Customer-Facing Feature Suite

ProductIntel isn't just an internal tool. It includes a full customer engagement layer: external APIs authenticated via API keys that let a company's end-users interact with the product team's data.

Feature Requests and Voting

Customers submit feature requests via API. Each request becomes a REQUEST artifact in the knowledge graph. Other customers can vote on requests (unique constraint prevents double-voting). Admins see requests in a filterable table with vote counts, source tracking, and a one-click "Convert to Story" action that:

Creates a STORY artifact with [From Request] prefix
Links it via DERIVED_FROM edge
Triggers Librarian Agent enrichment in the background
Marks the request as "planned"

Public Roadmap

A curated junction table (pb_roadmap_items) decouples admin presentation from the artifact model. Admins add stories and requests to the roadmap with customer-friendly display titles, categories, target quarters, and visibility toggles. The external API returns a three-column board (Planned / In Progress / Shipped), only visible items.

Surveys and Voice of Customer

Full survey engine supporting NPS, CSAT, CES, and custom survey types. Question builder with five types (rating, NPS 0-10, text, single choice, multi choice). Results dashboard with per-question breakdown, average scores, and standard NPS/CSAT calculation (% promoters - % detractors).

Release Notes

AI-generated customer-friendly changelogs from sprint data. Gathers completed stories, filters to customer-facing ones, and generates benefit-focused Markdown release notes using resolveModel('release-notes'). Published as DOC artifacts with audience='customer'.

Consumer Chat (RAG)

API-key-authenticated chatbot backed by vector search over curated knowledge base articles. Admins select which docs are searchable, configure the system prompt, and manage API keys with rate limits.

13. Security System: 8-Scanner Pipeline with Auto-Fix

A daily security scan runs an 8-scanner pipeline against the codebase: npm audit, outdated packages, exposed secrets, missing auth guards on API routes, SQL injection vectors, XSS via dangerouslySetInnerHTML, RLS coverage on public schema tables, and exposure of sensitive columns. Findings auto-create stories tagged with severity, scanner source, and an incident timeline.

Auto-fix pipeline

Critical findings get auto-routed: assigned to the Platform Security team (with a Security Reviewer agent as lead), set to in_progress, queued for agent execution, with admin email + Discord notification. When a re-scan finds the issue resolved, the story auto-closes. Most days the security board is empty by lunchtime.

Why this matters

Security automation usually means alerts. ProductIntel's pipeline closes the loop: detect, route, fix, verify. The same agent execution infrastructure that delivers feature stories also delivers security fixes.

14. Tiered Onboarding: Minimum Viable Context

Getting product context into the system is the critical path to AI effectiveness. ProductIntel offers four onboarding tiers based on time investment:

Tier	Time	AI Relevance	Method
Quick Start	~5 min	~70%	17-field structured form (product name, tech stack, conventions, patterns)
Full Documentation	~30 min	~95%	5 category documents with rich templates and AI-assisted writing
Code Import	~10 min	~85%	Local agent scans repo structure, configs, and patterns (planned)
Website Crawler	~2 min	~60%	AI scrapes public pages for product context (planned)

Full Documentation workflow

Each of the 5 categories (Architecture, Conventions, API Patterns, Business Rules, Testing Strategy) supports three input methods:

Write: rich text editor pre-filled with a detailed template
Upload: drag-and-drop any file; AI converts to standard template format
Download Template: offline editing

Upload conversion uses an LLM to intelligently restructure arbitrary documents into the standard template format, ensuring consistent KB structure regardless of input quality.

15. AI-Powered Demo Client Generator

An admin tool for generating industry-realistic demo environments in under a minute. Describe a company and AI generates a complete profile with industry-specific products, stories, docs, cases, feature requests, and customer data.

Industry presets: Fintech, Health Tech, EdTech, SaaS/B2B, E-Commerce.

./scripts/setup-client.sh paystream --profile=profiles/paystream.json
DATABASE_URL=postgresql://localhost:5432/productintel_paystream PORT=3001 npm run dev

Creates a complete, isolated database instance with realistic data. Every story, doc, and feature request feels like it came from a real company in that industry.

16. Observer Agent and Skill Wallet

The Observer Agent watches how teams use the platform by analyzing API observation logs. It extracts behavioral patterns that become heuristics: learned rules with confidence scores, categories, and source attribution. The Skill Wallet provides a review workflow where team leads approve, dismiss, or deactivate heuristics. Approved heuristics feed into other agents. The platform literally learns how a team works.

17. Personal AI Co-pilot with Persona Accumulation

The Co-pilot builds a persona profile for each user by accumulating observations about their work patterns. Five-layer context assembly (user metadata, persona, assigned stories, API activity, recent artifacts) makes every conversation more relevant. Streaming responses with async persistence, proactive actionable suggestions, and a draggable floating widget with viewport-aware positioning.

18. What This Demonstrates

Capability	Evidence
Adoption-aware product design	Today + Work modules with company-level work-mode preference; supports agent-native, hybrid, and traditional teams in one product
Multi-agent system design	21 agents across 7 teams, 5-stage pipeline, pointer-based context, tool scoping
AI-first UX design	AI triage as default view, recommendations before controls, budget-aware assignment
RAG infrastructure	Context Engine with tiered onboarding, quality scoring, 7-category coverage analysis
Knowledge graph architecture	Unified artifact model, typed directional edges, confidence scoring
Enterprise AI patterns	Token tracking, reasoning trails, cost optimization, audit trails, budget service
Customer-facing AI products	RAG chatbot, feature requests, voting, roadmap, surveys, release notes
LLM observability	Inference traces with retrieval attribution and narrative explanations
AI cost optimization	Model calibration with golden test cases, A/B comparisons, Training Arena for teams
Autonomous agent execution	Mac Mini worker with git worktrees, PR creation, build/test verification, feedback loop
Security automation	8-scanner pipeline with auto-routing to Platform Security team, auto-fix via agent execution, auto-close on re-scan
Spec maturity engineering	4-level Spec Pipeline with LLM enrichment that bridges vague PM input to agent-ready specs
Full-stack proficiency	Next.js 16, React 19, PostgreSQL 17, pgvector, streaming, drag interactions, mobile web
Production thinking	Graceful degradation, idempotent operations, cache strategies (workload-fingerprint TTL), error boundaries
Platform architecture	21 modules in 6 groups, runtime settings, schema splits, fork-friendly design
Data-driven configuration	Agent registry, model config, module settings; behavior changes without deploys
Onboarding design	Tiered context ingestion (5 min to 30 min), upload with AI conversion, quality scoring
AI workforce management	Agent roster, team composition, strategy profiles, supervisor config, A/B testing

Architecture at a Glance

┌──────────────────────────────────────────────────────────────┐
│                    Next.js 16 App Router                      │
│                                                              │
│   Today (daily cycle)        Work (sprint mode)              │
│   ┌────────────────────┐    ┌──────────────────────┐         │
│   │ Capture            │    │ AI Triage            │         │
│   │ Refine             │    │ Backlog              │         │
│   │ Plan               │    │ Spec Pipeline        │         │
│   │ Execute            │    │ Board                │         │
│   │ Finalize           │    │ Completed            │         │
│   └────────────────────┘    └──────────────────────┘         │
│       (work_mode = 'agent', 'dual', or 'human')              │
│                                                              │
│  Workspace          AI Workforce      Intelligence           │
│  ┌─────────────┐    ┌────────────┐    ┌───────────────┐     │
│  │Dashboard    │    │Roster      │    │Strategy       │     │
│  │Knowledge    │    │Teams       │    │Industry Intel │     │
│  │Cases        │    │Monitor     │    │Behaviors      │     │
│  └─────────────┘    │Leaderboard │    └───────────────┘     │
│                     └────────────┘                          │
│                                                              │
│  Customers          AI Operations     Settings               │
│  ┌─────────────┐    ┌────────────┐    ┌───────────────┐     │
│  │Accounts     │    │Calibration │    │Admin          │     │
│  │Features     │    │Inference   │    │Onboarding     │     │
│  │Consumer Chat│    │Security    │    │               │     │
│  └─────────────┘    └────────────┘    └───────────────┘     │
├──────────────────────────────────────────────────────────────┤
│                    Context Engine (RAG)                       │
│  Product knowledge → Embedding pipeline → Agent injection    │
│  Quality scoring → Tiered onboarding → 7-category coverage  │
├──────────────────────────────────────────────────────────────┤
│                    AgentWeave Engine                          │
│  ┌─────────┐ ┌────────┐ ┌─────────┐ ┌───────────────────┐  │
│  │Discovery│→│Analyst │→│Prototype│→│  Product Owner     │  │
│  └─────────┘ └────────┘ └─────────┘ └───────────────────┘  │
│  Observer · Librarian · Copilot · +12 more (21 total)       │
├──────────────────────────────────────────────────────────────┤
│  PostgreSQL 17 + pgvector · ~85 tables                       │
│  pb_artifacts (unified) ←→ pb_knowledge_graph (edges)        │
│  ai_agent_registry · pb_inference_traces · pb_model_config   │
└──────────────────────────────────────────────────────────────┘

Running Locally

git clone https://github.com/mikeh883/productbrain.git
cp .env.local.example .env.local  # Add your API keys
brew services start postgresql@17
npm install && npm run dev

Set up a demo client in one command:

./scripts/setup-client.sh acme --profile=profiles/acme.json
DATABASE_URL=postgresql://localhost:5432/productintel_acme PORT=3001 npm run dev

Tests:

npm run test:api          # Vitest API smoke tests
npm run test:e2e          # Playwright E2E suite (Chromium)

Built by Mike Holloway. mikeholloway.dev

The original portfolio showcase.

ProductIntel: Technical Showcase

Why This Project Exists

1. Two Workflows, One Platform

Today module: daily-cycle workflow

Work module: sprint-based workflow

Adoption-aware design

2. From Vague Input to Validated Code Change

3. AgentWeave: A Custom Multi-Agent Orchestration Framework

What makes it different from LangChain or CrewAI:

The Five-Stage Pipeline

4. Unified Artifact Model with Knowledge Graph

5. Context Engine: The RAG Foundation That Grounds Every AI Call

How it works:

Quality scoring

Why this matters:

6. Inference Inspector: "Why Did the AI Say This?"

What's captured per trace:

Narrative explanation

Stats dashboard

7. Model Calibration: Right-Sizing LLM Costs

How it works:

Cost estimation

8. AI Workforce Management: An Org Chart for AI Agents

Agent Roster & Profiles

Team Composition

Agent Execution Pipeline

Smart Assignment

Real-Time Activity Monitor

Performance Dashboard

Defect Tracking & Gamification

Team Strategy System

Training Arena: A/B Testing for AI Teams

Team Config Export

9. AI Triage: "What Needs Attention and Why"

What the triage panel shows:

Budget service:

10. Spec Pipeline with LLM Enrichment

LLM enrichment

Why this matters

11. Anti-Platform Architecture with Runtime Module Settings

Module Manifests

Three-layer configuration

Schema split for merge-friendly forks

12. Customer-Facing Feature Suite

Feature Requests and Voting

Public Roadmap

Surveys and Voice of Customer

Release Notes

Consumer Chat (RAG)

13. Security System: 8-Scanner Pipeline with Auto-Fix

Auto-fix pipeline

Why this matters

14. Tiered Onboarding: Minimum Viable Context

Full Documentation workflow

15. AI-Powered Demo Client Generator

16. Observer Agent and Skill Wallet

17. Personal AI Co-pilot with Persona Accumulation

18. What This Demonstrates

Architecture at a Glance

Running Locally

Set up a demo client in one command: