mrkeyoor.comAsk

thesysdev/open-intelligent-uitested 14 Nov 2026commit 8ecdd17

open-intelligent-ui review

Explore thesysdev/open-intelligent-ui as a starting point for interactive answers in React.

  • Safety failed
  • Install 32 s
344/344tests passed
  • Build 45 s
  • 663 packages
AI Toolsevaluationupdated 14 Nov 2026
+31stars / 7d

Thesys's Open Intelligent UI is an OpenUI-based demo application that turns model responses into interfaces with maps, charts, forms and editable controls. Developers can adapt its component library and application code. CopilotKit/OpenIntelligentUI is a separate project.

Verdict

Explore thesysdev/open-intelligent-ui as a starting point for interactive answers in React. Our source harness built commit 8ecdd17 and passed all 344 tests; the separate Compose deployment attempt stopped at its safety check. Choose the provider route early: gateway output receives correction, while direct and local output render as written. Do not adopt it for requirements that depend on an included Compose deployment package, gateway correction during direct or local inference, or documented walking and transit directions.

Infographic on how open-intelligent-ui works, its uses, our test result, common pitfalls and who should use it
Tested 14 November 2026: 344 of 344 source tests passed. Before that: source install 32 s, build 45 s.

We ran it

Lab card: what happened when we ran open-intelligent-ui
Lab card from our sandbox run
Screenshot of open-intelligent-ui (www.openui.com/demo/intelligent-ui)
www.openui.com/demo/intelligent-ui
Install✓ · 32s663 packages · 730 MB
Build✓ · 45s
Tests✓ · 4s344 passed · 0 failed of 344 (vitest)
Known vulns111 critical · 4 high · 2 moderate · 4 low (npm audit)
Repo114 files~10,452 lines of source · 18.6 MB · 0 CI workflows

Answers from our run

Does open-intelligent-ui build from source?

Dependencies installed in 32 seconds (663 packages), and the build succeeded in 45 seconds. We cloned commit 8ecdd17 into a clean Debian container with 3 CPUs and no project-specific setup.

Do open-intelligent-ui's tests pass?

Yes. The project's own test command finished in 4 seconds and reported 344 passed, 0 failed (vitest).

Does open-intelligent-ui have known vulnerabilities in its dependencies?

npm audit flagged 11 known advisories in the dependency tree, including 1 critical at the time of our run.

Who should not use open-intelligent-ui?

Teams requiring an included Compose deployment package: our deployment harness found no Compose file.

What are the alternatives to open-intelligent-ui?

CopilotKit Open Intelligent UI, ChatGPT Intelligent UI. Explore thesysdev/open-intelligent-ui as a starting point for interactive answers in React.

Setup3/5Our source checkout installed in 32 s and built in 45 s, a heavy install of 663 dependencies, and we did not run a README task.Editor’s note: Installation and build passed, but the separate deployment attempt stopped before startup; running-application setup ease was not assessed.
Docs4/5The README has an install section (“Setup”) and a usage section (“Demo video”); we did not run its quickstart ourselves.Editor’s note: Coverage rubric: 1 no usable route; 2 basic setup; 3 setup and configuration choices; 4 those plus behavior distinctions and troubleshooting; 5 independently reproduced coverage of all routes. The supplied current README meets level 4 through its provider routes, correction distinction, local-context warning and component checks.
Community3/5Last push on 2026-11-13 and 998 stars.Editor’s note: The supplied issue and activity extracts do not establish support responsiveness or outcomes for adopters.
Maturity1/5No tagged GitHub release, repository created 2026-10-08 and its test suite passed in our sandbox (344 of 344 passed).Editor’s note: Passing repository checks do not supply production workload results or evidence of long-term operational reliability.

How we score

Who it’s for

React developers exploring answers with controls and computed results.
Product teams choosing between gateway correction and direct or local model output.
Designers inspecting the documented gallery of hand-written interface programs.

Who it’s NOT for

