ax-go-agent-memory-skills

Implement Go agent memory workflows with recall callbacks and skill tracking.

2.9k|186|Updated Feb 23, 2023
One-click install
npx skills add https://github.com/ax-llm/ax --skill ax-go-agent-memory-skills
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ax-go-agent-memory-skills
Source: https://github.com/ax-llm/ax/tree/main/website/static/go/.well-known/agent-skills/ax-go-agent-memory-skills
Command: npx skills add https://github.com/ax-llm/ax --skill ax-go-agent-memory-skills

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers write Go code for Ax agent memory workflows without guessing the correct package patterns for recall, skill discovery, and state tracking.

Core Features & Use Cases

  • Memory and Recall Control: Structure host callbacks for loading memories and retrieving relevant context during an agent turn.
  • Skill Discovery and Usage Tracking: Detect which skills were loaded and which ones actually influenced the response.
  • Ax Go Integration: Work with the generated Go package github.com/ax-llm/ax/packages/go using the documented runtime and agent APIs.
  • Use Case: A developer can use this Skill to build a Go assistant that remembers prior facts, logs which skills were consulted, and keeps retrieval logic outside generated package global state.

Quick Start

Use this skill to help me write Go code for Ax agent memory, recall callbacks, dynamic skill discovery, loaded-skill state, and used-skill tracking in github.com/ax-llm/ax/packages/go.

Frequently Asked Questions about ax-go-agent-memory-skills

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement recall callbacks for Go agent memory in Ax?

Recall callbacks in Ax Go agent memory workflows are structured as host-side functions that load memories and retrieve relevant context during an agent turn. This Skill provides the correct package patterns for organizing them outside generated package global state.

What is the best way to track which skills were loaded and used in a Go agent run?

Skill discovery and used-skill tracking in Ax Go runs are managed by maintaining loaded-skill state and monitoring which skills influenced the response. This keeps dynamic skill discovery logic organized within host-side memory workflows.

Does the Ax Go package support dynamic skill discovery during runtime?

Yes, the Ax Go package supports dynamic skill discovery during runtime. You use generated-package APIs with no-key or provider-backed runtime profiles to detect and load skills on the fly for deterministic and networked execution.

How do I manage agent memory state without relying on global variables in Go?

Managing Go agent memory state without global variables involves structuring retrieval logic and loaded-skill state on the host side using recall callbacks. This approach keeps memory workflows organized through runtime context management rather than package-level globals.

Can I use no-key runtime profiles for deterministic Ax agent execution in Go?

Yes, no-key runtime profiles are supported for deterministic Ax agent execution in Go. They allow you to run agent memory workflows and skill tracking locally without provider-backed network access, ensuring consistent behavior during development.

Why does my Ax Go agent struggle to retrieve relevant context across turns?

Ax Go agents struggle with context retrieval across turns when recall callbacks are not properly structured for host-side memory loading. Implementing organized memory workflows with correct package patterns ensures relevant context is retrieved during each agent turn.