_Artifex

Idea → reference → real-world scale (almost).

Comment

Inspiration

Enterprise innovation teams live in slides and strategy PDFs while stakeholders still ask “what does it actually look like?” Artifex is built for that gap: turn a hypothetical product idea (with company and supporting documents) into something people can see in the browser and optionally experience in 3D/XR, so innovation managers can move from narrative to a tangible artifact their product org can react to.

What it does

Artifex runs an end-to-end pipeline from idea to prototype:

Context in — Users provide a company, the product idea, and documents (uploads). Optional Composio hooks pull additional context from tools like Google Drive and Notion into the same “context documents” flow.

Brand-grounded research — With Tavily (and optional Backboard for synthesis / search), the system gathers web-grounded brand and product signals, then produces a research digest (and sources) tuned for downstream concept imagery, not generic marketing fluff. Human-in-the-loop before pixels — Users can review and edit the research digest (and related brief fields) so enterprise facts and tone stay accurate and on-brand before any expensive generation.

Concept “sketches” — The system generates reference concept images (canonical front view plus a three-quarter view derived from the front so geometry stays consistent), using the idea, company, documents, and research.

Stakeholder-ready 3D — After concept confirmation, Artifex runs Meshy image-to-3D and exports formats such as GLB (plus STL/OBJ/etc. as configured). The web app uses model-viewer for an interactive spin-and-inspect experience. A Unity Quest viewer path in the repo supports XR / hand interaction for “see and touch” demos. Outputs are organized per job (spec.json, previews, meshes) with a clear API for async jobs, regeneration, and cancellation—closer to how real innovation workflows behave than a single-shot toy demo.

Summarizes the manufacturing brief endpoint, cost bands / BOM-style output, software vs physical focus, and Composio (Drive, Notion) as platform integration. Nothing in the repo referenced “Pingfram,” so that heading uses platform integration; if that was a specific product name, say what it should be called and we can align the wording.

How I built it

Backend: Django orchestrates jobs, storage (local or S3), optional Redis/RQ workers, and external APIs (OpenAI for images/chat as configured, Tavily, Meshy, Backboard, Composio).

Frontend: Next.js / React drives the job lifecycle, research review, concept review, format selection, and 3D preview via model-viewer.

Pipeline design: Deliberate pause points (awaiting_concept_confirmation, research → image prompt preview) so enterprise users stay in control—critical when strategy docs and brand risk matter.

Optional XR: Unity + Meta XR tooling (quest-viewer) for loading and interacting with prototypes beyond the flat screen.

Composio: Composio is how Artifex turns “we already live in Drive and Notion” from a wish into first-class context ingestion without building bespoke OAuth clients for every enterprise system. The backend exposes connect / disconnect, toolkit discovery with connection status, fetch (which pulls remote content and returns markdown sections merged into the same context documents the rest of the pipeline already consumes), and Google Drive browse so the UI can search and pick files instead of pasting links blindly. Under the hood it uses Composio’s connected accounts, auth config resolution, and tool execution (with explicit handling around version pinning and common failure modes like Drive 403 when scopes or sharing are wrong). The significance for this project is structural: Composio is the integration bus that lets an innovation manager attach live corporate knowledge (not just what they remember to paste) to an idea-to-3D workflow, which is exactly the Aucctus narrative enterprise truth in, tangible prototype out, without Artifex owning every connector forever.

Cloudinary: Cloudinary is used as an optional delivery CDN for raster artifacts only: after writes land on the primary store (local or S3), preview.png and concept reference PNGs can be uploaded so the job JSON carries secure_url links that browsers fetch from Cloudinary’s edge instead of hammering your Django host for large images. The frontend then applies URL-API transforms (q_auto, f_auto, bounded dimensions) via helpers like cloudinaryThumb / cloudinaryOptimized so grids, portfolios, and lightboxes stay fast and bandwidth-aware while meshes and structured files still follow the main storage backend. That split is important because 3D files (GLB, STEP, etc.) are not offloaded to Cloudinary in this design, you get CDN polish where it helps UX most (image review and stakeholder browsing) without complicating binary artifact governance. For a demo-heavy hackathon product, that directly improves perceived speed, reliability, and scale of the concept-review experience, which is the human gate right before expensive Meshy 3D generation.

Backboard: In Artifex, Backboard is an optional “assistant layer” that plugs into the same stages where you would otherwise rely only on a general-purpose chat model plus raw snippets. For brand research, it can synthesize structured JSON (digest, sources, brief fields) from the user’s idea and context, optionally combining Backboard’s own web search with or instead of Tavily, and it can upload the user’s long-form documents as indexed thread documents so synthesis is grounded in RAG over those files rather than a single stuffed prompt. That matters for enterprise innovation managers because strategy PDFs and annual reports are long, sensitive, and easy to mis-paraphrase; thread-scoped documents plus controlled web search push the system toward traceable, document-faithful research before any pixels are spent.

Pingram: Pingram is Artifex’s optional outbound-email channel for the “after production” step: from the manufacturing tab, once a run is completed, an authenticated user can email a supplier through Pingram while the API key stays on the Django server—the browser never sees secrets. The backend posts to Pingram’s /send with a configurable notification type, email forced as the channel, validated subject and body, and a stable hashed recipient id derived from the job and address; HTML is built server-side (escaped user text plus a small Artifex footer with run id, product name from spec, and workspace company) so the message is both branded and traceable. Region-aware base URLs (US default, EU/Canada overrides) and a simple readiness check keep ops predictable; completed-job-only access avoids half-baked outreach mid-pipeline. For the Aucctus story—enterprise truth in, tangible prototype out—Pingram is the thin bridge from reviewed concept and production plan to real supplier conversation, without Artifex becoming an SMTP product or storing long-lived mail credentials beside your own app auth.

Challenges I ran into

Reliability across vendors — Image APIs, Meshy polling, and timeouts behave differently in the wild; the stack uses retries, clear error codes, and regenerate paths so a demo does not die on one flaky hop.

Brand truth vs. model creativity — Generative models will “invent” unless constrained. Combining uploaded documents, optional live search, an editable digest, and image-conditioned three-quarter views helps keep outputs plausible and consistent.

Enterprise context plumbing — OAuth and fetch flows (Composio), permission errors on Drive, and callback URL configuration are real integration work—not just a pretty UI.

Accomplishments that I am proud of

A credible enterprise-shaped loop: documents + company + optional live research → editable research → concept references → confirmed → exportable 3D with multiple formats.

Object-first thinking: the pipeline is built around artifacts (PNGs, GLB, spec.json) and job APIs a product team could actually wire into workflows.

Honest human gates where they matter most (research and concept), without giving up automation everywhere else.

Optional XR so “touch” can mean more than a mouse orbit—aligned with the track’s stakeholder story.

What I learned

For Fortune 500–style use cases, the interface is compliance: users need to see sources, edit the brief, and confirm before 3D spend.

Consistency beats single hero renders—tying the three-quarter view to the front reference materially reduces “two different products” failure modes.

Hackathon demos win on recovery: regeneration, cancel, and clear statuses matter as much as the happy path.

What's next for Artifex

Deeper structured product spec from the idea (beyond persistence placeholders) so downstream CAD / packaging / CMF teams get richer handoff data.

Tighter enterprise connectors (SharePoint, Slack summaries to stakeholders) and role-based sharing of job outputs.

Iteration loops: side-by-side concept variants, A/B for stakeholder votes, and lightweight annotation on references before 3D.

XR polish: one-click Quest packaging of the latest GLB for exec walkthroughs.

Built With

Share this project:

Updates