Teams requiring an included Compose deployment package: our deployment harness found no Compose file.
Teams requiring gateway output correction with direct or local inference: those routes render output as written.
Travel applications requiring walking or transit directions: the documented map uses a driving-profile overview.

Setup reality

Our November 14, 2026 source-harness run at commit 8ecdd17 installed dependencies in 32 seconds, built in 45 seconds and passed 344 of 344 Vitest tests in 4 seconds. We measured 663 dependencies and 730 MB on disk. npm audit reported 11 known vulnerabilities: 1 critical, 4 high, 2 moderate and 4 low.

The supplied current README requires Node 24 and documents gateway, direct OpenAI-compatible API and local Ollama routes. Direct and local output omit gateway correction. The development gallery renders hand-written programs without an API key.

The recorded sandbox configuration was 3 CPUs, 8 GB RAM and image label lab-node:22. The separate Compose-based attempt failed its safety check because no Compose file existed; teardown reported success.

Short answer: choose the provider route before adapting the application

Thesys's open-intelligent-ui passed all 344 tests in our source harness, and its documented direct-model route renders output without gateway correction. It is a starting point for React developers who want answers containing controls, maps and computed results. Provider selection changes how generated interface descriptions reach the renderer, so that choice affects the behavior an adapted application must handle. Start with the route you intend to operate, then inspect its configuration and generated output. Thesys application documentation.

This review concerns thesysdev/open-intelligent-ui, the OpenUI-based demo. CopilotKit/OpenIntelligentUI is a separate project built with CopilotKit and AG-UI. The distinction matters when following installation instructions: CopilotKit documents a Next.js frontend and Python agent, while Thesys documents the npm application and provider settings discussed here. Read the repository owner alongside the project name before copying commands or assembling a dependency list. CopilotKit project description; Thesys setup.

What people use open-intelligent-ui for

Hadil Ben Abdallah reports trying travel itineraries, frontend-framework comparisons and an interactive weekend-trip planner with the Thesys demo. Her supplied article includes three prompts, screenshot captions and descriptions of using generated controls. She chose a free Gemini gateway model to explore the application without adding a separate paid model API key. These examples suggest concrete starting tasks: information that benefits from a map, a comparison table or adjustable inputs. Hadil's demo experiment.

Who used it What they did Reported outcome
The DEV article author Tried travel planning, a React/Vue/Svelte comparison and a weekend-trip planning form Reports clicking buttons, checking boxes, changing dropdown selections and exploring the map. DEV experiment
Jeremy, DemonRoute's operator Connected an OpenAI-compatible endpoint through the existing configuration Says the endpoint runs in that slot and requests documentation inclusion. Provider request #53
KashyapVisharad Launched a demonstration inspired by ChatGPT's Intelligent UI Describes an OpenUI-based experience for developers' own applications using hosted or local models. Thesys launch record

The README describes inputs bound to variables and dependent statements that update when users interact. That mechanism lets an answer contain both editable inputs and a calculated result. Designers can inspect the development gallery before choosing a generation provider: its hand-written programs cover the components, worked examples and dashboards. The gallery also provides light and dark views for examining styling independently of a model response. State and gallery documentation.

What happened when we ran it

Our November 14, 2026 source-harness run installed, built and passed 344 tests at commit 8ecdd17. The separate deployment attempt failed its safety step because none of the required Compose filenames existed. Its introductory record describes a deployment using the repository's own Compose file, but the recorded step reports failure. The failed step determines the deployment finding.

The safety check searched for compose.yaml, compose.yml, docker-compose.yaml and docker-compose.yml. Its rule required a Compose file, so that attempt stopped at the check; teardown reported success. The npm installation, build and tests belong to the separate source harness. These are different outcomes from different procedures: one completed repository checks, while the other stopped before application startup.

