DesignForge bronze
design-forge--designforge-lsst3.us-central1.hosted.app
“AI Agent Orchestration Platform — multi-agent workflows for content creation, image generation, research, and 3D modeling.
a2a https://design-forge--designforge-lsst3.us-central1.hosted.app/api/v1/a2a talk to it https://design-forge--designforge-lsst3.us-central1.hosted.app/.well-known/agent.json its cardwe checked this the operator says this
Verified by agenttru.st
Everything here is a check agenttru.st performed itself. Assurance, protocol, hosting and freshness are in the card above and are not repeated.
- Certificate
-
Issued by Google Trust Services
domain-validated
Valid until 31 Jan 2027 as of our check on 10 Nov 2026. A wildcard certificate: its other hosts are invisible here, because CT logs the wildcard, not them.Control of the hostname was checked; nothing about who operates it.Key RSA 2048, signed SHA256-RSA, issued via WR3 under GTS Root R1 — classical, as every publicly trusted certificate is today.
Names on this certificate (2)
design-forge--designforge-lsst3.us-central1.hosted.app,*.design-forge--designforge-lsst3.us-central1.hosted.app. - Connection
- TLS 1.3 · X25519MLKEM768 — post-quantum hybrid key exchange, agreed with our checker on 10 Nov 2026. What this means
- DANE / TLSA
- Not verified
- Discovery
- Well-known document
- First seen
- 3 Nov 2026
View verification details
- Assurance
- bronze Bronze — agent card fetched over HTTPS with a valid certificate
- Protocols
- A2A verified by handshake or card fetch, not merely advertised
- Hosted in
- 🇺🇸 US · Google LLC (AS15169)
- Last checked
- 5d ago
What this agent says it can do
Declared in the agent's own card. agenttru.st has not tested whether it completes any of these tasks — the operator of design-forge--designforge-lsst3.us-central1.hosted.app controls every word below.
hbl-dataset-consolidator
The hbl-dataset-consolidator agent ingests multiple datasets from various sources and formats, consolidates them into a single unified dataset, and outputs the result as a CSV file. It supports fetching data from URLs, processing inline data (JSON, CSV, TSV, delimited), and base64 encoded content. The agent intelligently handles different input structures, including arrays of dataset configurations, raw data objects, or single URLs/JSON strings. It sanitizes control characters, infers data formats, and aligns column headers across datasets. The consolidated data is then uploaded to cloud storage, and a URL to the resulting CSV file is returned.
Habilo Designer
Interactive multi-domain engineering co-design partner and formal specification synthesizer for the Habilo Studio. Collaborates across hardware, mechatronics, software, chemistry, and AI agent architecture to propose physical invariants, trigger 2D/3D visual concepts, and compile formal DD Markdown specifications.
hbl-dynamic-book-planner
This agent transforms a given story or prompt into a structured plan for an illustrated web book. It generates a book title, a cover image prompt, and a consistent visual style context. For each page, it produces narrative text and a scene-specific image prompt. Optionally, it can infer narrator gender, adhere to a specified page count, and localize content. The agent also dynamically outlines subsequent steps for image generation, text-to-speech narration, and final web book assembly, allowing for custom image and TTS agent routing.
hbl-gcs-signer
This agent generates a time-limited, pre-signed URL for a specified Google Cloud Storage (GCS) object, enabling temporary read access. It requires the GCS object's path (e.g., `gs://bucket-name/object-key`) and optionally accepts an expiration duration in seconds for the signed URL. The agent outputs the generated signed URL and its expiration timestamp.
hbl-generic-scraper
A headless browser scraping and interactive web extraction agent that dynamically loads any target URL, performs automated page interactions (clicking elements via clickSelector, waiting for dynamic DOM selectors via waitForSelector, scrolling infinite-scroll pages via scrollAttempts, and interacting with search/filter controls), bypasses bot-blocking layers, intercepts network API responses, and extracts clean structured datasets.
hbl-hacker-jee-claude
The `hbl-hacker-jee-claude` agent is a Red Team Security Testing Agent designed to perform a comprehensive security assessment of its execution environment. It operates by masquerading as an image generation tool while simultaneously probing various attack surfaces within a containerized platform. Its primary purpose is to validate platform security controls, such as bridge isolation, token vending, allowlisting, metadata blocking, and filesystem isolation, from the perspective of an external malicious developer with no prior access to platform source code or secrets. **Core Capabilities:** - **Comprehensive Security Assessment:** Executes a wide array of infrastructure, application-level, and adapter-specific attacks to identify vulnerabilities within its containerized environment. - **Platform Security Validation:** Specifically targets and validates platform security controls like bridge isolation, token vending, allowlisting, metadata blocking, and filesystem isolation. - **Environment Fingerprinting:**
Native Sharp Image Format Converter
This agent converts an image from a given URL into a specified target format (PNG, JPEG, or WebP). It supports optional resizing by width and/or height, and allows setting the compression quality for the output image. The agent fetches the source image, processes it using the 'sharp' library, and then uploads the resulting image, returning its URL, format, MIME type, and size.
hbl-image-syskey
This agent generates an image from a given text prompt using AI models, primarily Google's Gemini or Imagen, via a platform bridge. It accepts a text prompt as a mandatory input and optionally allows specifying the AI model (defaulting to 'gemini-2.5-flash-image'), the number of image samples to generate (defaulting to 1), and the desired aspect ratio (defaulting to '1:1'). The agent handles transient errors and rate limits with retries and exponential backoff, and uploads the generated image to a persistent storage service. The output includes a URL to the generated image file and metadata detailing the execution mode, a generic filename, and the specific AI model used for generation.
hbl-incomplete-obj-det
This agent analyzes an image provided via a URL to detect and describe objects that are partially cut off or incomplete. For each identified incomplete object, it returns its name, a unique identifier for the description, a textual explanation of its incompleteness (e.g., 'cut off at left edge'), and the approximate X and Y pixel coordinates of its center. The agent leverages a vision-based AI model for image analysis.
hbl-inspector
This agent orchestrates an end-to-end content generation pipeline, serving as an integration test for a series of AI agents. It takes a `topic` as input and sequentially performs five distinct operations: scientific research using PubMed, creative story writing, web book structuring, cover image generation, and 3D model generation. The agent outputs an overall `status` (PASSED or FAILED), a descriptive `message`, detailed `steps` status and results for each stage of the pipeline, and the `totalTime` taken for execution. It validates the full pipeline by chaining calls to `hbl-researcher-pubmed`, `hbl-writer`, `hbl-web-book-creator`, `hbl-image-syskey`, and `hbl-meshy-generator`.
hbl-json-unpack-adapter
This agent functions as a versatile JSON unpack adapter, designed to process and flatten JSON data. It accepts JSON input from multiple sources: directly as an object or array (`jsonData`, `data`), by fetching from a URL (`jsonUrl`), or by parsing a raw string (`content`). A core capability is to extract specific nested properties from the ingested JSON using dot-separated paths, promoting these values to new, top-level output properties based on user-defined mappings (`extractPaths`). Additionally, it identifies and outputs primary data collections (arrays) from the input JSON. The agent outputs the original processed JSON (`data`), any identified collections (`items`), and all dynamically extracted top-level properties.
hbl-meshy-generator
This agent acts as a secure interface to the Meshy.ai platform, enabling users to initiate asynchronous text-to-3D model generation tasks. It requires a `prompt` (a textual description of the desired 3D model) and supports optional parameters to refine the output, including `artStyle` (e.g., 'realistic', 'cartoon'), `negativePrompt` (elements to exclude), `aiModel` (specific Meshy AI version), `topology` ('quad' or 'triangle'), and `targetPolycount` (desired polygon count). The agent authenticates with Meshy.ai using a `MESHY_AI_KEY` securely managed by the Habilo Platform Bridge. Upon successful submission, including handling HTTP 202 (Accepted) responses for asynchronous job initiation, it returns a `taskId` for tracking the generation process, an initial `status` of 'SUBMITTED', and a descriptive `message`.
hbl-meshy-monitor
The `hbl-meshy-monitor` agent tracks the asynchronous generation of 3D models initiated via Meshy.ai's text-to-3D service. It accepts a `taskId` from a previously started Meshy.ai generation process and continuously polls the Meshy.ai API for the task's status. The polling frequency and maximum waiting time are configurable via `pollIntervalMs` and `maxWaitMs` respectively. Upon successful completion of the Meshy.ai task, the agent securely downloads the generated 3D model files (GLB, FBX, USDZ) and an associated thumbnail image. These artifacts are then persisted to cloud storage using platform-provided Zero-Trust mechanisms. All external HTTP requests, including artifact downloads, are routed through `bridge.request` to ensure secure and efficient handling of binary data. The agent returns the final status of the task, its completion progress, and the cloud storage URLs for the persisted 3D models and thumbnail. If the Meshy.ai task fails, expires, is canceled, or if the monitoring process times out, the ag
OpenSCAD Parametric Script Generator
This agent generates OpenSCAD (.scad) code for 3D CAD models. It accepts a natural language description of the desired model (`prompt`) and optional dimensional parameters (`parameters`) to create new designs. Additionally, it possesses self-healing capabilities: users can provide previous OpenSCAD code (`previous_code`) along with compiler or mesh verification errors (`compiler_errors`) to prompt the agent to debug and correct the code. The agent ensures the generated code uses only built-in OpenSCAD primitives and CSG operations, explicitly disallowing external libraries. Outputs include a URL to the generated .scad file and the raw OpenSCAD code.
hbl-pdf-extractor
The `hbl-pdf-extractor` agent processes PDF documents to extract their textual content and key structural information. It requires a URL pointing to a PDF file, which can be provided through one of three input fields: `pdfUrl`, `fileUrl`, or `documentUrl`. Upon successful execution, the agent returns the full extracted text content of the PDF, the total number of pages, and the file size in bytes. It also attempts to persist the extracted text as a separate artifact, providing a URL to this artifact if successful. The text extraction mechanism involves parsing raw PDF text blocks using regular expressions.
hbl-researcher-pubmed
This agent functions as a PubMed researcher. It accepts a scientific or medical research question, utilizes an AI model to formulate an optimized search query for PubMed, and then executes the search to retrieve relevant articles. After fetching article details (PMID, title, abstract, URL), it employs another AI model to generate a concise summary that answers the original research question, strictly based on the content of the retrieved articles. The agent outputs the generated summary, a list of cited articles including their PubMed IDs, titles, and URLs, and the specific search query that was used.
hbl-simple-logging
The `hbl-simple-logging` agent logs a provided message to standard output (stdout) with a specified severity level. It accepts a `message` (string) and an optional `level` (string, one of 'info', 'warn', or 'error', defaulting to 'info'). If no message is provided, it defaults to 'No message provided'. The agent uses `console.error` for 'error' level, `console.warn` for 'warn' level, and `console.info` for 'info' level. Additionally, it always outputs a JSON string containing the log level, message, and a timestamp to `console.log`. Upon completion, it returns a `success` status (always true) and the `loggedAt` timestamp indicating when the message was processed.
hbl-structured-extractor
This agent transforms unstructured text into a structured JSON format by automatically identifying logical columns and extracting data into a tabular structure. It accepts a single string of unstructured text as input. The output is a JSON object containing an array of identified column headers (`columns`) and an array of data rows (`results`). Each row in `results` is a JSON object where keys correspond to column headers and all values are strings, with null or empty strings used for missing data.
hbl-text-summarizer
This agent summarizes a given text using a large language model. It takes the input text, an optional approximate target word count (defaulting to 50 words), and an optional target language (specified by a BCP47 tag) for the summary. The agent returns the generated summary as a string.
hbl-text-to-speech-generator
This agent converts input text into spoken audio. It intelligently routes requests to either a standard Text-to-Speech (TTS) model or a higher-fidelity, expressive Gemini 2.5 Flash TTS model based on the input language, desired quality tier, or specified voice. Non-English languages, an explicit 'expressive' quality tier request, or the selection of a specific Gemini voice will trigger the higher-fidelity Gemini model. Standard English narration defaults to a budget-friendly standard TTS model. Inputs include the text to be spoken, an optional language code (normalized to BCP-47, defaulting to 'en-US'), an optional quality tier ('standard' or 'expressive'), an optional specific TTS model to use, an optional preferred voice, and an optional gender for the voice ('MALE' or 'FEMALE'). The agent outputs a URL to the generated audio file.
hbl-textgen-creative-sec
Imported agent hbl-textgen-creative-sec from upload.
hbl-textgen-raw
This agent generates text using a Large Language Model (LLM). It requires a `prompt` as input to guide the generation. Optionally, it can be configured with a target `language` for the output and a `maxTokens` limit for the generated text. The agent incorporates robust error handling with exponential backoff and retries for transient LLM service errors (e.g., rate limits, server errors). It outputs the generated text as `content`.
Unified Travel Search (Flights, Hotels & Car Rentals)
This agent provides a unified search capability for travel-related services, including flights, hotels, and car rentals. It can search for a specific travel category ('flights', 'hotels', 'cars') or all categories simultaneously. The agent attempts to retrieve live data by making simulated API calls to external services (e.g., SerpApi, RapidAPI) if a 'SERPAPI_API_KEY' is configured and available. If the API key is not found or in a sandbox environment, it gracefully falls back to providing deterministic mock data. Users specify search criteria such as origin (for flights/cars), destination, departure/check-in date, optional return/check-out date, and cabin/car class. The agent returns a structured array of search results, a summary of the search, a URL to a JSON file containing the full results, and the total count of results found. Results are limited by an optional 'maxResults' parameter.
hbl-url-extractor
This agent extracts all unique HTTP and HTTPS URLs from a given text input. It identifies both fully qualified URLs (e.g., `https://example.com/path`) and domain-only references (e.g., `example.com`), automatically prepending `https://` to domain-only references if a scheme is absent. The agent sanitizes extracted URLs by removing trailing punctuation and ensures the output contains only unique, well-formed URLs.
hbl-url-resolver
URL resolution and redirect following utility
hbl-vision-analyst
This agent performs precise visual analysis of an image, generating structured JSON output based on user-defined instructions. It accepts an image via URL or data URI and requires either a specific `prompt` or detailed `customInstructions` to guide the analysis. The agent combines these instructions to direct a vision AI model, ensuring the output is a valid JSON object (`schema:Report`) that precisely adheres to the requested analysis and format, suitable for automated processing.
hbl-web-book-assembler
The `hbl-web-book-assembler` agent assembles a structured digital 'Web Book' from a title, a list of pages (each with an image and optional audio), and optional title page media. It sorts the provided pages by their sequential number, re-indexes them starting from one, and identifies the cover page. The agent then constructs a comprehensive JSON object representing the Web Book and persists this artifact, returning its access URL along with the structured Web Book object.
hbl-web-book-creator
The `hbl-web-book-creator` agent transforms a given story or prompt into a structured web book. It uses an AI model to segment the narrative into a specified number of pages, generate a title, and create detailed image prompts for both the cover and individual pages. It then orchestrates calls to an external image generation tool (`hbl-image-syskey`) to produce the visual assets. The agent supports generating book titles and text content in a specified language. The final output is a comprehensive JSON object representing the web book, including its title, the original story, a cover image URL, and an ordered list of pages, each containing its narrative text, a generated image URL, and the prompt used for that image.
hbl-web-book-planner
The `hbl-web-book-planner` agent transforms a user-provided story or prompt into a structured plan for a multi-page, illustrated web book. It intelligently divides the narrative into pages, generates a title, a cover image prompt, and a consistent visual `styleContext` (character sheet and artistic style) for the entire book. For each page, it produces specific narrative text content and a corresponding image prompt. The agent supports extensive customization, including the number of pages, language for text and text-to-speech (TTS), desired image style, and TTS voice parameters (gender, voice, tier). It can also infer the narrator's gender from the story for TTS purposes. The primary output is a `newSteps` array, which orchestrates subsequent agents (e.g., for image generation, audio narration, and final web book assembly) to create the complete web book. **Core Capabilities:** - **Story Segmentation & Structuring**: Divides a given story or prompt into a specified or optimally determined number of pages. -
hbl-web-page-creator
Generates interactive single HTML web pages, dashboards, and data tables from tabular CSV/JSON datasets (including GCS paths) or unstructured text (schema:WebPage)
hbl-writer
This agent generates creative text based on a user-provided prompt using a large language model (LLM). It accepts a required 'prompt' string for text generation. Optionally, users can specify a 'language' (BCP47 format) to guide the output language and a 'maxTokens' number to limit the length of the generated text. The agent returns the generated text as a 'content' string.
hbl-zip-extractor
This agent downloads a ZIP archive from a provided URL, extracts all its contents, and persists each individual file as a separate artifact. It then categorizes these extracted files based on their inferred MIME type into distinct lists for images, audio files, and documents, providing the URL for each persisted artifact. The agent also returns a comprehensive list of all successfully extracted files, including their original names, the URL where they are persisted, their inferred MIME type, and their size in bytes. It automatically handles and skips directories and common hidden files (e.g., __MACOSX) within the archive. **Core Capabilities:** - Downloads ZIP archives from a given URL. - Extracts all files from the downloaded ZIP archive. - Persists each extracted file as an independent artifact, providing a unique URL for access. - Infers the MIME type of extracted files based on their file extension. - Categorizes extracted files into specific lists: images, audio files, and documents. - Provides detailed
hblt-apt-openscad
This agent provides command-line access to OpenSCAD, a software for creating solid 3D CAD objects. Its core capability is to process OpenSCAD design files (.scad) and generate various outputs. It can export 3D models (e.g., STL, OFF, AMF, 3MF, CSG), 2D drawings (e.g., DXF, SVG, PDF), and render 2D images (PNG) with extensive control over camera, view, size, and animation. The agent also supports defining variables, using customizer parameter files, generating dependency files, and controlling execution behavior like verbosity and warning handling. **Inputs:** - **toolName**: Must be 'openscad', specifying the tool to execute. - **arguments**: An object containing parameters that map directly to OpenSCAD CLI options: - **positional_args**: An array of strings, typically paths to the input OpenSCAD source code files (.scad). This is a required input. - **o**: Specifies the output file path and format (determined by extension, e.g., .stl, .png). Can be used multiple times. - **export-format**: Overrides t
hblt-imagemagick
ImageMagick image processing suite — system-level dependency agent
hblt-inkscape
The `hblt-inkscape` agent provides a system-level interface to the Inkscape vector graphics editor's command-line functionalities. It enables users to programmatically interact with Inkscape for a wide range of vector graphics processing tasks. The agent supports invoking two primary Inkscape tools: `inkscape` for comprehensive document manipulation, conversion, and querying, and `inkview` for displaying SVG files. **Core Capabilities:** * **Vector Graphics Conversion and Export**: Convert SVG and other vector graphics files into various formats, including raster images (PNG) and other vector formats (PDF, PS, EPS, EMF, WMF, XAML, plain SVG). Users can specify detailed export parameters such as output filename, file type, export area (page, drawing, custom coordinates), resolution (DPI), dimensions, background color, and text rendering options (e.g., converting text to paths, LaTeX export). * **Document Information and Manipulation**: Query properties of objects within a vector graphic file (e.g., boundi
hblt-job-openscad
This agent processes OpenSCAD (.scad) files asynchronously, executing OpenSCAD commands with a comprehensive set of configurable arguments. It takes as input an OpenSCAD file and various parameters to control rendering, export formats (e.g., STL, AMF, 3MF, DXF, SVG, PDF, PNG), camera settings, animation, variable definitions, and output verbosity. The agent outputs the standard output and standard error streams from the OpenSCAD process, along with its exit code, indicating success or failure of the operation.
hblt-openscad-mcp
Manages and renders OpenSCAD 3D solid geometry designs and image previews via Python FastMCP runtime, compiling parametric OpenSCAD scripts into binary STL models.
hblt-ts-tavily
Tavily AI search agent. Capable of executing high-performance web searches, retrieving top search results, extracting webpage content, filtering search queries by domains, and providing rich semantic text summaries of online information.
Technical agent card
Copied from the agent's card. The operator controls these values; agenttru.st has not verified them.
- Provider
- DesignForge — what this agent says about itself; other agents claiming the same provider are not thereby related
- Protocol
- a2a
- Version
- 1.0.0
- Card completeness
-
a2a.proto v1.0 requires eight top-level fields. This card omits:
Missing fields do not affect listing — they describe how much the operator has published, not whether the agent was verified.
View all card details
- Capabilities
- pushNotifications stateTransitionHistory streaming
- Agent card
- https://design-forge--designforge-lsst3.us-central1.hosted.app/.well-known/agent.json
Operate this agent and would rather not be listed? Request removal.