# Giselle: an open source AI app builder for agentic workflows

> Giselle is a TypeScript monorepo that ships a visual agent builder, a knowledge store and GitHub automation behind a Next.js app. It installs with pnpm and needs at least one provider API key, but the documentation is thin on production deployment.

**giselles-ai/giselle** — Giselle: AI App Builder. Open Source.

- Repository: https://github.com/giselles-ai/giselle
- Website: https://giselles.ai
- Stars: 555 · Forks: 124
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/giselles-ai-giselle

## The problem Giselle targets: chaining models without writing glue code

Most teams that want an AI agent end up writing the same scaffolding twice: once to call a model, once to wire that call into a trigger, a retrieval step and a downstream action. Giselle's answer is a studio where those pieces are assembled visually and then executed. The README describes it as "an open source AI for agentic workflows, enabling seamless human-AI collaboration" and lists four use cases: a research assistant that gathers information from the web and internal docs, a code reviewer that integrates with a GitHub workflow, a document generator that produces PRDs, specs and release notes from a codebase, and a workflow automator that chains multiple models.

The audience is mixed by design. The Vibe Coding Guide is written for both developers and non-engineers, and says it covers setting up a Node.js environment, understanding the project structure, running the playground and connecting to LLM providers. That is an unusual positioning: a repository that is a pnpm workspace with Turborepo, Biome and Changesets, but whose entry documentation assumes you may never open a terminal beyond the quick start. Whether that holds up depends on how far you go past the first agent.

## How Giselle is put together: a Turborepo workspace with a Next.js studio