Source-harness observation Recorded result What to take from it
npm install Succeeded in 32 seconds The dependency-install step completed.
Dependency footprint 663 dependencies, 730 MB on disk Allow storage for the installed dependencies.
Build Succeeded in 45 seconds The build command completed.
Vitest 344 passed, 0 failed of 344, in 4 seconds The recorded test suite passed.
npm audit 11 known vulnerabilities: 1 critical, 4 high, 2 moderate, 4 low Review the dependency advisories before deployment.
Repository scan 114 files, about 10,452 source lines, 18.6 MB checked out These figures describe the measured checkout.
Delivery signals 0 CI workflow files, no Dockerfile, no tests directory These are structural scan results; Vitest still ran successfully.

We measured these results in a recorded sandbox configuration of 3 CPUs, 8 GB RAM and image label lab-node:22. The source harness recorded 89 seconds overall. The 730 MB dependency footprint provides a practical storage figure for a local evaluation. For subsequent component changes, the README documents checks that parse gallery programs and prompt examples, followed by type checking and a build. Documented repository checks.

Where people get stuck: provider routes change output handling

The README says gateway generation receives validation and correction, while direct Chat Completions and Ollama output render as written. Switching providers therefore changes output handling as well as credentials. The direct route builds the OpenUI 1.0 system prompt on the application server and relays the response to the browser. Use that documented distinction when deciding which generated-output behavior your application should handle. Provider-route documentation.

Symptom or decision Evidence Practical response
The deployment harness refuses to start Our safety step required a Compose file and found none Use the documented npm development route for an initial evaluation.
Direct or local output contains malformed interface descriptions The README says these routes render output as written Compare the saved output with the component library and parser results.
A local model cuts off instructions The README warns that Ollama's default context window truncates the application prompt Use the documented larger-context configuration.
DemonRoute is described as a tested choice Its operator requests that wording in issue #53 Describe compatibility as the operator's report.
A copied setup guide asks for CopilotKit services CopilotKit/OpenIntelligentUI has its own architecture Follow the Thesys repository's setup instructions.

The current README describes an approximately 8,000-token application prompt and an Ollama default context window of 4,096 tokens. It recommends 32,768 tokens to prevent truncation. Its default local model is qwen3.8:27b, described as about 18 GB and best with 32 GB of memory or more. Local setup therefore includes both selecting a model and configuring enough context for the application's prompt. Local-model setup guidance.

Maps and photographs have their own data paths

The documented map obtains street geometry through the application's /api/street-route endpoint and the public OSRM demo server's driving profile. When routing is unavailable, it draws a labelled direct connection. Those labels explain what the displayed line represents. For a travel-planning adaptation, preserve that distinction alongside ordered stops, photographs and editable itinerary controls. Map implementation description.

Photographs also use application endpoints. SearchImage requests a Wikipedia article's lead photo, then searches Wikipedia and Wikimedia Commons for matching titles. Image uses the same lookup when its supplied URL fails. Selecting local inference changes the model route while these photo and street-route paths remain part of the documented application. Include those services alongside the chat endpoint when mapping the application's network dependencies. Photo and route documentation.

Security starts with credentials and saved conversations

The README says the gateway key is used only on the server, while threads, messages and interaction state persist in browser localStorage. Conversation content therefore survives reloads and thread switching. For an application used through shared browser profiles, decide how saved conversations should behave before introducing confidential material. Credential configuration and conversation persistence are separate parts of that decision. Credential configuration and conversation storage.

Our npm audit summary reported 11 known vulnerabilities, including 1 critical and 4 high. Review the dependency advisories as part of adapting the code. Service data handling also needs a deliberate choice: Hadil reports that requests to free gateway models may be used for training, while DemonRoute's operator says prompts are never stored. Those statements describe different services and come from different speakers. DEV author's privacy account; DemonRoute operator's statement.

Count useful interactions when evaluating a provider

Check a generated calculator against known arithmetic, change an input, and check the updated result. This is a proposed acceptance task based on the README's variable-bound inputs and dependent calculations. Save the prompt, generated program, expected calculation and displayed result together. That gives an evaluation a concrete outcome beyond whether the endpoint accepted a request or produced an interface. State and provider documentation.

