Local-First · Fair-Code · You Own Every Hop

Build AI Agents on a Canvas.
Run Them Where You Point.

A no-code, local-first studio for building and running AI agents. Inference runs on your machine — llama.cpp, MLX, or vLLM — or any OpenAI-compatible API you register, chosen per agent and per call by a logical ID like triage-fast. TheYgent never proxies your prompts, payloads, or weights.

Star on GitHub Read the Docs →
  • llama.cpp
  • MLX
  • vLLM
  • openai-compatible
~/TheYgent — make up

Sovereignty, Not Surveillance

You Own Every Hop.

TheYgent is never the man-in-the-middle. No proxied prompts, no captured weights — every hop runs where you point it.

  • Never a Middleman The vendor is never an involuntary hop between you and your model.
  • Nothing Proxied Prompts, payloads, and weights are never routed through anyone's servers.
  • Per-Agent, Per-Call Your choice of engine for every node, every run — swap it without touching an edge.
The Whole Idea Swap the engine, keep the ID — triage-fast → MLX, vLLM, or a hosted API

You can register a hosted API whenever you want one; the promise is sovereignty and anti-lock-in — not “nothing ever leaves your machine.” When something crosses the wire, it does so because you sent it there.

The Builder

Compose Agents Visually.

A visual AI agent builder: drag nodes onto a canvas, wire them with edges, configure them in the inspector, and run — no code required. The graph is the agent; saving it mints a content-addressed version you can roll back to.

  • input · output
  • llm
  • tool · mcp
  • router · transform · guardrail
  • human · subgraph · loop · map
  • audio · image
Editor · Palette + Inspector

Logical-ID Indirection

One ID per Call. Any Engine Underneath.

Give a model a logical ID once. Swap the engine beneath it — Apple Silicon, an NVIDIA GPU, any machine, or an API you register — and every edge on the canvas stays untouched: no vendor lock-in, no rewiring. Engine choice is per node, not per app: one graph can run local and hosted models side by side.

Bind triage-fast to
logical id binding runs on
triage-fast mlx Apple Silicon
draft-large vllm An NVIDIA GPU
extract-ocr llamacpp Any machine
reason-remote openai-compatible An API you register

MLX serves it on Apple Silicon — the Neural Engine and GPU.

binding ∈ { mlx | vllm | llamacpp | openai-compatible } · source ∈ { hf | local-path | url }

Mix Freely Local + remote in one graph — triage-fast answers on-device, reason-remote escalates to an API you registered

The Runtime

Everything a Real Agent Needs.

Chat, tools, retrieval, models, and automation — one local runtime that orchestrates all of it, no glue code.

chat

Unified Chat

Streaming answers, a collapsible thinking view for reasoning models, and voice and image input — talk to any model or saved agent.

tools

Tools & MCP

Built-in tools, HTTP calls, and any MCP (Model Context Protocol) server over stdio or HTTP — running in your own trust domain.

automation

Triggers

Deploy a saved agent behind a token-authed endpoint, an HMAC-signed webhook, or a cron schedule.

memory

Retrieval Sources

Crawl a site or upload documents, embed them locally into pgvector, and wire RAG retrieval into any graph.

models

Model Registry

Browse the catalog, see what fits your RAM before downloading, and serve chat, vision, audio, and embeddings locally.

the bench

The Bench

Test and benchmark any model or agent: per-turn latency and token metrics, saved and compared side by side.

Production Discipline

Production-Grade by Default.

An agent you can’t replay, trace, or audit is a demo. Every TheYgent run is checkpointed, traced, and kept — and the whole stack deploys the same way everywhere.

  • Durable Runs checkpoint every step. Kill the process mid-run and it resumes from the last completed node — loops, subgraphs, and human approvals included.
  • Observable Every run yields a zoomable span waterfall — per-node inputs, outputs, timing, and token usage — with opt-in OTLP export to your own OpenTelemetry collector.
  • Auditable Runs, sessions, and traces persist in your Postgres. Agents are immutable, content-addressed versions — you can always answer which graph ran, when, and with what.
  • Deployable The same three services, self-hosted in every topology: make up on bare metal, Docker Compose, or Kubernetes — never two architectures.

