Public documentation

Agensi Publisher v1.3.6

Evidence-grounded listing authoring, prompt architecture, and the tested ChatGPT Chrome-extension workflow for preparing Agensi drafts without crossing the submission boundary.

Overview

Agensi Publisher v1.3.6 — Public Technical Documentation

1. Purpose

Agensi Publisher converts verified skill-package evidence into an Agensi marketplace draft while preserving a strict separation between product truth, commercial recommendations, browser execution, creator review, and publication.

The central invariant is:

CLAIM_SCOPE_MUST_NOT_EXCEED_EVIDENCE_SCOPE

The browser is not the author. The Publisher is the authoring and governing authority; the browser executor only materializes the approved field set in Agensi and verifies the result.

2. Operating modes

APPROVED_SOURCE_MODE

Use when exact creator-approved listing copy already exists. The approved fields are immutable source material for preparation and reconciliation.

NEW_SKILL_AUTHORING_MODE

Use when a verified skill ZIP and logo exist but approved listing copy does not. The Publisher builds evidence, positioning, commercial recommendations, permissions, buyer copy and validation artifacts before the browser is allowed to populate the Dashboard.

3. Evidence and copy architecture

A normal new-skill run includes:

  1. package integrity;
  2. Evidence Ledger;
  3. Product Truth Brief;
  4. Positioning Brief;
  5. positioning angles and selection;
  6. pricing/category proposal;
  7. permissions and compatibility;
  8. buyer-facing field set;
  9. Claim Audit;
  10. Genericity Gates;
  11. Fresh Read Copy Critic;
  12. Authoring Validator;
  13. frozen Publisher field set;
  14. official matching-policy preflight;
  15. browser entry and reconciliation.

No unsupported material claim may survive into buyer-facing copy.

4. Pricing policy

v1.3.6 keeps six equal-weight evidence dimensions, each scored 0–2:

Automatic paid recommendations:

ScoreBandPrice
0–3UTILITY$9
4–7SPECIALIZED$15
8–10ADVANCED$19
11–12PREMIUM$25

These are Publisher recommendations, not market-value claims. Creator-approved decisions and current catalog baselines retain higher commercial precedence.

5. Category policy

Category selection is evidence-driven. The Publisher evaluates the product's primary buyer job, mechanism, output and current authorized Agensi taxonomy.

Historical placement is not automatically authoritative for a blind diagnostic run.

6. Permission model

Permissions describe the product's required runtime capability envelope, not whatever tools happen to be available to the executor.

Separate:

Only required runtime capabilities become required marketplace toggles. Optional tools with documented fallback stay optional and belong in compatibility/permission notes where relevant.

7. Browser Dashboard route

The browser route is:

PUBLISHER AUTHORING -> FROZEN FIELD SET -> AGENSI DASHBOARD -> SAVE -> PREVIEW -> RECONCILIATION -> CREATOR REVIEW

The authoring workflow stops before Submit for Review.

ChatGPT Chrome extension

This is the strongest tested route for end-to-end browser automation. Creator acceptance runs demonstrated:

Claude Code App and Claude Cowork

Both worked for Publisher-driven authoring and Agensi Dashboard preparation in tested configurations. However, the tested native file-picker flows required human file selection. They are therefore supported routes, but not the preferred path when the goal is maximum upload automation.

The ChatGPT Chrome extension is the recommended tested route for that objective.

8. Validation source vs browser asset source

Keep these concepts separate:

VALIDATION_AND_AUTHORING_SOURCE

The bytes the Publisher runtime can actually read for SHA verification, evidence extraction and validators.

BROWSER_LOCAL_ASSET_SOURCE

The local ZIP/logo selected through the website file picker.

Browser access to a local path does not prove the Publisher runtime can read it. Conversation attachments or an authorized runtime mount are useful when both authoring and browser upload need access to the same package.

9. Platform autofill

Agensi-generated buyer-facing content is:

UNTRUSTED_PLATFORM_AUTOFILL

until it matches Publisher authority.

The browser executor should replace unsupported autofill rather than treating it as evidence.

10. Dynamic tag accounting

Do not assume one category creates exactly one platform tag.

After category selection, observe the real platform-generated tags and calculate:

