🎯 Repository Quality Improvement - MCP Integration Quality & Developer Experience

[github-actions[bot]]

🎯 Repository Quality Improvement Report - MCP Integration Quality & Developer Experience

Analysis Date: 2025-11-28
Focus Area: MCP Integration Quality & Developer Experience
Strategy Type: Custom
Custom Area: Yes - This focus area examines the quality of MCP (Model Context Protocol) server integration, configuration patterns, developer experience, tooling discoverability, and documentation completeness. MCP is a core extensibility mechanism in gh-aw that enables workflow authors to integrate external tools and services.

Executive Summary

The MCP integration in gh-aw demonstrates strong technical foundation with 73 Go files, 125+ functions, 49 test files, and robust error handling (80% of errors include examples). However, there are significant opportunities to improve developer experience and adoption:

• Low workflow adoption: Only 15.2% of workflows (21 of 138) use MCP configurations
• Configuration pattern migration needed: 39 workflows still use legacy allowed: pattern instead of modern toolsets: approach
• Rich example library underutilized: 19 shared MCP workflow templates exist but low discoverability
• Documentation scattered: MCP guidance spread across 21 documentation files with varying quality
• CLI tool discoverability: Powerful MCP CLI commands (inspect, list-tools, add) lack comprehensive help text and examples

The analysis reveals a mature implementation with adoption barriers - the technology is solid, but workflow authors need better guidance, examples, and tooling to leverage MCP servers effectively.

Full Analysis Report

Focus Area: MCP Integration Quality & Developer Experience

Current State Assessment

Metrics Collected:

Metric	Value	Status
MCP-related Go files	73 files	✅ Comprehensive
Total MCP functions	125+ functions	✅ Feature-rich
Test coverage files	49 test files	✅ Well-tested
Integration tests	9 files (1 live)	✅ Strong
Workflow adoption rate	15.2% (21/138)	⚠️ Low adoption
Workflows using toolsets	~20%	⚠️ Migration needed
Workflows using allowed	39 workflows	⚠️ Legacy pattern
Shared MCP templates	19 examples	✅ Good library
MCP error messages with examples	80% (4/5)	✅ High quality
Documentation files	21 files	⚠️ Scattered
CLI command files	18 files	✅ Feature-complete
Lines in mcp-config.go	962 lines	⚠️ Complex
Lines in mcp_renderer.go	637 lines	⚠️ Large
Total MCP CLI code	10,900 lines	✅ Rich tooling

Findings

Strengths

1. Robust Implementation Foundation

   • 73 MCP-related Go files with well-organized code structure
   • 125+ functions providing comprehensive MCP functionality
   • Strong separation of concerns (config, rendering, servers, CLI)

2. Excellent Test Coverage

   • 49 dedicated MCP test files
   • 9 integration test files including 1 live integration test
   • Comprehensive validation test suite

3. High-Quality Error Messages

   • 80% of MCP configuration errors include examples (4 out of 5)
   • Clear validation messages guide users to correct syntax
   • Example-enhanced error messages follow project standards

4. Rich Shared Workflow Library

   • 19 shared MCP workflow templates in .github/workflows/shared/mcp/
   • Covers diverse MCP servers: arxiv, ast-grep, azure, brave, context7, datadog, deepwiki, drain3, fabric-rti, gh-aw, jupyter, markitdown, and more
   • Provides ready-to-use examples for common integrations

5. Powerful CLI Tooling

   • 10,900 lines of MCP CLI code across 18 command files
   • Comprehensive commands: mcp list, mcp inspect, mcp add, mcp list-tools
   • MCP registry integration with DefaultMCPRegistryURL

6. Well-Documented GitHub MCP Server

   • 269-line instruction file at .github/instructions/github-mcp-server.instructions.md
   • 27 toolset references with clear guidance
   • Covers local/remote modes, authentication, toolsets, and best practices

Areas for Improvement

1. Low Workflow Adoption (15.2%)

   • Only 21 of 138 workflows use MCP configurations
   • Indicates either:
     • Lack of awareness about MCP capabilities
     • High perceived complexity/friction
     • Insufficient documentation/examples
     • Tooling not discoverable enough

2. Legacy Configuration Pattern Prevalence

   • 39 workflows still use allowed: pattern
   • Modern toolsets: approach provides better organization and reduced verbosity
   • No automated migration guide or linter to detect this anti-pattern

