15 copy-paste agent skills powered by the Oyza Core certainty protocol. Built for research, programming, and visual communication in Gumloop workflows.
Every agent in Gumzen runs under the behavioral guardrails of Oyza Core — a portable contract for human-agent interaction and epistemic calibration:
- Strict Evidence Calibration: Differentiates reported claims, direct physical measurements, logical inferences, and unproven hypotheses.
- Goal Custody: Executes explicit objectives without substituting assumed goals, and asks clarifying questions only when trade-offs materially affect scope.
- Minimal filler: Aims to avoid sycophancy, synthetic polite preambles, and conversational filler (a prompt-level intent, not a measured guarantee).
- Contained Authority: An analysis does not authorize execution; destructive actions need explicit delegation.
You can run any Gumzen skill inside Gumloop in less than 60 seconds:
- Pick a Skill: Browse the catalog below and open its
SKILL.mdfile. - Copy the Payload: Scroll down to the "Bloque Listo para Copiar (Copy-Ready Payload)" section and click the native copy button.
- Paste into Gumloop: In your Gumloop workflow canvas, drag an AI Agent Node, paste the payload into its System Prompt / Instructions field, and wire your input variables.
Each skill sets behavioral rules for the agent. Output quality depends on the model and on the inputs you provide, and it has not been benchmarked. Read each skill's SKILL.md for its expected inputs (for example, the epistemic auditor needs the gate report and the primary text).
The suite is divided into three focused domains with clear boundaries:
| Skill | Primary Focus | Concrete Deliverable |
|---|---|---|
scout |
Clean-room reconnaissance | Isolates the essential 5% algorithm, discarding 95% framework bloat while analyzing closed issues for hidden bugs. |
idea-maximizer |
Multi-horizon exploration | Generates 3 tiered alternatives (Direct, Adjacent, Aspirational) bound to falsifiable verification milestones. |
intent-contract |
Socratic intent capture | Resolves ambiguous prompts via at most 2 high-leverage A/B/C trade-off queries and locks non-goals. |
code-audit |
Adversarial static review | Inspects diffs across 4 lenses: resource lifecycles, race conditions, AST idioms, and security boundaries. |
causal-debug |
Root-cause diagnostic | Separates root causes from surface symptoms using counter-factual placebo tests and regression suites. |
| Skill | Primary Focus | Concrete Deliverable |
|---|---|---|
humanizer |
Cadence & anti-slop editing | Guides sentence-length variation and avoids common synthetic phrasing. Prompt-level guidance, not measured on outputs. |
presentation-architect |
Widescreen Marp slide decks | Generates 16:9 Marp presentations with KaTeX math, a strict 18-line vertical budget, and timed speaker notes. |
visual-explainer |
Spatial mental models | Translates complex flows into pure terminal ASCII blueprints and rendered GitHub Mermaid diagrams. |
narrative-distiller |
BLUF executive briefings | Compresses long threads and reports into 2-sentence conclusions with exact metrics and reversible next steps. |
pedagogic-editor |
Instructional scaffolding | Balances cognitive load through 3 stages: intuitive physical anchor, minimal runnable skeleton, and edge cases. |
| Skill | Primary Focus | Concrete Deliverable |
|---|---|---|
web-research-filter |
Noise & SEO scrubbing | Triangulates claims across |
paper-deconstructor |
Empirical paper dissection | Separates direct observations from author inferences and outputs normalized Unicode BibTeX citations. |
concept-synthesizer |
Cross-domain isomorphisms | Uncovers formal mathematical and systemic equivalents across different vocabularies and disciplines. |
socratic-tutor |
Active discovery inquiry | Presents minimal counter-examples to challenge assumptions without unsolicited answers or patronizing lectures. |
epistemic-auditor |
Pre-flight quality gate | Semantic audit of provenance and causal bounds. Numeric and Marp-budget checks come from the deterministic gate. |
Every skill in Gumzen is engineered with a strict copy-ready boundary:
User: "Build a 6-slide Marp presentation explaining our distributed queue benchmark."
Agent: "Here is your Marp presentation ready for projection:
┌────────────────────────────────────────────────────────┐
│ ```markdown │
│ --- │
│ marp: true │
│ size: 16:9 │
│ theme: gaia │
│ ... │
│ ``` │
└────────────────────────────────────────────────────────┘
⏱️ Presentation Duration: 8 minutes.
💡 Speaker Tip: Focus on the throughput drop at Slide 3 before explaining the fix."
The copy-ready blocks are written to avoid greetings and signatures. Still review the output before publishing it.
The repository provides a complete 6-node workflow in workflows/academic_research_pipeline.json:
- User Input: Topic or arXiv research query.
- arXiv Fetcher (Python): Retrieves verified metadata and abstracts without LLM token cost.
- Paper Deconstructor (Agent): Extracts empirical evidence and builds a normalized BibTeX registry.
- Presentation Architect (Agent): Compiles 16:9 Marp slides with speaker notes.
- Deterministic Gate Checks (Python): Checks in code, without an LLM: Marp frontmatter, 18-line budget, speaker-note timing, numeric provenance against the primary text, and BibTeX keys.
- Epistemic Auditor (Agent): Evaluates provenance and causal bounds, using the deterministic gate report.
The auditor needs the gate report, the primary text (papers_markdown), and the slides. The DAG is a reference layout: the import format of this JSON in Gumloop has not been verified, so wire the nodes manually and paste each skill and custom-node code.
You can verify the entire test suite locally:
npm testThis executes:
-
tests/suite_runner.cjs: Validates file structures, DAG contracts, BibTeX generation, zero legacy duplicates, and all 15 skills. -
tests/test_gate_checks.cjs: Tests deterministic gate checks with mutations for frontmatter, line budgets, speaker notes, and provenance. -
tests/test_humanize_and_marp.cjs: Audits prose cadence, burstiness ($\sigma^2 \ge 6.0$ ,$CV \ge 0.25$ ), anti-slop rules, and Marp syntax.
- Numeric provenance is by value: the gate checks that each number in the slides appears in the primary text. A correct number used in the wrong context passes.
- No primary text, no numeric check: if the primary text is empty, numeric provenance is not verified.
- Partial coverage: integers below 10 without
%or decimals are not checked; years from 1900 to 2099 are ignored. - Derived figures: values computed from the source (reductions, averages) are flagged and need human review.
- No output benchmark: skill quality depends on the model and inputs and has not been measured on agent outputs.
- Humanizer metrics are prompt-level guidance; the tests check the skill text, not the generated prose.
Distributed under the MIT License.
Gumzen builds upon open work by the research and developer community:
- Marp Team and robonuggets for Markdown slide design conventions.
- ngtiendong for academic literature deconstruction patterns.
- The Axkern ecosystem and Oyza Core for epistemic verification and interaction contracts.
See ATTRIBUTION.md for detailed provenance records.
🇪🇸 Resumen en Español (Haz clic para expandir)
Gumzen opera sobre el contrato de interacción y certeza Oyza Core, garantizando distinción rigurosa entre observaciones directas e inferencias, cero adulación, economía de recursos y verificación adversarial.
- Programación:
scout,idea-maximizer,intent-contract,code-audit,causal-debug. - Comunicación:
humanizer,presentation-architect,visual-explainer,narrative-distiller,pedagogic-editor. - Investigación:
web-research-filter,paper-deconstructor,concept-synthesizer,socratic-tutor,epistemic-auditor.
Cada habilidad contiene un bloque listo para pegar en los nodos de agente de Gumloop, redactado para evitar saludos y firmas personales.
El DAG de ejemplo tiene 6 nodos. La compuerta determinista (código, sin LLM) verifica el frontmatter Marp, el presupuesto de 18 líneas, las notas con tiempo, la procedencia numérica frente al texto primario y las claves BibTeX. El auditor del agente evalúa procedencia semántica y límites causales.
La procedencia numérica compara valores, no contexto; sin texto primario no se verifican cifras. Los agentes no están evaluados con benchmarks: el comportamiento depende del modelo y de las entradas.
Consulte ATTRIBUTION.md y LICENSE para detalles completos.