⚡ Zaltech

A full-stack framework for building AI-native, cross-provider applications that run across ChatGPT, OpenAI, Gemini, Claude, and any MCP-compatible platforms. Designed to standardize how you build tools, UI widgets, and integrations on top of the Model Context Protocol (MCP).

Project Status

Zaltech is in active development.

This repository documents the architecture and early design of an AI-native framework extracted from real products built on top of the Model Context Protocol (MCP).

The framework is not yet public while core abstractions and cross-host runtime guarantees are still being finalized.

It will be released publicly once the foundation is stable and reusable, which is currently expected in 2026.

Why Zaltech Exists

Today, building real AI applications means dealing with:

• Fragmented provider SDKs
• Custom MCP servers per project
• One-off UI bridges for every platform
• No standard way to ship interactive AI apps
• Rewriting the same transport, auth, and rendering logic

Zaltech unifies all of that into one consistent, standards-aligned developer surface.

Core Features

Feature	Description
MCP-First Architecture	Native implementation of MCP tools, resources, prompts, and structured output using the official MCP SDK.
Cross-Provider Runtime	Run the same app across multiple hosts; OpenAI is fully supported today, with Gemini, Claude, and others following as MCP support matures.
Native AI UI System	Host-native, responsive UI components and interactive widgets rendered via MCP resources using React, reusable across chat clients, dashboards, and native or hybrid applications.
Feature-Based Architecture	Each capability is a vertical slice (tool + logic + UI), giving clean, domain-driven boundaries and easy reuse.
Streaming-First Transport	Built on HTTP streaming and SSE for low-latency responses, stateless scaling, and JSON output by default.
Authentication Out of the Box	OAuth-ready, token-based auth with secure MCP auth flows and minimal configuration.
Observability Built In	Batteries-included observability stack with structured logs, request tracing, and dashboards pre-wired via OpenTelemetry, Grafana, Loki, and Prometheus so logs, metrics, and traces work out of the box.
MCP Inspector (First-Class)	Visual inspection and testing of tools, prompts, resources, logs, and execution flow using MCP Inspector.
Local Visual UI Testing	Storybook-style sandbox for building and iterating on widgets without live LLM calls.
Agentic Checkout	Built-in support for Agentic Checkout with REST endpoints, webhooks, and delegated payments for end-to-end checkout flows inside ChatGPT.
Delegated Payment	Built-in support for Delegated Payment enabling secure payment token delegation to PSPs and merchants with single-use, constrained tokens for PCI-compliant transactions.
State Management	Built-in patterns for managing business state on server, ephemeral UI state in widgets via window.openai.widgetState, and cross-session state in your backend storage.
One-Command DX & Deploy	One command to run locally and one to deploy—no manual infrastructure orchestration.

Current Capabilities

As of December 2025

Zaltech is designed from day one to support multiple AI providers via MCP, but we want to be fully transparent about what works today:

• Full production support: Only ChatGPT/OpenAI currently offers a mature MCP-based runtime for rich interactive UI widgets.
• MCP tools & backend logic: Fully functional and tested on OpenAI, ready for any MCP-compatible host.
• Rich interactive UI widgets: Available exclusively on OpenAI/ChatGPT today (using React + OpenAI Apps UI SDK).
• Payments (Agentic Checkout / Delegated Payment): OpenAI-only for now.
• All other features (auth, streaming, observability, state management, local testing): Production-ready on OpenAI.

Support for Gemini, Claude, Grok, and others will activate as soon as they ship equivalent UI runtimes. We’re not waiting — the abstractions are built — but rich UI depends on the hosts catching up.

Architecture

Zaltech is feature-first across the entire stack, with each feature implemented as a complete vertical slice spanning three layers.

Three-Layer Feature Architecture

Each feature is organized as a self-contained vertical slice:

feature_name/
├── mcp/src/features/{feature}/      # MCP Layer
│   ├── tool.py                      # MCP tool definition & handler
│   ├── resource.py                  # Widget resource definitions
│   └── models.py                    # Pydantic data models
│
├── app/src/features/{feature}/      # App Layer
│   ├── generator.py                 # Core business logic
│   └── extractor.py                 # Trigger/keyword extraction
│
└── ui/src/features/{feature}/       # UI Layer
    └── React component              # Embedded widget for AI hosts