TOTAL_TAGS = dedupe(PUBLISHER_EXPLICIT_TAGS + OBSERVED_PLATFORM_CATEGORY_TAGS)

A category may produce zero, one or multiple tags. Remove unrelated autofill tags and respect the current live limit.

11. Reconciliation vocabulary

Correctable editable mismatches should not survive to creator review.

12. Platform-fixed compatibility copy

Agensi can render fixed, non-editable compatibility-oriented UI text outside the listing field set.

Classify it as:

PLATFORM_FIXED_COMPATIBILITY_CLAIM

It is:

13. Asset reconciliation

ZIP

When Agensi does not expose the remote byte hash:

MATCH_BY_NAME_AND_STRUCTURE

plus:

REMOTE_ZIP_HASH_UNVERIFIED

This requires valid local sidecar verification plus matching filename/package structure.

Logo

14. Multi-skill execution

Multi-skill work is sequential, not parallel browser mutation:

skill 1 -> complete/reconcile -> skill 2 -> complete/reconcile -> ...

Every target gets independent:

A per-skill failure can be isolated when safe. Global execution stops when authentication, draft identity or cross-skill separation becomes unsafe.

15. Publication boundary

During Publisher authoring:

Creator review and submission are separate operations.

16. Recommended workflow

For maximum tested automation:

  1. open ChatGPT with Chrome extension available;
  2. sign into Agensi normally;
  3. provide the exact target local folder(s);
  4. provide ZIP/.sha256/logo to the runtime when local-path reading is not guaranteed;
  5. call Agensi Publisher Skills via MCP;
  6. let Publisher author and validate;
  7. let ChatGPT upload verified assets and populate the Dashboard;
  8. reconcile Editor/Desktop/Mobile;
  9. stop before Submit for Review;
  10. perform creator review separately.
Prompt Engineering

Prompt Engineering Guide for Agensi Publisher

1. Why the prompt architecture matters

A good Publisher prompt is not merely a task description. It is an execution contract. It must prevent four common failure modes:

The prompt should therefore define authority, sources, invariants, sequence, blockers and terminal states before describing individual browser actions.

2. The authority stack

A robust prompt starts with explicit roles:

AGENSI PUBLISHER SKILLS VIA MCP = AUTHORING AND GOVERNING AUTHORITY

CHATGPT = EXECUTOR

LOCAL/ATTACHED ASSETS = PACKAGE AND EVIDENCE SOURCE

AGENSI DASHBOARD = ENTRY AND VERIFICATION SURFACE

This prevents browser-generated content or executor intuition from silently becoming product truth.

3. Make prompts version-neutral by default

For operational use, call the current Publisher normally and record its version as audit metadata.

Avoid hardcoding pricing bands, policy thresholds or a specific Publisher version unless the purpose of the test is explicitly version validation.

This makes demonstration prompts durable across later Publisher releases.

4. Declare the publication stop early

The publication boundary should appear near the top, not only at the end:

A visible Submit button is not authorization.

5. Separate source roles

When the browser can access local files but the model runtime may not, declare two sources:

VALIDATION_AND_AUTHORING_SOURCE

and

BROWSER_LOCAL_ASSET_SOURCE

This avoids false claims that browser upload proves package validation.

6. Blind commercial diagnostics

If the purpose is to test pricing/category policy without anchors, the prompt must explicitly exclude:

The required causal paths are:

PACKAGE EVIDENCE -> CURRENT PRICING POLICY -> RECOMMENDATION

PACKAGE EVIDENCE -> PRODUCT FUNCTION -> CURRENT TAXONOMY -> CATEGORY

Incidental exposure can be reported without automatically contaminating the run; contamination occurs when exposed information influences the decision.

7. Advance authorization without authorizing submission

For autonomous multi-skill preparation, the prompt may pre-authorize applying a Publisher-generated field set after all required gates pass.

The authorization must be bounded to named targets and must explicitly exclude submission/publication.

This removes unnecessary per-skill pauses while retaining the critical human boundary.

8. Sequential isolation

A multi-skill prompt should require:

ACTIVE_TARGET_SLUG: <slug>

before browser mutation.

Every skill must independently rebuild:

