PRODUCT: FOUNDRY

Don't just compile documents. Manipulate them.

The missing last mile for AI. STRUC Foundry is a C++ headless engine that exposes a direct object graph to write, edit, and mutate high-fidelity documents via atomic transactions. Engineered for <50ms latency.

* Benchmark: Native C++ Engine. Zero-serialization overhead. No headless browser.
// Direct Object Graph Injection (JSON-RPC)
const response = await fetch('https://api.struc.so/foundry/mutate', {
  method: 'POST',
  body: JSON.stringify({
    operation: 'InjectBlock',
    target: '#compliance_module',
    payload: {
      type: 'policy_block',
      content: 'Data Retention Policy: 5 Years...',
      attributes: { style: 'iso_standard' }
    }
  })
});

// The engine returns the new revision hash instantly
const { revision_id, render_url } = await response.json();
Latency: Object Mutation & Logic
Python/XML Parsing
2400ms
Cloud APIs
1200ms
STRUC Foundry
42ms

Supported Compliance Environments

> LegalTech Deterministic redlining. Strict version control.
> FinTech High-volume automated reporting. Audit trails.
> Healthcare Tamper-proof, audit-ready patient records.
> GovTech ISO-compliant archival (PDF/A) for long-term storage.
PRODUCT: INDEX

Structure-Aware RAG 🧠

Standard vector databases slice documents blindly, destroying context.
STRUC Index exports Semantic Chunks that respect semantic boundaries for perfect retrieval.

LEGACY TEXT SPLITTING
# Chunk 104 (500 chars)
...shall indemnify the Provider against
any claims arising from use of the

# Chunk 105 (500 chars)
Software. Furthermore, the limit of
liability shall not exceed...

❌ Split mid-sentence. Meaning lost.

STRUC INDEX EXPORT
// Object: 9.1 (Indemnity)
{
  "id": "9.1",
  "type": "indemnity_block",
  "context": "Section 9 > Liability",
  "content": "...claims arising from use of Software..."
}

âś… Atomic Object. Perfect Retrieval.

Universal Agent Interface ✨

Your LLM thinks. Our engine executes. We provide strict tool definitions for any model (OpenAI, Anthropic, Llama).

GATEWAY::LISTENER IDLE

1. Connect Your Model

Point your agent (LangChain, AutoGen, or custom) to our C++ engine. We generate type-safe tool definitions for GPT-4 and Claude 3.5.

2. Receive Tool Calls

Instead of hallucinating XML, your model emits precise RPC payloads. We validate them against the document graph instantly.

3. Atomic Execution

The engine executes the operations in <50ms. No retry loops. No fuzzy matching. Just deterministic state mutation.

Direct Object Access

Stop treating documents like flat files. Interact with a persistent C++ object graph. Inject rows, update variables, and reorder sections via RPCs without overhead.

Strict Schema Enforcement

LLMs hallucinate formatting. We don't. Our C++ engine enforces rigid templates at the object level. The AI suggests changes; the Engine guarantees validity.

Structure-Aware Embeddings

Feed your RAG pipeline with clean, semantic chunks from STRUC Index. Tuned for structured content (reports, contracts). Note: Marketing/creative docs may require manual overrides.

High-Fidelity Roundtripping

Cycle documents from DOCX -> Object -> DOCX. Our engine preserves the full semantic state—comments, track changes, and margins—so you can automate workflows safely.

PDF/A Compliance

Generating valid PDF/A-1b is hard. We do it natively. Our engine ensures strict archiving standards for government and defense contracts, with zero font-embedding errors.

Universal Output Targets

Engineered for Paged Media. Compile Object -> DOCX / PDF from a single source of truth. Ensure your web preview matches the final document pixel-for-pixel.

Request API Keys

We are currently in Private Beta. We are manually onboarding high-volume partners to ensure environment stability.

/ to focus

```