Run It Locally

Up in Two Commands.

Clone the repo and run make up. The interface, control plane, inference plane, and Postgres come online locally; engines start lazily when a model is first called.

  • Three local services + your Postgres
  • Bring your own models, or register an API
  • No vendor account — localhost by default
Quickstart 
$ git clone https://github.com/al2m4n/TheYgent.git
$ cd TheYgent
$ make up
✓ inference-plane   :8081
✓ control-plane     :8080   postgres :5432
✓ interface         :5174
# open http://localhost:5174

Questions

Asked and Answered.

What is TheYgent?

TheYgent is a no-code, local-first platform for building and running AI agents on a visual canvas. You drag nodes — LLMs, MCP tools, routers, RAG retrieval, guardrails, human approvals — wire them with edges, and run the graph as an agent. Inference runs on your own machine via llama.cpp, MLX, or vLLM, or on any OpenAI-compatible API you register, chosen per agent and per call.

Is TheYgent open source?

TheYgent is source-available under a fair-code license (the Sustainable Use License), not an OSI-approved open-source license. The full source is on GitHub, and you are free to use, modify, and self-host it for internal business, personal, and non-commercial purposes. Selling it — including offering it as a hosted service — is not permitted.

Does TheYgent send my data to the cloud?

TheYgent never proxies your prompts, payloads, or model weights through anyone’s servers — you own every hop. By default everything runs on your machine: local engines, your own Postgres, localhost interfaces. If you register a hosted API for a model, that traffic goes directly from your machine to the provider you chose — it crosses the wire only because you sent it there.

Which local inference engines does TheYgent support?

Three local engines plus a universal escape hatch: llama.cpp (runs on any machine, CPU or GPU), MLX (Apple Silicon), and vLLM (NVIDIA GPUs) — plus any OpenAI-compatible API you register. Models get a logical ID, so you can swap the engine underneath without touching the agent graph, and one graph can mix local and hosted models side by side.

Can I use MCP (Model Context Protocol) tools in my agents?

Yes. TheYgent connects to any MCP server over stdio or HTTP, and you can browse and install servers from the MCP registry inside the app. MCP tools drop onto the canvas as nodes, so a local model can call the same tools a hosted assistant would — running in your own trust domain.

Do I need to write code to build an agent?

No. The canvas is the whole workflow: drag nodes from the palette, connect them, configure each one in the inspector, and run. Publishing an agent mints an immutable, content-addressed version you can invoke by API, roll back, or wire to a trigger — all without writing code.

Can agents run unattended — on a schedule or from a webhook?

Yes. A published agent can sit behind a token-authenticated endpoint, an HMAC-signed webhook, or a cron schedule. Runs can be durable: every step is checkpointed, so if the process dies mid-run it resumes from the last completed node — loops, subgraphs, and human-approval waits included.

How do I self-host TheYgent?

Clone the repo and run make up for bare metal, or deploy the same three services with Docker Compose or Kubernetes — it’s one architecture in every topology. There’s no vendor account and no cloud dependency — the only account is the local admin you create in the first-run wizard; the stack listens on localhost by default and stores everything in your own Postgres.

Does TheYgent support RAG (retrieval-augmented generation)?

Yes. Crawl a site or upload documents, embed them locally into pgvector in your own Postgres, and wire a retrieval node into any graph. Embedding and retrieval both run through engines you choose — keep the embedding model local and your documents never leave your machine; bind a hosted API and they go only where you pointed them.

Can one agent use both local and hosted models?

Yes — engine choice is per node, not per app. A common pattern is a fast local model handling triage on-device while a larger hosted model, reached through an API you registered, takes the escalations. Because nodes reference logical model IDs, swapping any binding later doesn’t touch a single edge.

The License

Source-Available, Fair-Code.

Free to use, modify, and self-host for internal business, personal, and non-commercial use under the Sustainable Use License. What you can’t do: sell it or offer it as a hosted service. No bait-and-switch — the core is the core.

Read the License →

Your Canvas. Your Engines. Your Agents.

No vendor account, no cloud dependency, no lock-in. Clone the repo, run make up, and your first agent is on the canvas in minutes.

Star on GitHub Read the Docs →