Do not keep two partially edited drafts active unless the platform requires it.

9. Browser autofill policy

Declare platform autofill untrusted:

UNTRUSTED_PLATFORM_AUTOFILL

The browser executor is then required to reconcile platform guesses against the Publisher field set instead of accepting plausible text.

10. Dynamic tags

Do not encode “one category equals one tag.” Require observation after category selection:

TOTAL_TAGS = dedupe(PUBLISHER_EXPLICIT_TAGS + OBSERVED_PLATFORM_CATEGORY_TAGS)

This remains correct if the platform generates zero, one or multiple category tags.

11. Fixed platform UI copy

Tell the executor to distinguish editable Publisher fields from fixed platform UI text.

Compatibility-oriented fixed platform text should be reported as:

PLATFORM_FIXED_COMPATIBILITY_CLAIM

It should not be counted as a field mismatch and must not be used as evidence.

12. Asset automation classification

For ZIP and logo independently, use explicit outcomes:

This makes host comparisons auditable and prevents “upload succeeded” from hiding human intervention.

13. Keep video runs readable

For recorded demonstrations, instruct ChatGPT to do the full technical work but emit concise progress updates during execution. Put Evidence Ledger details, scores and reconciliation tables in the consolidated report at the end.

Good progress update:

Package verified, Publisher gates passed, official preflight passed. Populating the Agensi draft.

Avoid dumping the full dossier in the middle of browser navigation.

14. Failure isolation

A good batch prompt distinguishes per-skill blockers from global blockers.

Per-skill blocker: stop that skill, preserve its state, continue when safe.

Global blocker examples:

15. Final reporting contract

The prompt should require per-skill reporting of:

For multi-skill runs, add aggregate counts.

16. Prompt customization rule

When adapting a template, change target-specific values only:

Do not casually remove:

ChatGPT Extension Workflow

Detailed Workflow: ChatGPT + Chrome Extension + Agensi Publisher

1. Why this is the preferred tested route

Among the tested environments, ChatGPT with the Chrome extension produced the strongest browser automation result: local ZIP and logo selection completed automatically in multi-skill runs while Publisher remained the authoring authority.

Claude Code App and Claude Cowork successfully completed Publisher-driven authoring and Agensi form preparation, but their tested native file-picker flows required human file selection. They remain useful supported alternatives, particularly when local workspace access is important, but the ChatGPT extension is the best tested route for minimizing upload intervention.

2. Prepare the browser session

Before starting the run:

  1. open Chrome in the profile normally used for Agensi;
  2. sign in to Agensi manually;
  3. open the Creator Dashboard/new-skill workflow;
  4. ensure the ChatGPT browser extension is available;
  5. authorize the Agensi MCP connector before the recorded run when possible;
  6. close unrelated tabs and avoid displaying private material during recording.

Do not put passwords, cookies, session tokens or MFA secrets into the prompt.

3. Prepare the package inputs

For each skill keep together:

If the ChatGPT runtime cannot directly read the local folder, attach the same ZIP, sidecar and logo to the conversation. Use those bytes for validation while using the local folder for the browser upload.

When both sources are available, compare hashes so the analyzed package and browser-upload package can be proven equivalent.

4. Start with authority separation

The prompt should state:

Agensi Publisher Skills via MCP = AUTHORING AND GOVERNING AUTHORITY

ChatGPT = EXECUTOR

Chrome / Agensi Dashboard = ASSET UPLOAD, DRAFT ENTRY AND VERIFICATION

This keeps ChatGPT from independently rewriting Publisher copy while navigating the form.

5. Load Publisher through MCP

ChatGPT should load Agensi Publisher Skills and record version metadata for audit.

Operational prompts should normally remain version-neutral. The current Publisher determines its own pricing bands, quality gates and policy behavior.

If MCP authorization is missing, resolve it before authoring. Do not silently substitute an unrelated local copy when the run specifies MCP Publisher authority.

6. Validate before authoring

For each target:

Do not create buyer-facing claims from filenames alone.

7. Publisher authoring

The Publisher builds the Evidence Ledger, positioning, pricing/category recommendation, permission model, copy, Claim Audit and quality gates.

