Skip to main content
Glama

Create GitHub Issue with Journal Entry

create_github_issue_with_entry

Create a GitHub issue and automatically generate a linked journal entry that documents the issue creation for persistent project context.

Instructions

Create a GitHub issue AND automatically create a linked journal entry documenting the issue creation.

Input Schema

NameRequiredDescriptionDefault
bodyNoIssue body/description
repoNoRepository name - LEAVE EMPTY to auto-detect
tagsNoJournal entry tags
ownerNoRepository owner - LEAVE EMPTY to auto-detect
titleNoIssue title
labelsNoLabels to apply
assigneesNoUsers to assign
use_test_dbNo
entry_contentNoCustom journal content (defaults to auto-generated summary)
initial_statusNoInitial status column (e.g., "Backlog", "Ready"). Defaults to "Backlog" when adding to a project.
project_numberNoGitHub Project number to add this issue to
milestone_numberNoMilestone number to assign this issue to

Output Schema

NameRequiredDescriptionDefault
codeNoError code (e.g. VALIDATION_ERROR, INTERNAL_ERROR)
errorNoHuman-readable error message
issueNo
detailsNoAdditional error context
messageNo
projectNo
successNo
categoryNoError category (validation, query, connection, internal)
suggestionNoSuggested fix for the error
instructionNo
recoverableNoWhether the error is recoverable
journalEntryNo
aggregated_errorsNoDetails of individual errors in a multi-step operation
requiresUserInputNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv9.0.0

TDQS

A3.5/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly=false, openWorld=true, idempotent=false and destructive=false. The description adds the genuinely non-obvious side effect that a journal entry is created automatically as a consequence, which is valuable context beyond structured fields. It stops short of explaining atomicity (what happens if the issue is created but the journal entry fails) or auth requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with the compound effect stated up front and zero filler. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists and annotations cover the safety profile, so the description needn't explain return values. However, for a 12-parameter, non-idempotent, open-world mutation with an implicit second write, the description should say more about failure behavior and the required repo context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 92%, so nearly every one of the 12 parameters is already documented in the schema, including the auto-detect hint on repo/owner. The description adds no parameter-level meaning beyond that, which is the correct baseline when the schema does the work.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and compound resource: creates a GitHub issue and a linked journal entry. This clearly separates it from create_entry and get_github_issues. It does not explicitly contrast with the obvious counterpart close_github_issue_with_entry, so an agent must infer the create/close pairing from the name alone.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this versus create_entry or close_github_issue_with_entry, and no prerequisites (auth, repo access) are mentioned. The agent must infer the intended workflow entirely from the tool name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Deploy Server

Other Tools