Agent Mesh Coordinator
ruvnet/ruflo
Agent skill for mesh-coordinator - invoke with $agent-mesh-coordinator
Generate through-thickness mesh for composite curing simulation.
$ npx skills add Cai-aa/CAE-Agent-Hub --skill composite-mesh -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install Cai-aa/CAE-Agent-Hub composite-mesh --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/Cai-aa/CAE-Agent-Hub.git skills-src && mkdir -p .claude/skills && cp -r skills-src/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh .claude/skills/composite-mesh && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "composite-mesh" agent skill from https://github.com/Cai-aa/CAE-Agent-Hub/tree/main/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh into .claude/skills/composite-mesh/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "composite-mesh", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/Cai-aa/CAE-Agent-Hub/tree/main/Skill/abaqus/composite-curing-simulation/modeling/composite-meshType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add Cai-aa/CAE-Agent-Hub --skill composite-mesh -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install Cai-aa/CAE-Agent-Hub composite-mesh --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Cai-aa/CAE-Agent-Hub.git skills-src && mkdir -p .agents/skills && cp -r skills-src/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh .agents/skills/composite-mesh && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "composite-mesh" agent skill from https://github.com/Cai-aa/CAE-Agent-Hub/tree/main/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh into .agents/skills/composite-mesh/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "composite-mesh", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add Cai-aa/CAE-Agent-Hub --skill composite-mesh -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install Cai-aa/CAE-Agent-Hub composite-mesh --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Cai-aa/CAE-Agent-Hub.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh .cursor/skills/composite-mesh && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "composite-mesh" agent skill from https://github.com/Cai-aa/CAE-Agent-Hub/tree/main/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh into .cursor/skills/composite-mesh/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "composite-mesh", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/Cai-aa/CAE-Agent-Hub.git --path Skill/abaqus/composite-curing-simulation/modeling/composite-mesh--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add Cai-aa/CAE-Agent-Hub --skill composite-mesh -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install Cai-aa/CAE-Agent-Hub composite-mesh --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Cai-aa/CAE-Agent-Hub.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh .gemini/skills/composite-mesh && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "composite-mesh" agent skill from https://github.com/Cai-aa/CAE-Agent-Hub/tree/main/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh into .gemini/skills/composite-mesh/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "composite-mesh", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install Cai-aa/CAE-Agent-Hub composite-meshInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add Cai-aa/CAE-Agent-Hub --skill composite-mesh -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/Cai-aa/CAE-Agent-Hub.git skills-src && mkdir -p .github/skills && cp -r skills-src/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh .github/skills/composite-mesh && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "composite-mesh" agent skill from https://github.com/Cai-aa/CAE-Agent-Hub/tree/main/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh into .github/skills/composite-mesh/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "composite-mesh", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add Cai-aa/CAE-Agent-Hub --skill composite-mesh -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install Cai-aa/CAE-Agent-Hub composite-mesh --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Cai-aa/CAE-Agent-Hub.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh .opencode/skills/composite-mesh && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "composite-mesh" agent skill from https://github.com/Cai-aa/CAE-Agent-Hub/tree/main/Skill/abaqus/composite-curing-simulation/modeling/composite-mesh into .opencode/skills/composite-mesh/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "composite-mesh", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
composite-meshGenerate through-thickness mesh for composite curing simulation.
Composite Mesh is an agent skill from Cai-aa/CAE-Agent-Hub. Generate through-thickness mesh for composite curing simulation. Invoke when user needs C3D8 solid elements, composite mesh, or through-thickness element layout.
Its SKILL.md is about 3.5k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.
The licence is MIT.
5 steps, taken from the first numbered list in SKILL.md.
Read from SKILL.md and the folder at commit 194ef49. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md (its code samples are python).
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Composite Mesh loads about 3.5k tokens when it runs. Until then it costs about 44 tokens; SKILL.md has 1,511 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from Cai-aa/CAE-Agent-Hub at commit 194ef49, republished under its MIT licence (© Cai-aa). 1,511 words, ~3,502 tokens.
.claude/skills/composite-mesh/SKILL.md (or your agent's skills folder).This skill generates the through-thickness mesh for the composite (P8) part in curing simulation. It covers element type selection, through-thickness discretization, in-plane mesh layout, surface element set identification, and mesh quality considerations.
The composite part uses C3D8 elements: 8-node linear brick elements with full integration.
*Element, type=C3D8
1, <n1>, <n2>, <n3>, <n4>, <n5>, <n6>, <n7>, <n8>| Property | C3D8 (Full Integration) | C3D8R (Reduced Integration) |
|---|---|---|
| Integration pts | 8 (2x2x2) | 1 (centroid) |
| Hourglassing | No | Yes (needs control) |
| Accuracy | Higher for bending | Lower for bending |
| Use case | Composite plies (this model) | Tool/mold (this model) |
Full integration (C3D8) is preferred for the composite because:
The tool/mold part uses C3D8R (reduced integration) because it is a bulk body where hourglassing is less of a concern and computational efficiency matters more.
The through-thickness direction is along the X-axis, spanning from X = -1 to X = 0. This means the composite thickness is 1 unit (1 mm in model units) in the X direction.
X = -1.0 +-----------------------------------+
| Ply-1 (element layer 1) |
X = -0.75+-----------------------------------+ (4-ply: 0.25 mm each)
| Ply-2 (element layer 2) |
X = -0.5 +-----------------------------------+
| Ply-3 (element layer 3) |
X = -0.25+-----------------------------------+
| Ply-4 (element layer 4) |
X = 0.0 +-----------------------------------+The stack direction in *Solid Section, composite is 3, which corresponds to this
X-axis through-thickness direction via the orientation definition.
The 4-ply mesh has 4 elements through the thickness, each 0.25 mm thick (total 1 mm).
| Property | Value |
|---|---|
| Through-thickness elements | 4 |
| Ply thickness | 0.25 mm |
| Total thickness | 1.0 mm |
| In-plane nodes per layer | 605 |
| Total elements | 2160 |
| Total nodes | 3025 |
The 8-ply mesh has 8 elements through the thickness, each 0.125 mm thick (total 1 mm).
| Property | Value |
|---|---|
| Through-thickness elements | 8 |
| Ply thickness | 0.125 mm |
| Total thickness | 1.0 mm |
| In-plane nodes per layer | 605 |
| Total elements | 4320 |
| Total nodes | 5445 |
The in-plane mesh is shared between the 4-ply and 8-ply models. Both have 605 nodes per through-thickness layer and 540 elements per through-thickness layer.
| Property | Value |
|---|---|
| Nodes per layer | 605 |
| Elements per layer | 540 |
| Shape | L-bracket |
| In-plane dimensions | 100 mm |
The in-plane mesh defines the L-bracket shape. The through-thickness discretization (4 or 8 layers) is applied on top of this in-plane mesh by extruding nodes and elements in the X direction.
Each C3D8 element has 8 nodes. The connectivity follows the standard Abaqus brick element node ordering:
8-------7
/| /|
5-------6 |
| | | |
| 4-----|-3
|/ |/
1-------2| Node | Position |
|---|---|
| 1 | Bottom face, corner 1 |
| 2 | Bottom face, corner 2 |
| 3 | Bottom face, corner 3 |
| 4 | Bottom face, corner 4 |
| 5 | Top face, corner 1 |
| 6 | Top face, corner 2 |
| 7 | Top face, corner 3 |
| 8 | Top face, corner 4 |
Element N in the through-thickness direction has nodes at two consecutive X-coordinate layers. For the 4-ply mesh:
For element N (where N is the global element number), the through-thickness layer is:
layer = (N - 1) // in_plane_element_count
# in_plane_element_count = 540 for both 4-ply and 8-ply modelsFor a 4-ply model with 540 in-plane elements per layer:
Each element's 8 nodes consist of 4 nodes from the lower X layer and 4 nodes from the upper X layer, with matching in-plane positions.
Two surface element sets are defined for the composite part. These sets identify the elements on the outer and inner surfaces of the L-bracket, which are used for contact and pressure application.
*Elset, elset=_com-surface_S1, internal
<element_numbers>tool-surface*Elset, elset=__PickedSurf337_S2, internal
<element_numbers>*Dsload _PickedSurf337, P, 0.6)For the surface element sets, elements are selected from specific through-thickness positions. The S1 face corresponds to one side of the through-thickness stack, and the S2 face corresponds to the other side.
# For a 4-ply model (4 through-thickness layers, 540 elements per layer)
# S1 (outer) elements: layer 0, specific in-plane elements
# S2 (inner) elements: layer 3, specific in-plane elements
# The surface elements are every Nth element where N depends on the
# in-plane mesh pattern at the surface faceTo identify which elements belong to the S1 or S2 surface, examine the element connectivity and node coordinates.
Parse all elements: Read the *Element, type=C3D8 block to get all element
connectivities.
Parse all nodes: Read the *Node block to get all node coordinates.
Identify surface nodes: Find nodes that lie on the outer surface (S1) or inner surface (S2) by checking their in-plane coordinates against the bracket boundary.
Identify surface elements: For each element, check if it has a face (4 nodes) that lies entirely on the target surface. The face is identified by the S1 or S2 face label in the C3D8 element convention.
Build element set: Collect all element IDs that have a face on the target surface.
def identify_surface_elements(elements, nodes, surface_face='S1'):
"""
Identify elements on a given surface face.
Args:
elements: Dict of {element_id: [node1, ..., node8]}
nodes: Dict of {node_id: (x, y, z)}
surface_face: 'S1' (outer) or 'S2' (inner)
Returns:
List of element IDs on the surface.
"""
# C3D8 face definitions: face -> node indices (0-based)
face_nodes = {
'S1': [0, 1, 2, 3], # Bottom face (nodes 1,2,3,4)
'S2': [4, 5, 6, 7], # Top face (nodes 5,6,7,8)
}
# Determine target X coordinate for the surface
if surface_face == 'S1':
target_x = -1.0 # Outer surface (X = -1)
else:
target_x = 0.0 # Inner surface (X = 0)
surface_elements = []
for elem_id, node_list in elements.items():
face_idx = face_nodes[surface_face]
face_node_ids = [node_list[i] for i in face_idx]
# Check if all face nodes are at the target X coordinate
all_on_surface = all(
abs(nodes[nid][0] - target_x) < 1e-6
for nid in face_node_ids
)
if all_on_surface:
surface_elements.append(elem_id)
return sorted(surface_elements)| Face | Node Indices (0-based) | Node Numbers (1-based) | Description |
|---|---|---|---|
| S1 | 0, 1, 2, 3 | 1, 2, 3, 4 | Bottom face (X = -1) |
| S2 | 4, 5, 6, 7 | 5, 6, 7, 8 | Top face (X = 0) |
| S3 | 0, 1, 5, 4 | 1, 2, 6, 5 | Side face |
| S4 | 1, 2, 6, 5 | 2, 3, 7, 6 | Side face |
| S5 | 2, 3, 7, 6 | 3, 4, 8, 7 | Side face |
| S6 | 3, 0, 4, 7 | 4, 1, 5, 8 | Side face |
Note: The exact face-to-node mapping depends on the element node ordering in the INP file. Always verify by checking node coordinates against the expected surface position.
When changing from 4 plies to 8 plies (or vice versa), the entire through-thickness mesh must be regenerated. This is because:
Use the merge strategy described in modeling/composite-layup to swap the P8 Part from
a pre-built model with the correct mesh.
Element type mismatch: The composite uses C3D8 (full integration), while the tool uses C3D8R (reduced integration). Do not swap these.
Through-thickness direction: The thickness is along the X-axis (from -1 to 0), not the Z-axis. This is set by the orientation and stack direction, not by the mesh alone.
Surface face labels: S1 is the outer/contact surface (X = -1), and S2 is the inner/pressure surface (X = 0). Do not confuse these when defining surface element sets.
Node count verification: After mesh generation, verify the total node count matches the expected value (3025 for 4-ply, 5445 for 8-ply). A mismatch indicates a mesh error.
In-plane mesh sharing: The in-plane mesh (605 nodes per layer, 540 elements per layer) is the same for both 4-ply and 8-ply models. Only the through-thickness discretization differs.
Element numbering continuity: Elements are numbered sequentially through the through-thickness layers. Element layer boundaries occur at multiples of the in-plane element count (540). Use this to assign ply labels correctly.
© Cai-aa, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Just SKILL.md in Skill/abaqus/composite-curing-simulation/modeling/composite-mesh of Cai-aa/CAE-Agent-Hub.
Open the folder on GitHubat commit 194ef49
Composite Mesh next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Composite Mesh this skillCai-aa/CAE-Agent-Hub | 998 | — | ~3.5k | Automated safety check: Pass | MIT | |
| Agent Mesh Coordinatorruvnet/ruflo | 74k | 3 repos | ~3.2k | Automated safety check: Pass | MIT | |
| Composition Patternssickn33/agentic-awesome-skills | 47k | 1 repos | ~742 | Automated safety check: Pass | MIT | |
| Eas Simulatorsickn33/agentic-awesome-skills | 47k | 1 repos | ~6k | Automated safety check: Notes | MIT | |
| Service Meshsickn33/agentic-awesome-skills | 47k | 2 repos | ~2.7k | Automated safety check: Pass | MIT | |
| Vercel Composition Patternssupabase/supabase | 111k | 59 repos | ~726 | Automated safety check: Pass | MIT |
ruvnet/ruflo
Agent skill for mesh-coordinator - invoke with $agent-mesh-coordinator
sickn33/agentic-awesome-skills
A skill your agent uses when working with composition-patterns tasks or workflows
sickn33/agentic-awesome-skills
Curated upstream guidance for Eas Simulator; use when the workflow matches the user goal.
sickn33/agentic-awesome-skills
Implement Istio and Linkerd service meshes. An agent skill from sickn33/agentic-awesome-skills.
supabase/supabase
React composition patterns that scale. An agent skill from supabase/supabase.
wshobson/agents
Design optimal agent team compositions with sizing heuristics, preset configurations, and agent type selection.
Cai-aa/CAE-Agent-Hub
Operate or inspect live ANSYS Workbench Mechanical structural simulations through the configured MCP, including model setup, materials, connections, loads, mesh, solve, convergence, validation, and…
Cai-aa/CAE-Agent-Hub
Plan, create, adapt, and quality-audit coin-style five-block O-grid hexahedral meshes for cylindrical CAE models.
Cai-aa/CAE-Agent-Hub
Evidence-first COMSOL Java API and batch workflow for permanent-magnet motor NVH.
Cai-aa/CAE-Agent-Hub
Evidence-first Ansys Electronics Desktop and PyAEDT automation for Maxwell, HFSS, Q3D, Icepak, and related electromagnetic workflows.
Cai-aa/CAE-Agent-Hub
Evidence-first Ansys Mechanical structural automation through Workbench RunWB2 journals, Mechanical Scripting/ACT ExtAPI, or PyMechanical gRPC.
Cai-aa/CAE-Agent-Hub
Run, diagnose, reproduce, and validate ANSYS Fluent CFD simulations of forced-convection autoclaves using Fluent MCP or PyFluent.
Generate through-thickness mesh for composite curing simulation. Composite Mesh is an agent skill from Cai-aa/CAE-Agent-Hub. Generate through-thickness mesh for composite curing simulation.
Composite Mesh fits situations like: needs C3D8 solid elements; through-thickness element layout.
Run `npx skills add Cai-aa/CAE-Agent-Hub --skill composite-mesh -a claude-code`. Or copy the skill folder (Skill/abaqus/composite-curing-simulation/modeling/composite-mesh in Cai-aa/CAE-Agent-Hub) into .claude/skills/composite-mesh in your project. Claude Code loads it when a task matches its description.
Run `npx skills add Cai-aa/CAE-Agent-Hub --skill composite-mesh -a codex`. Or copy the skill folder (Skill/abaqus/composite-curing-simulation/modeling/composite-mesh in Cai-aa/CAE-Agent-Hub) into .agents/skills/composite-mesh in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Cai-aa/CAE-Agent-Hub --skill composite-mesh -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/composite-mesh, .gemini/skills/composite-mesh, .github/skills/composite-mesh and .opencode/skills/composite-mesh in your project.
SKILL.md names no scripts, command-line tools or credentials: Composite Mesh is instructions for the agent only. Our summary lists: Python 3.
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Composite Mesh is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 3.5k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
Skills that share tags, products or a category with Composite Mesh: Agent Mesh Coordinator (ruvnet/ruflo, 74k stars), Composition Patterns (sickn33/agentic-awesome-skills, 47k stars), Eas Simulator (sickn33/agentic-awesome-skills, 47k stars) and Service Mesh (sickn33/agentic-awesome-skills, 47k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Cai-aa (a GitHub user) maintains it in Cai-aa/CAE-Agent-Hub, which has 998 GitHub stars. The repository holds 57 skills in this directory. The repository was last updated on September 30, 2026.
Source: Cai-aa/CAE-Agent-Hub on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.