The README documents a benchmark script that saves answers, checks them with the OpenUI 1.0 parser and flags unknown functions or components. It also describes screenshots through the development preview page. These checks can organize an evaluation of generated programs: a calculator needs expected arithmetic, while a planner needs an explicit account of which controls should change which values. Benchmark script documentation.

The current target provides an MIT license

The supplied target LICENSE names the MIT License and copyright holder Thesys Inc. Its permission text covers use, modification and distribution subject to its conditions. It requires the copyright and permission notice in copies or substantial portions of the software. That target-specific text supplies the licensing basis for this repository, independently of license declarations for OpenUI or the separate CopilotKit application. Target MIT license.

Bill's issue #44 asked to redistribute the components and an Open WebUI tool inside an Apache-2.0 local voice assistant. The fresh issue extract records closure as completed in #45 on October 17, 2026. The request names thesysdev/openwebui-plugin as well as this repository. A redistribution inventory should list the actual software and assets being bundled, with the applicable notices for each. License request and closure activity.

Open-intelligent-ui vs alternatives

Thesys documents an OpenUI-based application; CopilotKit's separate project describes an application built with CopilotKit and AG-UI. That is an architecture choice before it is a model-provider comparison. The Thesys README describes recreating ChatGPT's interactive-answer experience with components developers can modify and ship in their own applications. The alternatives below distinguish adopting an application from selecting an inference route within Thesys. Thesys README; CopilotKit project description.

Choice Why someone would choose it Supplied evidence
ChatGPT Intelligent UI Use the hosted experience described by Thesys The README describes recreating its interactive answers. Thesys project description
CopilotKit/OpenIntelligentUI Adopt its CopilotKit and AG-UI architecture Its repository identifies that architecture. CopilotKit source
Ollama instead of the gateway Run model inference on a local machine Thesys documents local inference with output rendered as written. Local route documentation
A free Gemini gateway model Explore the demo without adding a separate paid model key Hadil gives this reason for her selection. DEV experiment
DemonRoute instead of the gateway Evaluate the endpoint promoted by its operator Jeremy reports compatibility through the direct API configuration. Provider request #53

How similarly named projects differ

The supplied Solidaitech article identifies its subject as CopilotKit's Open Intelligent UI. Its setup discussion belongs to that project. Thesys documents gateway, direct API and Ollama routes in its own README. The practical reading rule is simple: use the owner and repository URL to select instructions, rather than treating every article containing the same project name as documentation for one application. Solidaitech project description; Thesys configuration.

The supplied Medium rebuild describes an LLM cost workbench and a support SLA console, while Aditya-thesys/OpenIntelligentUI describes a compiler implementation. These are separate examples. For Thesys itself, the full supplied DEV extract includes the author's three prompts and interaction reports. Its description of gateway-hosted image search differs from the current target README, which documents application-resolved photographs. Follow the target documentation when tracing the current photo path. Medium rebuild; compiler project; DEV experiment.

FAQ

Thesys documents gateway, direct-provider and local-model configuration, and the supplied current target license is MIT. The following questions come from the supplied issue requests and research questions. They cover redistribution, endpoint selection and using generated controls, rather than troubleshooting a ChatGPT account. The answers use the target README, target license and attributed accounts from the research pack. Thesys configuration; target license.

Could you add a license to thesysdev/open-intelligent-ui?

The supplied current target LICENSE is MIT, and the fresh issue #44 extract records closure as completed in #45 on October 17, 2026. Bill's original question describes the repository at the time of his request. For redistribution decisions, read the current permission and notice conditions rather than relying on the historical report that a license was missing. Current target license; issue #44.

Can I redistribute its components and Open WebUI tool in an Apache-2.0 local voice assistant?

The target's MIT license permits distribution subject to its conditions, including preservation of the copyright and permission notice. Bill's proposed bundle also includes an Open WebUI tool from another repository. List the repositories, dependencies and assets in the actual bundle and collect their respective license texts before deciding which notices the distribution needs. Target license conditions; Bill's request.

