Agent Company

Agent Company is a local developer app, team-template registry, and marketplace for reusable agent teams.

It combines four layers:

1. A local Claude Agent SDK runner app wired to AutonomyX Model Runner through in-process MCP tools.
2. A lightweight team-template registry under agents/ with machine-readable agent.json manifests, documentation, validation tooling, and a generated registry.json catalog.
3. A marketplace layer with marketplace.json listings for publisher identity, install instructions, trust and security metadata, support level, and commercial model.
4. A browsable marketplace UI served from /marketplace.html, backed by generated static marketplace data.

The app combines a browser UI, an Express API, and an Electron desktop shell so you can configure agent context, choose models, run prompts, browse marketplace listings, and optionally emit Langfuse traces from one local interface.

What this repository is for

Use this repository to:

• Run local Claude-powered agent workflows against models exposed by AutonomyX Model Runner.
• Store reusable team templates under agents/.
• Publish marketplace-ready listings for agent teams.
• Browse marketplace listings in the local web UI.
• Document what each team template does, which roles it contains, and how to run or adapt it.
• Validate team-template and marketplace metadata before review or release.
• Generate a machine-readable registry.json catalog for programmatic discovery.
• Generate a machine-readable marketplace.json catalog for marketplace discovery, trust badges, publisher listings, and install flows.

Marketplace UI

Start the web app:

npm install
npm run build:indexes
npm run dev:web

Open:

http://127.0.0.1:3000/marketplace.html

The marketplace UI supports:

• search across listing names, descriptions, use cases, audiences, tags, categories, and publishers
• filtering by risk level
• filtering by pricing model
• filtering by support tier
• publisher verification badges
• trust and risk badges
• listing detail modal
• install command modal
• links to source folders

The UI reads static data from:

public/marketplace.json

npm run build:marketplace writes both root marketplace.json and public/marketplace.json.

Marketplace model

Agent Company is designed to be more than a folder registry. A marketplace-ready team template includes both registry metadata and marketplace metadata.

agents/<team-template-id>/
├── agent.json              # registry metadata
├── marketplace.json        # marketplace listing metadata
├── README.md               # human-readable setup and usage guide
└── CHANGELOG.md            # recommended for versioned changes

The marketplace listing schema is available at schemas/marketplace-listing.schema.json. The marketplace model is documented in docs/marketplace.md.

Marketplace listings describe:

• publisher identity and verification status
• headline, use cases, audience, screenshots, and demos
• install instructions and commands
• pricing model, license, and purchase/support metadata
• trust review status, risk level, data access, and security notes
• support level, documentation, and issue links
• featured status, maturity, and quality signals

Team templates

Every folder under agents/ is treated as a reusable team template.

A team template can represent a single specialist agent, a multi-agent crew, a framework-specific starter, or a reusable workflow pattern. The folder name is the template identifier, and each folder should contain enough metadata and documentation for another developer to understand, run, and adapt the team.

Recommended structure:

agents/<team-template-id>/
├── agent.json
├── marketplace.json
├── README.md
└── CHANGELOG.md

Each team-template README should explain:

• The purpose of the team.
• The roles, agents, or workflow stages included in the team.
• The expected inputs and outputs.
• Required models, tools, APIs, credentials, or runtime services.
• Setup and run instructions.
• Safety, permission, and data-handling notes.
• How to customize the template for a different team or project.

The registry manifest schema is documented in docs/agent-manifest.md, and the JSON schema lives at schemas/agent.schema.json.

A reference template and marketplace listing are available at agents/example-agent.

Highlighted marketplace listings