Layer Responsibilities

MCP Layer (mcp/src/features/)

• Defines MCP tools, schemas, and UI resources
• Handles tool registration and routing
• Manages authentication and authorization per tool
• Exposes widget resources via MCP resource endpoints

App Layer (app/src/features/)

• Implements business logic and domain rules
• Handles provider routing and AI API calls
• Processes data extraction and transformation
• Manages state and orchestration

UI Layer (ui/src/features/)

• React components rendered as embedded widgets
• Interactive UI for AI host platforms
• State management via widget state APIs
• Responsive layouts using Apps SDK UI primitives

Tech Stack

Zaltech is an opinionated full-stack framework with a Python backend and TypeScript frontend, providing a modern, type-safe developer experience and leveraging industry-standard tools to deliver a production-ready foundation.

Core Framework

• FastAPI – High-performance Python web framework
• Pydantic – Data validation & settings management

Frontend & UI

• React + TypeScript – Modern, type-safe UI layer
• Tailwind CSS – Utility-first styling
• Vite – Blazing-fast build tool & dev server
• OpenAI Apps UI SDK – Official ChatGPT-native components (For OpenAI Apps)

Developer Experience

• Storybook – Isolated UI sandbox (no LLM calls required)
• Vitest – Fast unit & integration testing for React components
• Pytest – Python testing framework with fixtures & plugins
• MCP Inspector – Visual debugging for tools, prompts, resources & logs

Observability

• OpenTelemetry – Traces, metrics & logs instrumentation
• Prometheus + Grafana – Metrics & dashboards
• Loki + Promtail – Log aggregation & querying

Infrastructure & Deployment

• Docker – Containerized services
• Docker Compose – One-command local & production-ready stack

Protocol Layer

• MCP Python SDK – Official Model Context Protocol implementation

For ChatGPT App Developers

If you're building ChatGPT Native Apps today, you typically start by wiring together the OpenAI Apps SDK and OpenAI Apps UI SDK, then you still have to figure out project structure, streaming, state, auth, payments, deployment, tooling, and much more.

Zaltech is an easy starter framework built directly on top of both SDKs and more, delivered pre-wired with structure, observability, visual UI sandbox, and much more, so you can ship immediately instead of assembling infrastructure.

AI Providers Support

Rank	AI Provider	MCP Tool Support	Interactive UI Support	Zaltech Current Support	Expected Future
1	ChatGPT (OpenAI)	✅ Ready	✅ Ready	Full (tools + UI)	Already shipping production apps
2	Google Gemini	✅ Ready	⏳ Pending	Tools only	UI runtime anticipated in 2026 updates
3	Anthropic Claude	✅ Ready	⏳ Pending	Tools only	UI enhancements likely as MCP evolves
4	Mistral AI	✅ Ready	⏳ Pending	Tools only	Rich UI pending provider adoption
5	Grok (xAI)	✅ Ready	⏳ Pending	Tools only	UI surface expected with platform growth
6	Perplexity AI	✅ Ready	⏳ Pending	Tools only	Future agentic UI support probable
7	Meta LLaMA	🟡 Partial	⏳ Pending	Community/Indirect tools	Depends on third-party hosts/runners
8	Other Hosts	🟡 Varies	🟡 Host-dependent	Tools where MCP is implemented	UI support varies by host implementation

How It Came to Be

Zaltech started as internal infrastructure for building multiple AI-native products using the OpenAI Apps SDK and MCP from the earliest preview releases, with the expectation from day zero that the foundation would need to support more than one product.

Because there was no established app framework, the first product was built in an intentionally extractable way, anticipating the same problems would need to be solved again: tool structure, streaming, state management, UI rendering, auth, deployment, and observability.

As additional products were built on top of the same core, those shared patterns were validated, refined, and progressively hardened into a single reusable foundation. That foundation became Zaltech.

Vision

Make building AI-native applications as standard as building web apps.

Community

Join us on Discord to stay updated.

License

Distributed under the MIT License. See LICENSE for more information.

Credits

Created by Mahmoud Zalt, supported by Sista AI.