Build AI Applications with ZGI

A practical foundation for turning company knowledge, models, and workflows into useful applications.

A support team wants an assistant that can answer questions using its own product documentation. The first prototype works well for a few familiar questions. Then someone asks about a newer policy, a teammate needs to review an uncertain answer, and the team wants to use the same capability in an internal application.

The model is only one part of that job. The application also needs the right information, a way to organize steps, a place to run, and a way for people to check its work.

ZGI is a source-available foundation for building and running AI applications. It brings agents, knowledge, models, tools, and workflows into one workspace so teams can assemble applications around their own tasks. Its source code is publicly available, and teams can deploy it in their own environment, subject to the project's license.

What can you build with ZGI?

Start with a task that already consumes time or requires people to move between sources. Depending on your configuration and the data you are authorized to use, you could build:

• A support knowledge assistant: find relevant product guidance and prepare an answer for an agent to review.
• An internal research assistant: organize information from approved company documents into a draft briefing, with gaps identified for follow-up.
• A business-data assistant: help an authorized employee explore approved tables and prepare an explanation of the result.
• A document workflow: extract information from incoming files, route it through configured steps, and prepare a structured output for review.
• A role-specific agent: combine instructions, a model, knowledge, and selected capabilities for a recurring team task.

These are examples to build and test, not a promise that each application is available as a ready-made template. The quality and permissions of the result depend on the documents, models, configuration, and controls you choose.

A closer look: prepare a support answer

Imagine a customer asks: “Can our team change its subscription plan during the current billing period?” The support representative has a policy guide and a current product FAQ. An answer needs to reflect the right documents, and an unclear policy should be escalated rather than guessed.

Here is one way a team could use ZGI to prepare a draft:

1. Add approved knowledge. Collect the current policy and FAQ, check that the files are suitable for the workspace, and add them to a knowledge collection. Give each file a clear name and date.
2. Build an agent. In Agent Studio, choose an available model, connect the approved knowledge, and instruct the agent to draft answers only from the supplied material.
3. Add a workflow if needed. Arrange steps for receiving a question, retrieving relevant information, preparing a draft, and routing uncertain cases for human review. The exact setup depends on your deployment.
4. Review and test. Ask known questions, check relevant source passages where available, and try cases where the answer is missing or documents disagree. A support representative reviews the draft before it is sent.

A useful response might say, “The approved FAQ describes the plan-change process, but the billing-period detail needs confirmation.” That is more useful than a confident answer built on an outdated document. The team still needs to verify the source, the product policy, and who is allowed to receive the answer.

Try a starting instruction like this:

Draft an answer to the support question using only the approved product documents provided. Identify the relevant document and section when available. If the documents do not answer the question, or if they conflict, say what needs confirmation. Do not invent policy details or send a response to the customer.

This instruction shapes the draft; it does not enforce access controls or guarantee accuracy. Test the complete setup with your own materials before relying on it.

How the building blocks fit together

The support example uses several parts of the same foundation:

Knowledge assets make approved files available for retrieval. They give an application material to consult, but the team must still maintain the files and check whether retrieved passages are relevant.

Models interpret a request and generate an output. ZGI's model management brings model-provider configuration into the workspace; the team chooses an available model for the task and checks its cost, data-handling terms, and quality.

Agents and skills bring instructions and selected capabilities together around a task. An agent may use the knowledge, tools, or workflows configured for it; it should receive only the access it needs.

Workflows organize multiple steps. A team can use them to separate retrieval, processing, review, and output instead of putting the whole task into one prompt.

Runtime and review tools help teams operate the application after a prototype. The public repository describes execution records, workspace permissions, and batch tests. Teams should verify the controls and behavior in the version they deploy.

The combination is what turns a model response into a workflow a team can inspect and improve. ZGI provides the workspace and building blocks; the application owner defines the task, sources, permissions, tests, and human review.

From one useful task to an application

You do not need to automate an entire department on day one. Pick a small task with a clear input and a result someone can check. A support-answer draft, an internal FAQ, or a document summary is a reasonable starting point.

Next, prepare a small set of approved sources and examples with known answers. Configure the agent, test straightforward questions, and include difficult cases: missing information, conflicting documents, an outdated policy, and a request outside the agent's scope. Check what the application does when a source is unavailable.

Once the result is useful, decide how people should access it. The public project describes options including a WebApp, an internal app center, and APIs. Availability and setup depend on the version and deployment, so verify the chosen route before presenting it as ready for a team.

For more sensitive work, keep a person in the approval path and make the handoff explicit. A good first release may prepare work for someone to review rather than sending messages or changing records by itself.

Public source, with a clear license

ZGI's source code is available on GitHub. You can inspect the project, learn how its components fit together, deploy it in your own environment, and contribute under the applicable project terms.

The repository uses the ZGI Community License, based on Apache License 2.0 with additional conditions. Its README states that personal, research, educational, and internal organizational use are free, while hosted multi-tenant services, white-label distribution, and removal of official ZGI branding require a commercial license. The project also states that this is not an OSI-approved open-source license. Read the current license before choosing a use or distribution model.

Source code: https://github.com/zgiai/zgi

License: https://github.com/zgiai/zgi/blob/main/LICENSE

Official website: https://zgi.ai

Start with a problem worth solving

The best place to begin is a task your team understands: a question that keeps coming up, a document that takes too long to prepare, or a process that needs a clearer review step. Build a small application around that task, connect only the information it needs, and test the result with the people who will use it.

That is the purpose of ZGI as an AI application foundation: give teams a common place to build, connect, run, and improve useful AI-powered work.