3. Scattered Documentation

   • MCP guidance spread across 21 documentation files
   • No single comprehensive "Getting Started with MCP" guide
   • Toolsets documentation mentions (29 references) not centralized
   • Troubleshooting distributed across multiple files

4. CLI Help Text Gaps

   • Help text presence: Only 8 Short/Long/Usage descriptions found across main MCP CLI files
   • Powerful commands like mcp inspect, mcp list-tools, mcp add lack comprehensive help
   • No embedded examples in CLI help output

5. Code Complexity in Core Files

   • mcp-config.go: 962 lines with 211 cyclomatic complexity indicators
   • mcp_renderer.go: 637 lines
   • mcp_servers.go: 481 lines
   • Opportunities for further modularization

6. Limited Discoverability Features

   • No tool table rendering found in MCP CLI code
   • Schema display limited (only 1 reference in mcp_inspect.go)
   • No visual aids or interactive exploration features

Detailed Analysis

Configuration Patterns

Current State:

• Modern toolsets: pattern emerging in newer workflows
• Legacy allowed: pattern still dominant in 39 workflows
• GitHub MCP server uses both local (Docker) and remote modes effectively

Examples of Modern Pattern:

tools:
  github:
    toolsets: [repos, issues, pull_requests]

Examples of Legacy Pattern:

tools:
  github:
    allowed: [get_repository, list_commits, create_issue]

Migration Opportunity:
The toolsets: approach provides:

• Better organization and discoverability
• Reduced configuration verbosity
• Automatic inclusion of new tools as they're added
• Clear semantic grouping

Documentation Structure

Current Documentation Distribution:

• Main guide: docs/src/content/docs/guides/mcps.md (7,285 bytes)
• Reference: docs/src/content/docs/reference/frontmatter-full.md (3 github: refs)
• Reference: docs/src/content/docs/reference/tools.md (7 github: refs)
• Troubleshooting: docs/src/content/docs/troubleshooting/common-issues.md (10 MCP refs)
• Troubleshooting: docs/src/content/docs/troubleshooting/errors.md (25 MCP refs)
• Instructions: .github/instructions/github-mcp-server.instructions.md (269 lines)
• Instructions: .github/instructions/http_mcp_headers.instructions.md

Gap Analysis:

• No centralized "Quick Start" guide for MCP beginners
• Toolsets documentation scattered (29 mentions across files)
• No migration guide from allowed: to toolsets:
• Limited MCP CLI command documentation

Developer Experience Journey

Current Workflow Author Journey:

1. ❌ Discovery: Hard to find MCP capabilities without prior knowledge
2. ⚠️ Learning: Documentation scattered, no single entry point
3. ⚠️ Configuration: Examples exist but not prominent
4. ⚠️ Debugging: Excellent CLI tools but low discoverability
5. ✅ Troubleshooting: Good error messages with examples

Ideal Journey Should Be:

1. ✅ Discovery: Clear documentation, prominent examples
2. ✅ Learning: Single comprehensive guide with progressive complexity
3. ✅ Configuration: Modern patterns recommended, legacy patterns deprecated
4. ✅ Debugging: CLI tools discoverable with rich help text
5. ✅ Troubleshooting: Error messages + linked documentation

---

🤖 Tasks for Copilot Agent

NOTE TO PLANNER AGENT: The following tasks are designed for GitHub Copilot agent execution. Please split these into individual work items for Claude to process.

Improvement Tasks

The following code regions and tasks should be processed by the Copilot agent. Each section is marked for easy identification by the planner agent.

Task 1: Create Comprehensive "Getting Started with MCP" Guide

Priority: High
Estimated Effort: Medium
Focus Area: Documentation

Description:
Create a single, comprehensive "Getting Started with MCP" guide that consolidates scattered MCP documentation and provides a clear onboarding path for workflow authors. The guide should cover MCP fundamentals, modern configuration patterns (toolsets), practical examples, and common use cases.

Acceptance Criteria:

• New guide at docs/src/content/docs/guides/getting-started-mcp.md
• Covers: What is MCP, Why use MCP, Basic configuration, Toolsets vs allowed, GitHub MCP server, Custom MCP servers
• Includes 5+ practical examples with progressive complexity
• Links to existing detailed documentation where appropriate
• Includes troubleshooting quick reference
• Uses Diátaxis tutorial format (learning-oriented, step-by-step)