ChatGPT should not independently “improve” the copy after freeze.

If a demo is synthetic/illustrative, it must be labeled accordingly rather than presented as observed execution.

8. Official preflight

Only a matching Publisher policy/executable preflight can produce OFFICIAL_PREFLIGHT_PASS.

A manual checklist or scratch validator is supplementary evidence, not official PASS.

9. Create/identify the correct draft

Before editing, verify the active target slug and draft identity.

For multi-skill runs, finish one draft before moving to the next. If the wrong asset creates a new draft, stop and reconcile identity before continuing.

10. Automated ZIP and logo upload

Through the visible Agensi controls:

  1. click ZIP upload;
  2. use the local path supplied in the prompt;
  3. select the exact ZIP;
  4. verify the displayed filename;
  5. repeat independently for the PNG logo.

Record whether each upload was fully automated or required human intervention.

Never assume the native picker opened in the correct last-used folder; verify the filename before confirming.

11. Replace platform autofill

Agensi may prefill copy, categories, tags, use cases, FAQs or permissions.

Treat these as:

UNTRUSTED_PLATFORM_AUTOFILL

Replace them with the frozen Publisher field set unless they already match exactly.

12. Pricing and category

Use the Publisher recommendation or higher-precedence creator decision according to the run's commercial contract.

For blind diagnostics, exclude historical values entirely.

After selecting category, observe actual platform-generated category tags.

13. Tags

Calculate after observation:

TOTAL_TAGS = dedupe(PUBLISHER_EXPLICIT_TAGS + OBSERVED_PLATFORM_CATEGORY_TAGS)

Do not assume one platform tag. Remove unrelated autofill tags and stay within the live limit.

14. Permissions

Enable only required runtime permissions derived from package evidence.

Optional shell/browser/network helpers with documented fallback remain optional rather than becoming required marketplace toggles merely because ChatGPT can use those capabilities.

15. Autosave and persistence

Wait for All changes saved or equivalent.

For important runs, reload and verify that exact values persisted. Hash comparison of long text fields is a useful audit technique when the environment exposes the values reliably.

16. Desktop and Mobile previews

Inspect both when available.

Compare exposed fields to the frozen Publisher set. Mark editor-only fields NOT_EXPOSED rather than pretending they were verified in preview.

17. Fixed platform compatibility strip

If Agensi renders a fixed compatibility-oriented message outside editable fields, classify:

PLATFORM_FIXED_COMPATIBILITY_CLAIM

Do not use it as evidence. Do not count it as an editable mismatch. Report it separately.

18. Asset reconciliation

ZIP without remote hash:

MATCH_BY_NAME_AND_STRUCTURE + REMOTE_ZIP_HASH_UNVERIFIED

Logo:

19. Multi-skill batch discipline

For each skill:

  1. establish active slug;
  2. validate assets;
  3. author through Publisher;
  4. preflight;
  5. create/identify draft;
  6. upload ZIP/logo;
  7. fill fields;
  8. save/reload;
  9. reconcile Desktop/Mobile/assets;
  10. record status;
  11. move to next target.

Never carry category, permission, price, tags or copy forward simply because two products look related.

20. Stop before submission

The browser authoring workflow ends at:

PUBLISHER_BROWSER_DRAFT_READY_FOR_CREATOR_REVIEW

Do not click Submit for Review. Do not publish. Do not call MCP submit_skill.

The creator performs review and any submission decision separately.

Single-Skill Template

Single-Skill Version-Neutral Template

Prepare exactly one Agensi draft for <SKILL_SLUG>.
Local folder: <LOCAL_SKILL_FOLDER>.

Agensi Publisher Skills via authorized MCP = AUTHORING AND GOVERNING AUTHORITY.
ChatGPT = EXECUTOR.
Chrome / Agensi Dashboard = ASSET UPLOAD, DRAFT ENTRY AND VERIFICATION.

Load the current Publisher and record its version metadata. Do not hardcode a Publisher version unless this run is specifically testing version parity.

Validate the exact ZIP, .sha256 and logo before buyer-facing authoring. Use NEW_SKILL_AUTHORING_MODE unless an explicit approved source applies. Build evidence, positioning, current-policy pricing/category, permissions, compatibility, buyer copy, Claim Audit, quality gates, Fresh Read Copy Critic, Authoring Validator, frozen field set and official preflight.