The repository is a pnpm workspace. The root package.json is named giselle-project, marked private, and pins packageManager to pnpm@10.16.0. Task running goes through Turborepo: build, check-types, test and clean are all turbo subcommands, and there is a separate build-sdk script filtered to @giselles-ai/* packages plus a build-data-type script filtered to @giselles-ai/protocol. That protocol package name is the clearest signal in the layout that the agent definitions are a typed data structure shared between the editor and the runtime, rather than something stored only as UI state.

The top level separates apps/, packages/ and internal-packages/, with config/, scripts/ and tools/ alongside. The dev script for the hosted studio is scoped: dev:studio.giselles.ai runs turbo dev filtered to studio.giselles.ai, which implies the cloud product and the self-hosted app are built from the same workspace rather than a fork. Tooling choices are opinionated: Biome for formatting and linting, Knip for unused-code detection (pnpm tidy), Changesets for versioning, and a set of color-specific scripts (report:colors, guard:colors, lint:colors:code) that suggest a design-token system enforced in CI.

The feature list in the README names six areas: GitHub AI Operations, a Visual Agent Builder, Multi-Model Composition across GPT, Claude and Gemini, a Knowledge Store with GitHub vector store integration, Team Collaboration and a Template Hub. The last two are explicitly marked "In Development". Treat that marking as the honest part of the README.

## Installing Giselle locally and building a first agent

The README gives a quick start it claims takes under two minutes. Clone the repository, install with pnpm, create an environment file and add at least one provider key:

```bash
git clone https://github.com/giselles-ai/giselle.git
cd giselle
pnpm install
touch .env.local
echo 'OPENAI_API_KEY="your_openai_api_key_here"' >> .env.local
pnpm turbo dev
```

The environment file is .env.local at the repository root, and the README notes that at least one AI provider API key is required, with OpenAI, Anthropic and Google AI listed as supported providers. The exact variable names for the Anthropic and Google keys are not given in the README, so check the source before assuming a naming pattern. After pnpm turbo dev, the README says to open http://localhost:3000.

What you should see is the studio: a canvas where agents are created by drag and drop, per the Visual Agent Builder feature. The README does not walk through connecting a knowledge store or a GitHub integration step by step; for that it points at CONTRIBUTING.md under "Development environment setup" and at the Vibe Coding Guide in docs/vibe/01-introduction.md, which it says explains the project structure and how to connect to LLM providers. Those two files are the real onboarding path, not the quick start block.

For the hosted route, the README states that giselles.ai runs the same features as the self-hosted version and includes 30 minutes of free Agent time per month on the free plan. That is the fastest way to decide whether the model is worth self-hosting.

## Where Giselle is the wrong tool

The README does not document rollback, backup, migration between versions, or production deployment for the self-hosted build. The self-hosting section is a single sentence pointing to CONTRIBUTING.md. If your requirement is a documented operational story, this repository does not currently provide one, and the roadmap section says the public roadmap is still being created. You are reading a project that is honest about being in flux.

Two of the six advertised features, Team Collaboration and Template Hub, are marked "In Development". Building a workflow that depends on shared agent configuration or on community templates means depending on unfinished surface. Similarly, the release line is at v0.75.6 with earlier patches v0.75.5 and v0.75.4, which is a fast-moving 0.x series; a version number below 1.0 in a workspace that uses Changesets is a signal that breaking changes are still permitted.

The workspace layout is also a constraint in itself. Giselle is not distributed as a single installable package you add to an existing Node application. It is a monorepo you clone and run, with internal packages under @giselles-ai/* whose build is a separate turbo filter. If you wanted a library to embed in your own service, this is not that shape. And if your team has no Node.js or pnpm experience, the quick start is not the obstacle; the CONTRIBUTING.md setup path and the workspace conventions are.

## Giselle compared with hand-rolled agent code

The realistic alternative is not another visual builder. It is writing the orchestration yourself: a small service that calls the provider SDKs directly, stores prompts in your own database, and exposes whatever UI you already have. The difference in approach is where the abstraction lives. In hand-rolled code, the agent definition is source code under your version control and your review process. In Giselle, the agent is a document you edit on a canvas, and the typed representation travels through @giselles-ai/protocol between the editor and the runtime.

That trade is legible. You gain a visual editor, multi-model composition where an agent selects among GPT, Claude and Gemini, and a knowledge store with GitHub vector store integration, without writing retrieval plumbing. You give up the ability to diff an agent as a text file, and you take on the project's own release cadence. The README's claim that Team Collaboration is still in development also means the review workflow around agent changes is not yet a solved problem here.

A second alternative is the hosted service at giselles.ai, which the README says has all the same features as the self-hosted version. Choosing between them is mostly a question of where your data and your provider keys live, and whether 30 minutes of free Agent time per month on the free plan covers your evaluation. Running the cloud version first costs nothing to try; self-hosting costs a clone and a key.

## Licence, maintenance and upgrade cost

Giselle is licensed under the Apache License Version 2.0, and the repository carries a LICENSE file at the root. The README also points to docs/packages-license.md for third-party package licences. Apache-2.0 is permissive and includes an express patent grant, which matters if you plan to build a commercial product on top of the workspace. That is a description of the licence text, not legal advice; if your organisation has a policy on copyleft or attribution, read the file and the third-party inventory yourself.

The last push to the default branch was on 2026-09-01, and the most recent release listed is v0.75.6 from 2026-04-27. Those two dates are worth reading together: commit activity and tagged releases are not moving at the same tempo, so a deployment pinned to a release tag may be several months behind the main branch. The repository is not archived.

Upgrade cost is the part the README is silent on. There is no documented migration guide, no compatibility matrix, and no stated support window for older 0.75.x releases. Changesets is configured (pnpm changeset, pnpm version), which means the project does generate changelog entries, but the README does not tell you how to consume them. If you self-host, budget time for reading release notes between versions rather than assuming a drop-in upgrade.

## Conclusion

Giselle fits teams who want a self-hostable visual builder for chaining OpenAI, Anthropic and Google AI models and who are willing to read CONTRIBUTING.md and the repository layout because the README does not cover production deployment, rollback or scaling. It does not fit anyone who needs a documented upgrade path, a published roadmap, or a stable API surface, since the README states the roadmap is still being created and the release line sits at v0.75.6. Verify first that your pnpm and Node versions satisfy the .node-version file and the packageManager field (pnpm@10.16.0), and confirm which AI provider key you will supply.

## FAQ

### What is Giselle and who is it for?

Giselle is an open source AI app builder for agentic workflows, written in TypeScript and licensed under Apache-2.0. The README positions it for both developers and non-engineers, with a Vibe Coding Guide aimed at people using AI coding assistants.

### How do I install and run Giselle locally?

Clone the repository, run pnpm install, create a .env.local file with at least one provider API key, then run pnpm turbo dev and open http://localhost:3000. The README lists OpenAI, Anthropic and Google AI as supported providers.

### Which AI providers does Giselle support?

The README states that OpenAI, Anthropic and Google AI are supported, and that at least one API key is required. Its Multi-Model Composition feature describes agents selecting among GPT, Claude and Gemini for each task.

### Is Giselle free to use?

The source code is available under the Apache License Version 2.0. The README also describes a hosted service at giselles.ai with the same features as the self-hosted version, including 30 minutes of free Agent time per month on the free plan.

## Sources

- [giselles-ai/giselle on GitHub](https://github.com/giselles-ai/giselle)
- [License: Apache-2.0](https://github.com/giselles-ai/giselle/blob/main/LICENSE)
- [Project website](https://giselles.ai)
- [README](https://github.com/giselles-ai/giselle/blob/main/README.md)
- [Releases](https://github.com/giselles-ai/giselle/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/giselles-ai-giselle