Which Coding Agents Are Supported by MemoryProxy? A Complete Integration Guide

MemoryProxy supports seven coding agents—Claude Code, CodeBuddy, Codex, WorkBuddy, dsh (DeepSeek Harness), Hermes, and OpenClaw—each with dedicated protocol adapters for Anthropic Messages, OpenAI Chat Completions, or OpenAI Responses API.

The TencentDB-Agent-Memory repository provides a request-forwarding proxy layer that injects team memory, skills, and persistent context into AI-assisted workflows. Understanding which coding agents are supported by MemoryProxy is essential for teams looking to standardize their LLM interactions across different AI coding assistants while maintaining centralized knowledge management.

MemoryProxy Architecture Overview

MemoryProxy acts as an intermediary layer between your development environment and upstream LLM providers. According to the source code in agents/README.md, the proxy abstracts client-specific protocols, handling session initialization, header management, and asset injection before forwarding requests to model endpoints. The system uses route handlers like handleAnthropicMessages, handleChatCompletions, and handleResponses to normalize requests from disparate coding agents into a unified format.

The Seven Coding Agents Supported by MemoryProxy

The proxy ships with built-in adapters for seven distinct coding agents, as documented in the agents/README.md file. Each adapter maps proprietary client protocols to standardized proxy routes and implements specific session management strategies.

Claude Code

Protocol: Anthropic Messages API
Session Initialization: Interactive Form via AskUserQuestion tool
Pagination: Supported (maximum 4 pages)
Headless Bypass: Not supported

Claude Code requires full interactive mode with mandatory form-based onboarding. The adapter enforces strict pagination limits and does not allow silent pass-through operation.

CodeBuddy

Protocol: OpenAI Chat Completions
Session Initialization: Interactive Form using ask_followup_question
Pagination: Unlimited (no restrictions)
Headless Bypass: Not supported

CodeBuddy maintains persistent conversational context without pagination limits but requires interactive setup through its native questioning interface.

Codex

Protocol: OpenAI Responses API
Session Initialization: Interactive Form combined with Default Gate
Form Tool: request_user_input
Headless Bypass: Not supported

Codex supports both interactive initialization and plan-gated access control, preventing headless operation without explicit configuration approval.

WorkBuddy

Protocol: OpenAI Responses API (Desktop) or Chat Completions (Web)
Session Initialization: Interactive Form with AskUserQuestion
Pagination: Supported (maximum 4 pages)
Headless Bypass: Supported (silent pass-through mode)

WorkBuddy offers flexible protocol support with both interactive and silent operation modes, making it suitable for desktop automation and web-based workflows.

dsh (DeepSeek Harness)

Protocol: OpenAI Chat Completions
Session Initialization: Interactive Form with Headless Bypass capability
Form Tool: ask_user_question
Pagination: Unlimited
Headless Bypass: Supported (no tool required)

dsh supports unlimited pagination and can operate without interactive tooling when running in bypass mode, ideal for automated pipelines.

Hermes

Protocol: OpenAI Chat Completions
Session Initialization: Header Pre-selection (no Form required)
Headless Bypass: Supported when headers are pre-configured

Hermes enables non-interactive setup ideal for CI/CD pipelines, relying entirely on HTTP headers for session context rather than interactive forms.

OpenClaw

Protocol: OpenAI Chat Completions
Session Initialization: Header Pre-selection (no Form)
Headless Bypass: Supported (header missing fallback)

OpenClaw provides a lightweight adapter for OpenAI-compatible clients that bypasses interactive configuration entirely through header-based routing.

How MemoryProxy Integrates Coding Agents

The proxy integrates coding agents through a four-stage pipeline defined in MemoryProxy/v3-api-memoryproxy-doc.md:

1. Configuration Generation: The agents/setup-proxy.sh wizard scans existing client configurations, validates connectivity, and generates proxy-specific config files while backing up originals.
2. Route Mapping: Proxy routes follow the pattern /:agent/:spaceId/v1/... where :agent must match one of the seven supported agent identifiers.
3. Session Registration: Mandatory headers (Authorization, x-team-id, x-agent-id, x-task-id, x-conversation-id) trigger automatic session registration and asset injection.
4. Asset Injection: Post-registration, the proxy prepends system prompts containing team-wide knowledge and skill definitions.

Configuration Examples

Interactive Setup with setup-proxy.sh

cd /path/to/TencentDB-Agent-Memory
bash agents/setup-proxy.sh

# Select "Claude Code" and provide model ID, proxy URL, and API token when prompted

Non-Interactive CI Configuration

bash agents/setup-proxy.sh \
  --agent claude-code \
  --proxy http://proxy.example.com:8096 \
  --space-id default \
  --model-id claude-opus-4.7 \
  --api-key "$ANTHROPIC_AUTH_TOKEN" \
  --non-interactive

Direct API Integration

POST http://proxy.example.com:8096/claude-code/default/v1/messages
Authorization: Bearer <user_api_key>
x-team-id: team-123
x-agent-id: claude-code
x-task-id: task-456
x-conversation-id: convo-789
Content-Type: application/json

{
  "model": "claude-opus-4.7",
  "messages": [{ "role": "user", "content": "Write a Python function to reverse a string." }]
}

Bulk Asset Import

tsx agents/asset-import.ts \
  --source workbuddy \
  --agent-id workbuddy-001 \
  --team-id team-123 \
  -y

Key Source Files

• agents/README.md: Master registry of supported coding agents and protocol mappings
• agents/setup-proxy.sh: Interactive configuration wizard for agent setup
• agents/skills/setup-proxy/SKILL.md: AI-driven configuration skill documentation
• MemoryProxy/v3-api-memoryproxy-doc.md: HTTP route specifications and header requirements
• agents/asset-import.ts: CLI utility for importing existing skills and memory assets

Summary

• MemoryProxy supports seven coding agents: Claude Code, CodeBuddy, Codex, WorkBuddy, dsh (DeepSeek Harness), Hermes, and OpenClaw
• Each agent adapter handles protocol translation between native APIs (Anthropic Messages, OpenAI Chat Completions, OpenAI Responses) and proxy routes
• Session initialization varies by agent: interactive forms for Claude Code and CodeBuddy, header-based pre-selection for Hermes and OpenClaw
• Required headers include x-team-id, x-agent-id, x-task-id, and x-conversation-id for automatic session registration
• The agents/setup-proxy.sh script automates configuration for both interactive and CI/CD environments

Frequently Asked Questions

Which coding agents support headless bypass mode?

Hermes, OpenClaw, WorkBuddy, and dsh support headless bypass, according to agents/README.md. Hermes and OpenClaw bypass interactively entirely by using header pre-selection, while WorkBuddy and dsh offer silent pass-through modes that skip the Form tool interaction.

How does MemoryProxy handle different API protocols?

The proxy normalizes requests through dedicated route handlers: handleAnthropicMessages processes Claude Code's native protocol, while handleChatCompletions and handleResponses manage OpenAI-compatible agents like CodeBuddy and Codex respectively.

What are the mandatory headers for MemoryProxy integration?

Per the source documentation in MemoryProxy/v3-api-memoryproxy-doc.md, sessions require five headers: Authorization (Bearer token), x-team-id, x-agent-id, x-task-id, and x-conversation-id. Missing headers trigger the interactive Form flow for agents that support it.

Can I import existing skills into MemoryProxy?

Yes. The agents/asset-import.ts CLI tool enables bulk ingestion of local skills and memory assets. Run the command with --source, --agent-id, and --team-id parameters to automatically import detected resources into the proxy's knowledge base.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}