Code Region: docs/src/content/docs/guides/

Create a comprehensive "Getting Started with MCP" guide at `docs/src/content/docs/guides/getting-started-mcp.md`.

The guide should follow the Diátaxis tutorial framework (learning-oriented) and include:

1. **Introduction** (What is MCP?)
   - Brief explanation of Model Context Protocol
   - Why gh-aw uses MCP for extensibility
   - Benefits for workflow authors

2. **Quick Start** (5-minute setup)
   - Simplest possible MCP configuration
   - Using GitHub MCP server with default toolsets
   - First workflow example that uses MCP

3. **Modern Configuration Patterns**
   - **Toolsets approach** (recommended)
   - Legacy `allowed:` approach (deprecated)
   - Migration guidance from allowed to toolsets
   - When to use which pattern

4. **GitHub MCP Server Deep Dive**
   - Available toolsets: context, repos, issues, pull_requests, actions, etc.
   - Local vs remote modes
   - Authentication and tokens
   - Common configurations

5. **Custom MCP Servers**
   - When to use custom MCP servers
   - Configuration examples (HTTP, stdio, container)
   - Shared MCP workflow library (point to .github/workflows/shared/mcp/)

6. **Practical Examples** (Progressive complexity)
   - Example 1: Simple GitHub operations with default toolsets
   - Example 2: Targeted toolset selection for specific use case
   - Example 3: HTTP MCP server integration
   - Example 4: Custom MCP server with Docker container
   - Example 5: Multi-MCP server workflow

7. **Debugging MCP Configurations**
   - Using `gh aw mcp inspect` command
   - Using `gh aw mcp list-tools` command
   - Common configuration errors
   - Validation tips

8. **Troubleshooting Quick Reference**
   - Authentication issues
   - Tool not found errors
   - Network permission problems
   - Schema validation failures

9. **Next Steps**
   - Link to comprehensive MCP reference
   - Link to shared MCP workflow library
   - Link to MCP CLI commands documentation

Use clear, concise language. Include code examples with syntax highlighting. Follow Astro Starlight MDX syntax with appropriate callouts (:::note, :::tip, :::caution).

---

Task 2: Migrate Documentation to Recommend Toolsets Over Allowed

Priority: High
Estimated Effort: Medium
Focus Area: Documentation

Description:
Update all MCP-related documentation to recommend the modern toolsets: configuration approach over the legacy allowed: pattern. Add deprecation notices for allowed: usage, migration guidance, and update all examples to use toolsets.

Acceptance Criteria:

• All documentation examples updated to use toolsets: approach
• Deprecation notice added for allowed: pattern
• Migration guide created (how to convert allowed to toolsets)
• GitHub MCP instruction file updated with toolsets-first approach
• Troubleshooting docs include toolsets-related issues
• Reference documentation clearly marks allowed as legacy

Code Region: docs/src/content/docs/**/*.md, .github/instructions/github-mcp-server.instructions.md

Update all MCP-related documentation to recommend the modern `toolsets:` configuration approach.

Tasks:

1. **Update Main MCP Guide** (`docs/src/content/docs/guides/mcps.md`)
   - Lead with toolsets approach in all examples
   - Add deprecation callout for allowed pattern
   - Show side-by-side comparison of toolsets vs allowed

2. **Update GitHub MCP Instruction File** (`.github/instructions/github-mcp-server.instructions.md`)
   - Reorder sections to put toolsets first
   - Add "Migration from allowed to toolsets" section
   - Update all examples to use toolsets
   - Keep allowed pattern in "Legacy Support" section at end

3. **Update Reference Documentation** (`docs/src/content/docs/reference/tools.md`)
   - Mark `allowed:` as legacy/deprecated
   - Emphasize `toolsets:` as recommended approach
   - Add migration examples

4. **Create Migration Guide**
   - New section in getting-started-mcp.md or separate guide
   - Provide mapping: common allowed patterns → equivalent toolsets
   - Include automated migration suggestions if possible

5. **Update Troubleshooting** (`docs/src/content/docs/troubleshooting/*.md`)
   - Add troubleshooting for toolsets-specific issues
   - Include "Tool not found" → "Check toolsets configuration"