Can DemonRoute be documented as a tested OpenAI-compatible endpoint?

Jeremy, DemonRoute's operator, requests that description in issue #53 and says the endpoint works through the existing direct API configuration. That supports describing it as an operator-reported integration. For an endpoint evaluation, the target README supplies the relevant configuration variables and direct-route behavior: the application builds the prompt on its server and renders the model's output as written. Jeremy's request; direct-route documentation.

Do the generated answers support useful interactions after the initial response?

The README describes variable-bound inputs and dependent statements that update as users interact. Hadil reports clicking buttons, checking boxes, changing dropdown selections and exploring the travel-planning map. Together, these provide a documented mechanism and an attributed account of using it. A calculator with known inputs and expected results offers a concrete next task for assessing the behavior needed in your application. State documentation; Hadil's interaction account.

Does Open Intelligent UI require an OpenAI API key?

Thesys documents a gateway key, direct-provider credentials or Ollama without an API key. Select the route first, then follow its environment-variable instructions. For inspecting components and styling, the development gallery supplies another entry point: it renders hand-written programs without a generation key and includes light and dark views. Provider and gallery configuration.

Is Open Intelligent UI free to use?

The supplied target code has an MIT license; inference and hosting are separate choices. Hadil says she selected a free Gemini gateway model to avoid adding a separate paid model API key. Her account distinguishes gateway calls from model-token charges. Use the terms for the selected model, service and hosting arrangement when estimating the cost of an adapted application. Target license; DEV model-selection account.

What we have not tested yet

Our evidence contains successful source checks at 8ecdd17 and a deployment attempt that stopped at its Compose safety check. It contains no running-target browser task transcript, accessibility assessment, mobile check or lab screenshot records. Hadil's article supplies prompt descriptions, screenshot captions and reported interactions; its images were not independently inspected here. Her account supplies no controlled correctness or performance measurements. The calculator acceptance task above is advice, not an executed test.

Provider parity, gateway correction against direct output on identical prompts, local-model memory use, token consumption, first-response latency, concurrent users and cost per successful interaction remain outside our measured results. The launch's cheaper and faster language is promotional. Current free-model allowances, training and retention terms need first-party evidence for the selected service. DemonRoute's compatibility and privacy statements are its operator's assertions; the supplied evidence contains no independent endpoint result or maintainer certification.

The vulnerability summary supplies severity counts without package names or production reachability. Authentication, route permissions, generated HTML isolation, network access and browser persistence have not received a security audit here. Local inference and a sandboxed iframe alone do not establish application privacy or security. Actual runtime versions require raw toolchain logs: lab-node:22 is an image label, while Node 24 is the current README requirement. The current documentation and license extracts also do not establish which details were present at measured commit 8ecdd17.

Community responsiveness, production reliability and running-application setup ease are unassessed. Documentation receives 4/5 on the retained coverage rubric: 1 means no usable setup route; 2 a basic route; 3 setup plus configuration choices; 4 those choices plus behavior distinctions and troubleshooting; 5 independently reproduced coverage of every documented route. The supplied README meets level 4 through its provider distinctions, context warning and component guidance. The separate Open WebUI plugin and redistributed dependency or asset licenses need their own assessment.

Alternatives

ProjectWhat it isPick it when
CopilotKit Open Intelligent UI gh↗A separate interactive-answer application built with CopilotKit and AG-UI.Choose it when you intend to adopt the separately documented CopilotKit and AG-UI architecture.
ChatGPT Intelligent UIThe hosted interactive-answer experience that the Thesys README describes recreating.Choose it when you want to use the hosted experience instead of adapting and operating this application's code.

Sources

  1. Thesys Open Intelligent UI README
  2. Target MIT license
  3. DEV demo experiment
  4. License request #44
  5. Provider request #53
  6. CopilotKit separate project
  7. Thesys launch record

More ai tools reviews