Agent Assembly Runtime
Edit one agent definition and rebuild its group, task and memory views.
We follow an idea until it becomes something you can explore, use, or build on. Sometimes that means a whole system. Sometimes the interesting detour becomes a project of its own.
Find something that interests you ↓Same care. Different scales. Browse by what you want to do.
See the original workbenches, the mechanisms extracted from them, and the public continuations.
No matches. Try fewer words or select Everything.
Edit one agent definition and rebuild its group, task and memory views.
Give a local agent room a durable record, with separate reading positions for each consumer.
Turn a capability record into a portable fenced blueprint, then parse it back.
Give an agent permission for specific package actions and record blocked or completed runs.
Follow a two-stage code-generation experiment from the first draft to a separate refinement.
Name your project paths, imports and startup tasks once, then resolve them from one configuration.
Compare two tiny systems that return the same answer but handle responsibility and failure differently.
Connect conversation to a camera and bounded movement in your own Unreal project.
Define an Atlas domain pack and catch broken definitions and references before a database import.
Take an evidence-backed graph proposal through work packets, review and a recorded commit.
Keep a task request, handler result and execution evidence together, including failures and refusals.
Follow an early builder experiment from a request to a prompt and a chain of registered steps.
Turn capability packages and Foundry blueprints into a graph plan you can inspect before importing.
Publish a local capability version and run its saved snapshot while the next draft changes.
Keep exported conversations, identify duplicate copies and prepare bounded migration batches.
Run a bounded coding-and-review cycle and retain each phase, including a stop before implementation.
Export one chosen coding conversation as readable messages with a source-line ledger.
Turn a local conversation collection into an ordered Discord archive, previewing changes before sending.
Keep a conversation and its changing transformations traceable in a recoverable local vault.
Label who or what a message is about while keeping the conversation context that explains it.
Turn versioned rules JSON into graph records, source references and linked relationships.
Trace a document's claims to evidence, contested points and unanswered questions.
Find dice expressions in JSON and keep the field, action and record each one belongs to.
Decide what an activity policy permits, then minimize retained records and plan expiry.
Plan how an ordered Discord archive should change while reusing existing message slots.
Turn a structured archive into a portable exhibit where topics lead directly to supporting records.
Trace selected Python calls and failures locally without collecting their payloads by default.
Preview a structured work plan, then deliberately publish a GitHub Project and draft items.
Carry a change through implementation, review and audit while preserving failed attempts and retries.
Preview a file move, reject stale plans and restore moved files from the recorded journal.
Run a saved, trusted Python task in a fresh interpreter and keep the source and result evidence.
Bundle an original message and nine prepared context versions with checked original text and character counts.
Record what one model/provider route did on one task, separating support from configuration problems.
Build Discord campaigns and character-creation conversations that can resume after a bot restart.
Save a multi-step conversation, resume it later and refuse stale updates.
Explore a daily-docket prototype whose working first step counts files and exact duplicates.
Follow six design roles from a project request to per-file implementation prompts.
Count a file collection and find exact duplicates before deciding what to move or index.
Build Python capability packages and assemble them into tasks in a desktop workbench.
Compare Python functions and rank possible variants without executing the code.
Map unfamiliar Python code into file breakdowns, relationships, reports and visible unknowns.
Create and validate character sheets without running a Discord bot.
Discover and check models, compare their answers on your task, and inspect the judge and available cost evidence.
Review individual files and generate ignore rules that keep unreviewed additions excluded.
Explore a local workbench for publishing capability versions and recording permitted or refused execution.
Map who owns each responsibility in a system and separate its identity, current state and next ideas.
Study a desktop experiment that kept tasks, model attempts, judgments and pricing views together.
Study how a transcript becomes a proposed work plan while preserving the model response for review.
Read visible usage values with separate Codex and Ollama adapters and preserve uncertain readings.
Check a task against stated completion rules and retain what remains unfinished or needs review.
CinvanaAI is an independent workshop shaped by human ideas, direction, and judgment, with AI helping turn the blueprints into working pieces. The collection spans model evaluation, software architecture, conversation systems, data tools, and games.
Each project stands on its own explanation and evidence. A small library can be useful without its parent workbench. An experiment can be worth sharing for what it reveals. The code, examples, and stated limits are there so you can make up your own mind.
Explore the repositories ↗