Treat Agensi autofill as UNTRUSTED_PLATFORM_AUTOFILL. Upload the exact verified ZIP and logo through normal browser controls. Populate only the frozen Publisher field set. Observe actual platform category tags after category selection; do not assume their count. Confirm autosave and reconcile Editor, Desktop Preview, Mobile Preview, ZIP and logo.

Report fixed non-editable compatibility UI separately as PLATFORM_FIXED_COMPATIBILITY_CLAIM. It is not Publisher evidence and not an editable mismatch.

ABSOLUTE STOP: do not click Submit for Review, do not publish, do not call MCP submit_skill, and do not invoke undocumented submission endpoints.

Return PUBLISHER_BROWSER_DRAFT_READY_FOR_CREATOR_REVIEW only after reconciliation.
Multi-Skill Template

Multi-Skill Version-Neutral Template

Prepare exactly <N> Agensi drafts sequentially, in this order:
1. <SKILL_1> — <LOCAL_FOLDER_1>
2. <SKILL_2> — <LOCAL_FOLDER_2>
...

Agensi Publisher Skills via authorized MCP = AUTHORING AND GOVERNING AUTHORITY.
ChatGPT = EXECUTOR.
Chrome / Agensi Dashboard = ASSET UPLOAD, DRAFT ENTRY AND VERIFICATION.

Load the current Publisher and record version metadata only for audit. Process one active listing at a time.

For every skill independently:
- establish ACTIVE_TARGET_SLUG;
- validate ZIP/.sha256/logo and package identity;
- build fresh evidence and positioning;
- derive pricing/category/permissions from that package and current Publisher policy;
- run all required Publisher gates and official preflight;
- create/identify the exact Agensi draft;
- upload exact ZIP and logo;
- replace UNTRUSTED_PLATFORM_AUTOFILL;
- observe actual PLATFORM_CATEGORY_TAGS after category selection;
- populate only the frozen Publisher field set;
- confirm autosave/reload persistence;
- reconcile Editor, Desktop Preview, Mobile Preview, ZIP and logo;
- record status before moving to the next skill.

Never reuse another skill's assets, evidence, price, category, tags, permissions, copy, FAQ, manifest or draft identity.

Classify fixed non-editable compatibility UI as PLATFORM_FIXED_COMPATIBILITY_CLAIM, not an editable mismatch.

Per-skill failures should be isolated when safe. Stop the whole batch if Publisher/authentication is unavailable globally, draft identity is unsafe, the wrong listing is being edited, or cross-skill isolation cannot be guaranteed.

ABSOLUTE STOP FOR EVERY SKILL: no Submit for Review, no publication, no MCP submit_skill, no undocumented submission endpoint.

Return per-skill reports plus a consolidated sequence summary.
Prompt Personalizer

Prompt Personalizer

Use this meta-prompt with ChatGPT when you want to adapt the public templates without weakening their safeguards.

Customize the supplied Agensi Publisher prompt for my target skill(s).

Replace only target-specific values such as:
- skill slug(s);
- local folder path(s);
- expected asset filenames;
- execution order;
- whether commercial decisions are blind or baseline-preserving;
- bounded creator pre-authorization.

Preserve without weakening:
- Agensi Publisher Skills as authoring/governing authority;
- ChatGPT as executor;
- evidence-before-copy rule;
- CLAIM_SCOPE_MUST_NOT_EXCEED_EVIDENCE_SCOPE;
- current Publisher policy rather than hardcoded version assumptions;
- required vs optional permission distinction;
- UNTRUSTED_PLATFORM_AUTOFILL handling;
- dynamic platform category-tag observation;
- official preflight requirement;
- Editor/Desktop/Mobile reconciliation;
- asset reconciliation vocabulary;
- PLATFORM_FIXED_COMPATIBILITY_CLAIM separation;
- cross-skill isolation;
- absolute stop before Submit for Review/publication.

Do not insert historical prices/categories unless I explicitly request a baseline-preserving commercial run.
Return the complete customized prompt ready to paste.