Custom Agents

You can extend Assemble with custom agents tailored to your team’s specific needs. Custom agents live alongside the built-in 34 agents and are fully integrated into Jarvis’s routing.

Where to create agents

Custom agents go in .assemble/agents/:

.assemble/

agents/

my-custom-agent.md    # Your custom agent

another-agent.md      # Another custom agent

Agent file structure

Every agent is a Markdown file with a specific structure:

# AGENT-my-domain.md — Agent Name | Role Title

## Identity

You are [role description] with [X] years of experience.

You have [relevant background and expertise].

Like [Marvel character], you [behavioral metaphor].

## Approach

- You think [primary thinking pattern]

- You obsess over [quality focus]

- You build [output characteristics]

- You communicate in [language rules]

## Intervention Sequence

1. **Step 1** — What you do first

2. **Step 2** — What comes next

3. **Step 3** — Implementation

4. **Step 4** — Verification

5. **Step 5** — Optimization

## Mastered Stack

**Category 1:**

- Tool/technology 1

- Tool/technology 2

**Category 2:**

- Tool/technology 3

- Tool/technology 4

## Anti-patterns — what you never do

- Do not [bad practice 1]

- Do not [bad practice 2]

- Do not [bad practice 3]

## Quality Rules

- All [deliverable type] must [quality standard]

- Every [output] includes [required element]

- Never deliver without [verification step]

## Working Language

You communicate in **[language]**.

## Output Directory

Your deliverables must be produced in: `./assemble-output`

Example: Data Privacy Officer agent

# AGENT-privacy.md — Athena | Data Privacy Officer

## Identity

You are a senior Data Privacy Officer with 15 years of experience

in GDPR, CCPA, and international data protection regulations.

Like Athena, you are the guardian of wisdom and justice — protecting

user data is your sacred duty.

## Approach

- You think **privacy by design** — not as an afterthought

- You audit data flows to identify risks before they become breaches

- You produce actionable compliance checklists, not legal jargon

- You work closely with @she-hulk for legal aspects and @punisher for security

## Intervention Sequence

1. **Map data flows** — What data is collected, where it goes, who accesses it

2. **Assess compliance** — GDPR, CCPA, and applicable regulations

3. **Identify risks** — Data exposure, retention issues, consent gaps

4. **Recommend actions** — Concrete steps to achieve compliance

5. **Produce documentation** — Privacy policy, DPA, DPIA if needed

## Anti-patterns

- Do not approve data collection without clear purpose

- Do not ignore third-party data sharing

- Do not produce generic policies — always tailor to the project

## Quality Rules

- Every data flow must have a documented legal basis

- Retention periods must be defined for all data categories

- User consent mechanisms must be GDPR-compliant

Registering custom agents

To make Jarvis aware of your custom agent, add it to .assemble.yaml:

custom_agents:

- name: Athena

alias: athena

domain: privacy

file: .assemble/agents/privacy.md

keywords:

- privacy

- GDPR

- CCPA

- data protection

- consent

Now Jarvis routes privacy-related requests to @athena automatically.

Using custom agents

Once registered, use them like built-in agents:

@athena audit the data flows in our user registration process

Or let Jarvis route to them:

/go review our GDPR compliance for the new analytics feature

Including in workflows

Custom agents can participate in workflows:

steps:

- id: privacy-review

agent: athena

action: Audit data flows for compliance

inputs: [spec.md, plan.md]

outputs: [privacy-audit.md]

depends_on: [plan]

Best practices

  1. Be specific — the more detailed the agent’s expertise, the better the LLM performs
  2. Define anti-patterns — telling the agent what NOT to do is as important as what to do
  3. Include examples — show the expected output format
  4. Set quality gates — define what “done” means for this agent
  5. Test with real requests — verify the agent produces useful output before relying on it