The generated marketplace.json file is the marketplace catalog. It is built from agents/*/marketplace.json plus the corresponding agent.json metadata.

Current highlighted listings include:

• agents/example-agent - reference package showing the expected registry and marketplace structure.
• agents/claude-agent-sdk - Claude Agent SDK-style starter that combines a Mistral model through OpenRouter, Glean-backed retrieval, and Supabase-backed memory persistence.

Validation and indexes

Validate registry metadata:

npm run validate:registry

Validate marketplace listings:

npm run validate:marketplace

Run both validators:

npm run validate

Normal validation mode is migration-friendly: it warns for legacy team-template folders that do not yet have full registry or marketplace metadata.

For strict enforcement:

npm run validate:registry -- --strict
npm run validate:marketplace -- --strict

Build the machine-readable registry catalog:

npm run build:registry

Build the machine-readable marketplace catalog and static UI data:

npm run build:marketplace

Build both indexes:

npm run build:indexes

Recommended release flow:

npm run validate
npm run build:indexes
git diff -- README.md registry.json marketplace.json public/marketplace.json agents/ schemas/ docs/ scripts/

Features

• Browse marketplace listings at /marketplace.html.
• Search and filter listings by use case, publisher, risk, pricing, and support.
• View install commands, trust metadata, and security notes for each listing.
• Select a Claude model for the agent run.
• Discover, select, and load models from the configured AutonomyX Model Runner.
• Route Claude agent turns through two local MCP tools:
  • list_runner_models
  • query_runner_model
• Choose active memory types per run:
  • working
  • episodic
  • semantic
  • procedural
  • preference
  • project
  • task
  • decision
  • artifact
• Add dynamic run context without changing saved configuration.
• Attach decision logs, evaluation criteria, feedback, guardrails, prompt registries, skill registries, model registries, LangGraph components, and decide components.
• Cancel in-flight requests and switch models quickly.
• Persist runtime UI configuration in config.json.
• Run as a local web app or packaged macOS desktop app.
• Emit optional Langfuse traces when Langfuse credentials are configured.
• Validate team-template and marketplace metadata before review or release.
• Generate registry.json for programmatic discovery.
• Generate marketplace.json and public/marketplace.json for listing discovery, install flows, trust badges, and publisher metadata.

Architecture

Electron desktop shell
        |
        v
Static frontend in public/
        |
        +--> /marketplace.html
        +--> /marketplace.json
        |
        v
Express API in server.js
        |
        +--> Claude Agent SDK
        |       |
        |       +--> in-process MCP server
        |               |
        |               +--> AutonomyX Model Runner
        |
        +--> optional Langfuse tracing

agents/
  |
  +--> <team-template-id>/agent.json
  +--> <team-template-id>/marketplace.json
  +--> <team-template-id>/README.md
  +--> registry validation tooling
  +--> marketplace validation tooling
  +--> registry index builder --------> registry.json
  +--> marketplace index builder -----> marketplace.json + public/marketplace.json

The selected runner model is made available to Claude as a local MCP tool. During an agent run, Claude can inspect available runner models, call the selected runner model, and then synthesize the final response.

Requirements

• Node.js 20 or newer
• npm
• Anthropic API key
• A running AutonomyX Model Runner instance
• macOS if you want to build the .dmg

Environment

Create a local .env file from the example:

cp .env.example .env

Required values:

ANTHROPIC_API_KEY=your_anthropic_api_key
RUNNER_BASE_URL=http://127.0.0.1:8765

Optional values:

PORT=3000
CLAUDE_MODELS=claude-opus-4-1,claude-sonnet-4-20250514,claude-3-7-sonnet-latest
LANGFUSE_PUBLIC_KEY=
LANGFUSE_SECRET_KEY=
LANGFUSE_BASE_URL=https://cloud.langfuse.com

RUNNER_BASE_URL should point to your local AutonomyX Model Runner API. The default is http://127.0.0.1:8765.

Run locally

Install dependencies:

npm install

Build the catalogs:

npm run build:indexes

Start the Electron desktop app:

npm run dev

Start only the web server:

npm run dev:web

Then open:

http://127.0.0.1:3000/
http://127.0.0.1:3000/marketplace.html

Run the production server entrypoint:

npm start

Using the app

1. Start AutonomyX Model Runner.
2. Build catalogs with npm run build:indexes.
3. Start this app with npm run dev or npm run dev:web.
4. Open /marketplace.html to browse listings.
5. Open the main app to run Claude-powered workflows.
6. Confirm ANTHROPIC_API_KEY is configured.
7. Refresh runner models from RUNNER_BASE_URL.
8. Load the runner model you want to use.
9. Select Claude and runner models.
10. Choose memory types and add any optional run context.
11. Submit a prompt.

The runner model must be loaded before Claude can call it through the MCP tool.

Add or update a marketplace listing

Read docs/pushing-to-registry.md and docs/marketplace.md before submitting a team template.

Minimum workflow:

git checkout -b add-my-team-template
mkdir -p agents/my-team-template
# add README.md, agent.json, and marketplace.json
npm run validate
npm run build:indexes
git add agents/my-team-template registry.json marketplace.json public/marketplace.json
git commit -m "marketplace: add my-team-template"
git push origin add-my-team-template

Open a pull request and include validation output, runtime requirements, security notes, listing trust level, support level, commercial model, and a short summary of the roles or agents included in the team.

New and updated marketplace listings should include both agent.json and marketplace.json. Legacy imported folders can be migrated gradually, then enforced later with strict validation.

Marketplace listing checklist

Use this checklist before publishing a template as marketplace-ready:

• Name the template and summarize the team in one or two sentences.
• List the team roles, agents, or workflow stages.
• Explain when to use the template and when not to use it.
• Document setup steps, environment variables, and required services.
• Show at least one run command or usage example.
• Document tool, file-system, network, shell, browser, and credential permissions.
• Add publisher, support, license, and pricing metadata.
• Set trust review status and risk level.
• Add security notes for any medium, high, or critical risk.
• Add customization notes for adapting the team to another project.
• Update agent.json, add marketplace.json, regenerate registry.json, and regenerate marketplace.json.

Build a macOS DMG

npm install
npm run dist:dmg

The generated .dmg is written to dist/.

The DMG build is unsigned by default. macOS may warn before first launch unless you sign and notarize the app.

Docker

Build an image:

docker build -t your-dockerhub-user/agent-company:latest .

Run the container:

docker run --rm -p 3000:3000 \
  -e ANTHROPIC_API_KEY=your_anthropic_api_key \
  -e RUNNER_BASE_URL=http://host.docker.internal:8765 \
  your-dockerhub-user/agent-company:latest

Project structure

.
├── agents/                 # Reusable team-template folders
├── docs/                   # Registry, marketplace, and contributor documentation
├── electron/               # Electron desktop shell
├── public/                 # Static frontend assets and marketplace UI
│   ├── index.html
│   ├── marketplace.html
│   └── marketplace.json
├── schemas/                # JSON schemas for registry and marketplace metadata
├── scripts/                # Registry, marketplace validation, and index scripts
├── registry.json           # Generated machine-readable team-template catalog
├── marketplace.json        # Generated marketplace listing catalog
├── server.js               # Express API, Claude Agent SDK integration, MCP tools
├── langfuse.js             # Optional Langfuse tracing integration
├── config.json             # Runtime-persisted UI configuration
├── .env.example            # Environment variable template
└── package.json            # Scripts, dependencies, and Electron build config

API overview

The Express server exposes these main routes:

• GET /api/config - return runtime config, memory types, and runner health.
• POST /api/config - update runtime model and memory configuration.
• GET /api/runner/models - fetch runner models from the configured runner API.
• POST /api/runner/models/load - load a runner model.
• POST /api/chat - run a Claude agent request with the selected runner model and context.

Static marketplace assets are served from:

• GET /marketplace.html
• GET /marketplace.json

Notes

• Built-in Claude tools are disabled for agent runs.
• The app auto-approves only the local MCP tools defined in server.js.
• The default runner models are local AutonomyX runner entries and can be changed in the UI or through configuration.
• Langfuse tracing is enabled only when both Langfuse public and secret keys are present.
• config.json is written by the app when configuration is changed from the UI.
• registry.json should be regenerated after adding or changing any agent.json manifest.
• marketplace.json and public/marketplace.json should be regenerated after adding or changing any marketplace.json listing.
• New marketplace entries should include both agent.json and marketplace.json; legacy imported folders can be migrated gradually and checked with strict validation later.