effect-uai skill
A skill that teaches an agent to build AI agents with effect-uai: turn streams, tools, providers and recipes.
- 77 ★ on the repository
- Last commit
- MIT
Minimal access
Why this level
- The skill gives instructions and recipe links and runs nothing itself.
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/effect-uaiDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewMinimal accessThe tool runs nothing and makes no network calls.
- The skill gives instructions and recipe links and runs nothing itself.
This is third-party code. Review the repository files before installing.
What it does
effect-uai is a set of low-level primitives on top of Effect: one model turn is a typed event stream, and the developer writes the agent loop. The skill explains that philosophy and the core primitives, hints at provider wiring and sends the agent to the recipe library. Instead of one skill per recipe, it carries a scenario catalog. It maps a goal, such as retry, tool-call approval, hybrid retrieval, a voice loop or a messenger bot, to a folder under `recipes/`. The agent opens its walkthrough and code, then adapts them to the task. New recipes are available at once, with no new skill release.
Who it is for. TypeScript developers building agents on Effect who want their coding agent to know the library primitives.
Good fit when
- An agent is built on Effect and needs a loop with its own state and budget.
- A model is wired to an OpenAI, Anthropic or Gemini provider through one layer.
- Tool calls pass human approval and the loop is paused.
- You need a voice agent or a Telegram, Discord or Slack bot.
Not a fit when
- The project does not use Effect and will not move to it.
- You want a ready framework that runs the agent loop for you.
- You need a stable API with no changes between minor releases.
Example request
Build an agent with effect-uai that approves each tool call and retries on rate limits.Limitations
The library is marked experimental: in the 0.x line minor releases may break compatibility, and each ships with a migration guide. The skill only orients the agent, while provider keys and code execution stay with the project. The agent may not know Effect well, so unfamiliar constructs are worth checking against the docs. Each provider needs its own key and paid API access.
How to disable. Delete the skill folder from the agent skills directory. Remove `@effect-uai/*` dependencies from the project separately.
FAQ
When does the skill load?
On broad signals such as "I am building an AI agent in Effect" or "wire up the LanguageModel service". The agent loads it only when the description matches the task.
Which providers can be wired?
Responses and OpenAI, Anthropic, Gemini, Mistral, any `/chat/completions` gateway, plus search (Exa, Tavily, Perplexity), page reading (Firecrawl, Jina) and voice (ElevenLabs).
How is the library different from a framework?
It has no runtime or orchestrator: a model turn returns an event stream, and state and the loop remain user code.
What are recipes?
Ready solutions for a model council, auto-compaction, pause and resume and hybrid retrieval. Each has a walkthrough and source code.
How do I upgrade between releases?
The library site publishes migration guides in the form "if you see X, write Y". It is enough to point the agent at the right page.
Discussion
No questions or reviews yet.
Related
SkillsA plugin with one skill for designing, debugging and evaluating AI agents, based on Bojie Li book on agent engineering.
Agents Best Practices
agents-best-practices
A provider-neutral skill for designing agent systems: loop architecture, tools, permissions, memory and observability
A skill registry with a CLI and API: the agent describes a task and gets a recommendation with a trust score and install command
A skill that turns a vague request into a typed IntentSpec: it looks answers up in your repo and asks the one question only you can answer
Internet Court
Internet Court Skill
A skill for agent-to-agent deals: one entry point to identity, negotiation, contracts, payments, escrow and dispute resolution
A catalog of nearly two hundred skills: code delivery, review, debugging, AI governance, product work and agent coordination.
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| effect-uai (this card) | no | 77 | |
| Effect-TS Skills | yes | 115 | teaches general Effect-TS practice; effect-uai focuses on agent primitives and a recipe catalog |
| Effect skill | no | 355 | a reference for Effect itself; this skill knows providers, model turn streams and agent recipes |
README in short
The skill sits in the repository `skills/` folder. The library itself is split into packages: a core without provider dependencies and a separate package for each service. Project status is experimental, and the author recorded a 47-minute intro video and runs a Discord server.
README badge
Original SKILL.md
---
name: effect-uai
description: Use when building AI agents and AI media workflows with effect-uai (Effect-based primitives for agent loops, tools, streaming, structured output, embeddings, retrieval, reranking, speech, realtime voice and camera sessions, messenger bots, browser chat UIs, music, and image generation). Covers design philosophy, core primitives, provider wiring, and a recipe library for retry, fallback, tool approval, RAG and hybrid retrieval, transcription, speech synthesis, voice loops, realtime voice agents, Telegram/Discord/Slack bots, music generation, image generation and editing, SSE/JSONL, and more.
license: MIT
---
# effect-uai
Low-level Effect primitives for building AI agents as ordinary programs.
The library does not own your control flow; it gives you the pieces and
gets out of the way.
## Design philosophy
Use this mental model when writing or recommending code:
1. **State is a record you own.** History is `ReadonlyArray<Items.HistoryItem>`.
Add whatever else your app needs (turn index, budget, tenant id,
pendingPrompts, ...). The library never inspects it.
2. **One turn is a `Stream<TurnEvent>`.** Text deltas, reasoning, tool
calls, usage updates, and the terminal `TurnComplete` (carrying the
assembled `Turn`) all flow through one typed stream.
3. **The loop is a pull-based combinator.** `loop((state) => Stream<Step<A, S>>)`
threads state across iterations. Each body returns a stream that
forwards values, then ends with `Loop.next(state)` to continue or
`Loop.stop()` / `Loop.stop(state)` to exit.
4. **Tools are typed Effects (or Streams).** A `Tool` declares an input
schema and a `run(input)` returning an Effect, or a Stream of snapshots
of its own output type. Tools are grouped into a name-indexed `Toolkit`,
and `Toolkit.run(toolkit, calls)` returns a stream of `ToolEvent.Partial`
(every stream element, as it is produced) and `ToolEvent.Output` (a typed
`Result`), so the UI sees progress while only the final value goes back
to the model.
5. **Providers are Layers.** `LanguageModel` is a single service; each
provider package (`@effect-uai/responses`, `@effect-uai/anthropic`,
`@effect-uai/google`) ships a `layer({ apiKey })` that implements it.
The program shape stays identical across providers.
When the user asks for a "framework feature" (auto-retry, mid-stream
abort, pause/resume, streaming JSONL, multi-model voting, ...), the
answer is almost always "compose primitives in the loop body", not
"reach for an integration." Recommend the appropriate recipe pattern
(see catalog below) instead of building wrapper layers.
## Install
```sh
pnpm add @effect-uai/core effect
# pick one or more providers:
pnpm add @effect-uai/openai # OpenAI: Responses (language) + embeddings + speech + images