ax-python-agent-context

Use when writing Python code with `axllm` for deciding between context maps, trajectory context policy, offline optimization (ACE/GEPA), and memory recall for long-context agents.

Quality

74%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./packages/python/skills/ax-python-agent-context/SKILL.md

Quality

Content

76%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A token-efficient, well-sectioned overview that points to external docs instead of inlining them, with one concrete code pattern and useful guardrails. Its main weakness is that the central task — deciding between contextMap, contextPolicy, optimization, and recall — is named without any decision procedure or criteria to carry it out, and the code example has an undefined `llm` dependency.

Suggestions

Add 2-3 decision criteria under 'When To Use' for choosing between contextMap, contextPolicy, optimization, and recall (e.g., which to pick for persistent corpus orientation vs. within-run compaction vs. improving prompts offline).

Complete the Core Pattern by showing how the `llm` argument is constructed, ideally using the advertised no-key scripted transport so the example runs without provider credentials.

Trim 'Relevant API Surface' to the four routing-relevant entry points and delegate the full list to the referenced `API.md`/`axir-api.json` to reduce duplication with the external docs.

Dimension	Reasoning	Score
Conciseness	The body is a lean, well-sectioned manifest: 'Real network support: yes', 'Treat AxIR as the source of generated package truth' — every line adds package-specific facts or constraints Claude could not know, with no padding or explanation of concepts Claude already knows. The only near-redundant lines ('Language: Python.', 'Package: `axllm`') duplicate the description, but these are terse manifest facts rather than over-explanation.	5 / 5
Actionability	The Core Pattern gives real, executable syntax ('helper = agent("question:string -> answer:string")', 'helper.forward(llm, {...})') and Guardrails give concrete directives ('Use `no-key` examples for deterministic local checks'). It falls short of 5 because `llm` is never constructed or shown (no copy-paste-ready path from import to output), and the no-key transport is named but never demonstrated.	4 / 5
Workflow Clarity	The skill's core task is routing ('Choose between contextMap, contextPolicy, optimization, and recall for a task'), but no decision criteria or sequence tells the agent HOW to choose between them — only that it should. Guardrails ('Start from package examples for exact native syntax before inventing a new call shape') act as loose checkpoints, which keeps this above 2, but the central decision flow has no explicit steps, so it cannot reach 4.	3 / 5
Progressive Disclosure	The body correctly stays an overview and signals one-level-deep references ('Package API docs: `API.md` and `axir-api.json`', 'Runnable examples: `examples/`') rather than inlining bulk API material. It misses 5 because no bundle files exist (no references/, scripts/, or assets/ directories ship with the skill), so the referenced paths cannot be navigated from the skill itself, and the 'Relevant API Surface' section inlines an API index that overlaps the referenced API docs.	4 / 5
	Total	16 / 20 Passed

Description

62%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A grammatically clean, third-person description with an explicit 'Use when' trigger and a well-defined niche around the `axllm` package. Its weaknesses are the absence of concrete actions (it says 'deciding between' four features without saying what is done with them) and sparse natural-language trigger synonyms beyond package-internal jargon.

Suggestions

Replace the generic 'writing Python code with `axllm`' framing with concrete verbs per capability, e.g., 'Configures context maps and trajectory context policy, runs offline optimization (ACE/GEPA), and sets up memory recall for long-context agents using the `axllm` Python package.'

Add natural synonyms users would actually type, such as 'context window management', 'prompt optimization', or 'retrieval/memory', alongside the current jargon terms.

Sharpen the trigger so it fires only for this router skill and not sibling `axllm` skills, e.g., 'Use when choosing or configuring how a long-context agent's context (maps, policy, optimization, recall) should be handled in `axllm` Python code.'

Dimension	Reasoning	Score
Specificity	The description names the domain precisely ('Python code with `axllm`', 'long-context agents') and enumerates four capability areas ('context maps, trajectory context policy, offline optimization (ACE/GEPA), and memory recall'), but the only actions offered are generic — 'writing Python code' and 'deciding between' — with no concrete verbs like 'configure', 'run', or 'optimize' attached to those areas. That matches anchor 3 (names domain and 1-2 concrete actions, not comprehensive); it is above 2 because the capability areas are real and specific, but below 4 because none of the four named areas comes with an actual action.	3 / 5
Completeness	Both halves are explicitly present: 'when' is an explicit trigger clause ('Use when writing Python code with `axllm`...') and 'what' is stated (routing between context maps, context policy, optimization, and recall). It falls short of anchor 5 because the 'what' is thin — 'deciding between' four features describes a routing role without stating what the skill concretely does with them — which matches anchor 4's 'when could be more explicit or specific' / what-and-when present.	4 / 5
Trigger Term Quality	Relevant keywords are present ('Python', 'axllm', 'ACE/GEPA', 'memory recall', 'long-context agents'), and a user of this generated package would plausibly say 'axllm' or 'GEPA'. But there are no synonyms or variations (no 'context window', 'context management', 'prompt optimization', 'retrieval'), and terms like 'trajectory context policy' are internal jargon users would rarely say. That fits anchor 3: some relevant keywords, missing common variations.	3 / 5
Distinctiveness Conflict Risk	The `axllm`-scoped trigger ('writing Python code with `axllm`') carves a clear niche with minimal overlap against generic Python skills, fitting anchor 4 (mostly distinct, minor overlap risk). It does not reach 5 because the skill name ('ax-python-agent-context') suggests a family of generated sibling skills for the same package, and terms like 'writing Python code with `axllm`' could also fire for those siblings rather than this context/optimization router specifically.	4 / 5
	Total	14 / 20 Passed

Validation

93%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 15 / 16 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	15 / 16 Passed

Repository: ax-llm/ax
Path: packages/python/skills/ax-python-agent-context/SKILL.md
Commit: 3f630a0

Reviewed: 3 days ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.