Example deprecation callout to add:
```markdown
:::caution[Legacy Configuration Pattern]
The `allowed:` configuration pattern is deprecated in favor of `toolsets:`. The `toolsets:` approach provides better organization, reduced verbosity, and automatic inclusion of new tools.

**Legacy (not recommended):**
```yaml
tools:
  github:
    allowed: [get_repository, list_commits, create_issue]

Modern (recommended):

tools:
  github:
    toolsets: [repos, issues]

:::

Ensure all documentation follows Astro Starlight MDX syntax and maintains consistency with the project's documentation style guide.

---

Task 3: Enhance MCP CLI Help Text and Examples

Priority: Medium
Estimated Effort: Medium
Focus Area: Developer Tooling

Description:
Enhance the help text for MCP CLI commands (mcp inspect, mcp list-tools, mcp add, mcp list) to include comprehensive descriptions, usage examples, and practical scenarios. Add embedded examples to make commands more discoverable and easier to use.

Acceptance Criteria:

• All MCP commands have comprehensive Short and Long descriptions
• Each command includes 2-3 usage examples in help text
• Common flags documented with examples
• Output format examples shown
• Help text follows consistent format across all MCP commands
• Examples cover common use cases

Code Region: pkg/cli/mcp.go, pkg/cli/mcp_list.go, pkg/cli/mcp_inspect.go, pkg/cli/mcp_add.go, pkg/cli/mcp_list_tools.go

Enhance help text for all MCP CLI commands to improve discoverability and usability.

Update the following files:

1. **pkg/cli/mcp.go** (Main MCP command)
   - Enhance Short description to be more descriptive
   - Add Long description with overview of subcommands
   - Include example: `gh aw mcp list`, `gh aw mcp inspect workflow-name`

2. **pkg/cli/mcp_list.go** (List workflows with MCP configs)
   - Enhance Short: "List all workflows that use MCP server configurations"
   - Add Long description explaining output format
   - Include examples:
     - Basic: `gh aw mcp list`
     - With filters: `gh aw mcp list --verbose`

3. **pkg/cli/mcp_inspect.go** (Inspect MCP servers)
   - Enhance Short: "Inspect MCP server configurations and available tools"
   - Add Long description explaining inspection capabilities
   - Include examples:
     - List all MCP in workflow: `gh aw mcp inspect workflow-name`
     - Specific server: `gh aw mcp inspect workflow-name --server github`
     - Specific tool: `gh aw mcp inspect workflow-name --server github --tool create_issue`

4. **pkg/cli/mcp_list_tools.go** (List tools from MCP server)
   - Enhance Short: "List all tools available from a specific MCP server"
   - Add Long description with use cases
   - Include examples:
     - Find workflows: `gh aw mcp list-tools github`
     - List tools: `gh aw mcp list-tools github workflow-name`

5. **pkg/cli/mcp_add.go** (Add MCP server to workflow)
   - Enhance Short: "Add an MCP server configuration to a workflow"
   - Add Long description with registry integration
   - Include examples:
     - From registry: `gh aw mcp add tavily-search my-workflow`
     - Custom server: `gh aw mcp add --url (redacted) my-workflow`

**Help Text Format Template:**
```go
Short: "Brief one-line description of command purpose",
Long: `Detailed description of what the command does and when to use it.

EXAMPLES:
  # Example 1 description
  gh aw mcp (command) (args)

  # Example 2 description
  gh aw mcp (command) --flag (args)

  # Example 3 description
  gh aw mcp (command) --flag1 --flag2 (args)

OUTPUT:
  Brief description of output format or what to expect
`,

Follow existing gh-aw CLI patterns for help text formatting and style.

---

#### Task 4: Add MCP Configuration Linter for Legacy Patterns

**Priority**: Medium  
**Estimated Effort**: Large  
**Focus Area**: Tooling

**Description:**
Create a linter or compilation warning system that detects legacy `allowed:` patterns in MCP configurations and suggests migration to modern `toolsets:` approach. The linter should run during `gh aw compile` and provide actionable migration guidance.

**Acceptance Criteria:**
- [ ] Linter detects `allowed:` usage in GitHub MCP configurations
- [ ] Warning message suggests equivalent `toolsets:` configuration
- [ ] Provides migration guidance with specific tool-to-toolset mapping
- [ ] Optional `--strict-mcp` flag to fail compilation on legacy patterns
- [ ] Warning includes link to migration documentation
- [ ] Integration test coverage for linter functionality

**Code Region:** `pkg/workflow/mcp_config_validation.go`, `pkg/workflow/compiler.go`

```markdown
Create an MCP configuration linter that detects legacy patterns and suggests modernization.

