Art-Directed Conceptual Illustration
Cover, analogy, and takeaway slides run through LLM art-director prompt refinement with canvas palette harmonization and strict anti-garbled-text guardrails.
Named after Liezi’s artificer · Explicit, inspectable, replayable structure
Feed an idea, URL, GitHub repository, academic PDF, or recording into deterministic DAG pipelines and agent-native loops. Emit native editable OOXML .pptx, 16:9 .pdf, narrated 1080p .mp4, normalized .mp3, .xlsx workbooks, and verified vector diagrams.
$yanshi workflow run examples/generators/illustrated_slides.yml --input subject "Rust Zero-Copy I/O" --output-dir out/slides
Ingest web pages with DNS-pinned SSRF protection, snapshot GitHub repos without running untrusted code, parse PDFs/arXiv tarballs, or extract captions + ASR transcripts.
- id: ingest_repo
type: repo_snapshot
parameters:
max_files: 180
include_imports: true
- id: ingest_paper
type: pdf_extract
parameters:
extract_tables: true
The LLM plans structure, visual routing, and clarifying questions via ask_user while deterministic DAG templates govern execution, cost, and retries.
- id: clarify_scope
type: agent
run_if: "{{ interactive }}"
parameters:
tools: ["ask_user"]
max_iterations: 4
system_prompt: "Confirm scale, audience, and constraints before drafting."
Fan out across slides, chapters, voice tracks, art-directed illustrations, and D2/Typst/TikZ diagrams concurrently — feeding compiler diagnostics back automatically.
- id: build_visuals
type: map
parameters:
concurrency: 4
body:
- id: art_panel
type: illustration
run_if: "{{ item.visual_kind == 'illustration' }}"
- id: arch_svg
type: figure
run_if: "{{ item.visual_kind == 'arch_diagram' }}"
Pure-Rust writers emit editable PowerPoint shapes/tables (.pptx) and typed Excel sheets (.xlsx), paired with sandboxed Typst, Pandoc, and FFmpeg muxing.
- id: deck_bundle
type: render_slides
parameters:
export_pptx: true # Pure-Rust native editable OOXML
export_pdf: true # 16:9 Typst vector deck
theme: "{{ slide_theme }}"
Deliverables travel through the graph as typed FlowValue::File handles with SHA-256 manifests — inspect inline in Studio or resume interrupted runs without re-billing.
# Resume an interrupted multi-stage video run from last completed node:
yanshi workflow resume 019a8f2c examples/generators/tech_slides_video.yml \
--output-dir out/lecture
All three slides below were produced in a single Yanshi run. Each slide is routed by intent to the right visual engine and compiled together into native editable OOXML .pptx, 16:9 .pdf, and interactive .html.
Cover, analogy, and takeaway slides run through LLM art-director prompt refinement with canvas palette harmonization and strict anti-garbled-text guardrails.
System topologies, state machines, and dataflows compile cleanly via D2, Typst, TikZ, or isolated Python — automatically repairing syntax or layout errors before export.
Code walkthroughs, benchmarks, and checklists emit real PowerPoint shapes (<p:sp>), <a:tbl> tables, and connectors — 100% editable in PowerPoint or Keynote.
Span the full binding-time spectrum — from fixed production DAGs to autonomous agent loops and runtime-compiled flows — sharing one ToolRegistry, checkpoint format, and security harness.
Built for repeatable Studio pipelines, RAG indexing, and batch automation. Validate expressions and node schemas statically before spending a token.
map, while, and run_if
cost_limit_usd enforcement
AgentNode
# Validate statically, cap spend, and export numeric Excel sheets
name: paper_reader
cost_limit_usd: 1.50
nodes:
- id: extract
type: pdf_extract
parameters:
source: "{{ source }}"
extract_tables: true
- id: bilingual_digest
type: llm
dependencies: ["extract"]
parameters:
model: "gpt-4o"
response_format: json_schema
prompt: "Synthesize key contributions and benchmarks..."
- id: export_excel
type: render_table
dependencies: ["bilingual_digest"]
parameters:
format: "xlsx"
Every observe, plan, tool call, reflection, and verification step is typed and traceable — and any DAG workflow can be exposed to the agent as a WorkflowTool.
SKILL.md packages
ask_user interrupt/resume across CLI, HTTP SSE, and Tauri
# Planner agent inspects the source, selects matching DAG generators,
# invokes WorkflowTools in parallel, and verifies output artifacts:
yanshi skill run examples/applications/content-studio \
--input url="https://arxiv.org/abs/1706.03762" \
--input want="report,mindmap,audio_overview" \
--output-dir "out/studio-bundle"
DynamicWorkflowAgent authors a bounded execution plan at runtime and compiles it via compile_plan_to_flow into an inspectable, parallel Flow.
use yanshi_agents::dynamic::{compile_plan_to_flow, DynamicWorkflowAgent};
use yanshi_core::FlowExt;
let plan = planner_agent.author_plan(&task, &allowed_tools).await?;
let flow = compile_plan_to_flow(&plan, ®istry)?;
// Executes on the standard concurrent scheduler with full tracing & checkpoints:
let outputs = flow.run().await?;
Embed only the crates you need. Under SecurityProfile::Production, macOS sandbox-exec / Linux Landlock+seccomp+cgroup v2 and Ed25519 signature checks are enforced fail-closed.
code_exec enforces zero-network ContainerBackend isolation
HttpTool closes TOCTOU SSRF gaps
use std::sync::Arc;
use yanshi_core::{flow::{Flow, GraphNode, NodeType}, FlowExt};
use yanshi_nodes_ai::nodes::llm::LlmNode;
use yanshi_tool::SecurityProfile;
// Production fail-closed defaults: OS sandbox & Ed25519 signature verification
let profile = SecurityProfile::Production;
let mut flow = Flow::new();
flow.add_node(GraphNode::standard("summarize", Arc::new(LlmNode::default())));
let result = flow.run().await?;
Select any template card below to inspect its full syntax-highlighted YAML source, DAG node topology, and CLI command right on this page.
Web-grounded keynote deck routing slides across 6 art-directed illustration styles, D2 diagrams, and native OOXML shapes.
Step-by-step progressive slide builds synced millisecond-accurately to TTS narration, spotlight rings, and optional PiP presenter.
Source-grounded presentation with self-repairing vector diagrams; works with zero image API keys out of the box.
Parallel multi-scene visual generation (stills or optional motion clips) muxed with per-scene voiceover and subtitles.
Two-speaker conversational deep-dive voiced in parallel and loudness-normalized to EBU R128 via render_audio.
Scans repository manifests and internal imports safely without executing code, producing verified D2 architecture diagrams and PDF dossier.
Interactive HITL clarification followed by system architecture, UML class/sequence, ER diagrams, PostgreSQL .sql DDL, and spec PDF.
Extracts experimental benchmark tables into typed Excel workbooks alongside a bilingual digest PDF, method diagram, and mindmap.
Prefers native captions with automatic fallback to FFmpeg audio extraction + ASR, emitting timestamped notes, .srt, and mindmap.
Parallel section drafting with verbatim source quotes and chunk-level footnote citations, typeset cleanly into HTML and PDF.
Extracts schema-checked headline metrics and renders crisp deterministic SVG and high-DPI PNG posters.
Hierarchical knowledge tree rendered simultaneously as vector SVG, PNG, and interactive collapsible HTML.
Extracts a typed parts list first, validates every component ID, and compiles publication-grade circuitikz schematics.
Turns source material into a self-contained offline flip-card study deck and structured JSON dataset.
Self-grading multiple-choice assessment page with instant answer rationales and score tracking.
Runtimes never depend on each other — only on the zero-logic L0 contract kernel, guarded continuously in CI by cargo xtask check-arch.
Validate, execute, checkpoint-resume, and inspect runs interactively in the terminal TUI with yanshi trace replay.
cargo install --path yanshi-cli
Launch yanshi-server for /ui/app template forms and /ui/studio DAG debugging with per-node breakpoints and inline media preview.
cargo run --package yanshi-server
Standalone Tauri v2 app embedding the local Rust engine — zero Postgres or external server process required.
./scripts/install_desktop.sh --open
Answers on native editable deliverables, model keys, OS-level sandboxing, and how Yanshi compares to Python agent stacks.
They are real, native OOXML presentations. Yanshi’s pure-Rust OOXML writer emits standard PowerPoint shapes (<p:sp>), native tables (<a:tbl>), code callouts, and connectors that open directly for text and layout editing in PowerPoint or Keynote — combined per-slide with verified D2/Typst/TikZ diagrams and 6 art-directed illustration styles, plus matching 16:9 .pdf and .html exports.
Yes. A single text LLM key runs most Studio generators out of the box — including slides.yml, report.yml, repo_architecture.yml, backend_project_planner.yml, paper_reader.yml, and mindmap.yml. Yanshi natively supports OpenAI, Anthropic Claude, Google Gemini, Moonshot, StepFun, and any OpenAI-compatible endpoint (DeepSeek, Qwen, or local Ollama).
Yanshi unifies deterministic concurrent DAGs, native autonomous agent loops (ReAct, Plan-Execute, Handoff/Blackboard/Debate), and runtime-compiled dynamic workflows on one narrow-waist Rust kernel. You get a single fast binary (< 1ms scheduling overhead, built-in 44-model cost_limit_usd enforcement) and first-class FlowValue::File multimodal renderers (.pptx, 1080p .mp4, .pdf, .xlsx, .mp3) with zero Python dependency drift or Base64 memory bloat.
Under SecurityProfile::Production, security is fail-closed by default: shell and renderer subprocesses run inside OS sandboxes (macOS sandbox-exec or Linux Landlock + seccomp + cgroup v2), code_exec requires a zero-network ContainerBackend, repo_snapshot inspects manifests statically without executing code, HttpTool pins DNS per request to block TOCTOU SSRF, and marketplace skills/plugins verify Ed25519 signatures.
No. With --checkpoint (and automatically on the gateway/Studio), Yanshi persists node outputs, SHA-256 file manifests, and accrued spend after every node. Running yanshi workflow resume <run_id> replays completed upstream outputs from disk and executes only unfinished downstream nodes under the remaining cost budget.