Implementation plan:

1. **Create Linter Function** in `pkg/workflow/mcp_config_validation.go`
   ```go
   // LintMCPConfiguration checks MCP configurations for legacy patterns
   // and returns warnings with migration suggestions
   func LintMCPConfiguration(tools map[string]any) []LintWarning {
       var warnings []LintWarning
       
       // Check for 'allowed' pattern in GitHub MCP
       if githubConfig, ok := tools["github"]; ok {
           if hasAllowedField(githubConfig) {
               warnings = append(warnings, LintWarning{
                   Type:    "legacy-allowed-pattern",
                   Message: "GitHub MCP using legacy 'allowed' pattern",
                   Suggestion: generateToolsetSuggestion(githubConfig),
                   Documentation: "(redacted)",
               })
           }
       }
       
       return warnings
   }

2. Integrate into Compiler in pkg/workflow/compiler.go

   • Call linter during MCP configuration processing
   • Emit warnings to console using console.FormatWarningMessage
   • Respect --strict-mcp flag to convert warnings to errors

3. Tool-to-Toolset Mapping Logic

   • Create mapping of common allowed tools to equivalent toolsets
   • Example: [get_repository, list_commits] → [repos]
   • Example: [create_issue, add_labels] → [issues]
   • Example: [list_pull_requests, create_pull_request] → [pull_requests]

4. Warning Message Format

   ⚠️  Legacy MCP Configuration Pattern Detected
   
   Workflow: example-workflow.md
   Issue: GitHub MCP using deprecated 'allowed' pattern
   
   Current configuration:
   ```yaml
   tools:
     github:
       allowed: [get_repository, list_commits, create_issue]
   

   Recommended modern configuration:

   tools:
     github:
       toolsets: [repos, issues]

   Learn more: (redacted)#migration

5. Add Tests

   • Test detection of allowed pattern
   • Test toolset suggestion generation
   • Test strict mode enforcement
   • Test warning message formatting

6. Update Compilation Flags

   • Add --strict-mcp flag to enable strict MCP validation
   • Document flag in CLI help and compilation documentation

---

#### Task 5: Create Interactive MCP Explorer Documentation

**Priority**: Low  
**Estimated Effort**: Medium  
**Focus Area**: Documentation

**Description:**
Create an interactive documentation page that showcases available MCP servers, their toolsets, common configurations, and links to the 19 shared MCP workflow templates. This page should serve as a discovery hub for workflow authors exploring MCP capabilities.

**Acceptance Criteria:**
- [ ] New page at `docs/src/content/docs/reference/mcp-explorer.md`
- [ ] Organized by MCP server type (GitHub, HTTP, Custom)
- [ ] Links to all 19 shared MCP workflow templates
- [ ] Shows toolsets available for GitHub MCP server
- [ ] Includes configuration snippets for each MCP type
- [ ] Uses Astro Starlight Card components for visual organization
- [ ] Search-friendly (good metadata, headings, keywords)

**Code Region:** `docs/src/content/docs/reference/`

```markdown
Create an interactive MCP Explorer reference page at `docs/src/content/docs/reference/mcp-explorer.md`.

Structure:

1. **Frontmatter**
   ```yaml
   ---
   title: MCP Server Explorer
   description: Discover available MCP servers, toolsets, and ready-to-use templates for your workflows
   ---

2. Introduction

   • Brief overview of MCP server ecosystem
   • How to use this explorer
   • Link to getting-started guide for beginners

3. GitHub MCP Server (Featured section)

   • Overview of GitHub MCP server
   • Complete list of available toolsets (use CardGrid)
   • Example configuration for each toolset
   • Authentication modes (local/remote)

4. Shared MCP Workflow Templates (Major section)

   • Introduction to template library
   • CardGrid showcasing all 19 templates:
     • arxiv (Research paper search)
     • ast-grep (Code pattern search)
     • azure (Azure cloud operations)
     • brave (Web search)
     • context7 (Context management)
     • datadog (Monitoring and metrics)
     • deepwiki (Wikipedia search)
     • drain3 (Log parsing)
     • fabric-rti (Fabric integration)
     • gh-aw (Workflow introspection)
     • jupyter (Notebook execution)
     • markitdown (Markdown conversion)
     • And 7 more
   • Each card should include:
     • Server name
     • Brief description
     • Link to template file
     • Common use cases

5. HTTP MCP Servers

   • Configuration pattern
   • Authentication with headers
   • Example servers from templates

6. Custom MCP Servers

   • When to create custom MCP servers
   • Configuration patterns (stdio, container)
   • Links to examples

7. Quick Reference Table

   • Table of all available MCP configurations
   • Columns: Server Name, Type, Key Features, Template Link

Use Astro Starlight components:

import { Card, CardGrid } from '`@astrojs/starlight`/components';

(CardGrid)
  (Card title="GitHub MCP Server" icon="github")
    Access GitHub API with toolsets for repos, issues, PRs, and more.
    [View template →](.github/workflows/shared/mcp/gh-aw.md)
  (/Card)
  
(/CardGrid)

Make it visually appealing, scannable, and discovery-focused.

---

## 📊 Historical Context

<details>
<summary><b>Previous Focus Areas</b></summary>

| Date | Focus Area | Type | Custom | Key Outcomes |
|------|------------|------|--------|--------------|
| 2025-11-25 | workflow-observability-debugging | Custom | Y | Error message quality analysis, logging infrastructure review |
| 2025-11-26 | workflow-compilation-consistency | Custom | Y | Shared workflow compilation gaps, automation opportunities |
| 2025-11-27 | ci-cd | Standard | N | GitHub Actions pipeline analysis, caching strategies |
| 2025-11-28 | mcp-integration-quality | Custom | Y | MCP adoption analysis, configuration patterns, developer experience |

**Strategy Statistics:**
- Total runs: 4
- Custom rate: 75%
- Unique areas explored: 4
- Reuse rate: 0%

</details>

---

## 🎯 Recommendations

### Immediate Actions (This Week)
1. **Create "Getting Started with MCP" Guide** - Priority: High - Consolidate scattered documentation into single comprehensive onboarding guide
2. **Migrate Documentation to Toolsets-First Approach** - Priority: High - Update all examples and add deprecation notices for `allowed:` pattern

### Short-term Actions (This Month)
1. **Enhance MCP CLI Help Text** - Priority: Medium - Add comprehensive descriptions and examples to all MCP commands
2. **Create MCP Configuration Linter** - Priority: Medium - Detect legacy patterns and suggest modernization during compilation

### Long-term Actions (This Quarter)
1. **Create Interactive MCP Explorer** - Priority: Low - Build discovery hub for MCP servers and templates
2. **Refactor Large MCP Files** - Priority: Low - Split mcp-config.go (962 lines) into smaller, focused modules
3. **Improve MCP Tool Discoverability** - Enhance CLI with visual tool tables and schema displays

---

## 📈 Success Metrics

Track these metrics to measure improvement in **MCP Integration Quality & Developer Experience**:

- **Workflow adoption rate**: 15.2% → 30% (double adoption within 3 months)
- **Legacy pattern usage**: 39 workflows → 10 workflows (75% migration)
- **Documentation consolidation**: 21 scattered files → 1 comprehensive guide + organized reference
- **CLI help completeness**: 8 descriptions → 20+ descriptions (all commands)
- **MCP template discoverability**: Low → High (measure via GitHub Insights / docs page views)

---

## Next Steps

1. Review and prioritize the tasks above
2. Assign tasks to Copilot agent via planner agent
3. Track progress on improvement items
4. Re-evaluate this focus area in 30 days to measure adoption improvement

---

*Generated by Repository Quality Improvement Agent*  
*Next analysis: 2025-11-29 - Focus area will be selected based on diversity algorithm (60% custom, 30% standard, 10% reuse)*


> AI generated by [Repository Quality Improvement Agent](https://github.com/githubnext/gh-aw/actions/runs/19764824246)

[pelikhan]

/plan

[github-actions[bot]]

🎉 Yo ho ho! Plan Command found the treasure and completed successfully! ⚓💰

[github-actions[bot]]

This discussion was automatically closed because it was created by an agentic workflow more than 3 days ago.