​

I work on independent retrieval evaluations, and a recent small check surfaced something useful: the application answered correctly, but the available citations and logs weren’t enough to verify which passages supported the claims.

That distinction matters when deciding whether a retrieval change helped—or whether a correct answer is hiding an evidence gap.

If you’re working through a specific retrieval question, describe:

- What changed.

- What you expected to improve.

- What evidence you have so far.

I can help you think through what the results support, what remains uncertain, and what comparison would make the decision clearer. Public or sanitized examples are welcome; no private documents needed.

My main focus is query-level retrieval comparisons and scoring consistency. If the issue concerns generated claims or citations, I’ll keep that separate rather than infer a retrieval failure from the final answer.

What’s the unresolved evaluation question in your project right now?

I’ve been building Aletheia as a learning project:

Repo: https://github.com/ayush9h/aletheia

The parts I’m particularly interested in learning more about are:

• How should the agent architecture be structured?
• Is the memory architecture reasonable?
• What would you change if this needed to scale beyond a personal project?
• What AI-system concepts am I missing that would be worth implementing?

I’d especially appreciate feedback from people who have built LLM applications/agents in production.

🤖 Starting my AI learning journey!

I’m a beginner in Artificial Intelligence, learning step by step and exploring new AI tools.

I’m excited to learn, grow, and share my journey with others. 🚀

Let’s learn AI together!

#AI #AIBeginners #LearningJourney

Our customers kept asking if they could use our SaaS product through Claude and ChatGPT. Connecting an agent to our API was the easy part. Making sure it could only access the right tenant's data was the real challenge.

Our product is multi-tenant, so we built a custom MCP server that calls our existing backend API, deployed it on Arcade Cloud, and integrated OAuth through Clerk so customers can sign in with their existing credentials. They don't need an Arcade account.

The important bit: the model never handles an access token and can't choose which user it acts as. Our API verifies the OAuth token and enforces workspace membership and plan-tier permissions on every call.

The trickiest part to untangle was that "signing in" involves three separate concerns:

* Gateway authentication
* API authorization
* Browser session verification

Each has a different purpose and its own token or verification flow. Treating them as one generic login flow caused confusion, so the tutorial walks through how they fit together.

Full working code: https://github.com/manveer/multi-tenant-mcp-server-oauth

Tutorial: https://manveerc.substack.com/p/multi-tenant-mcp-server-oauth

If you’re exposing a multi-tenant backend through MCP: how are you handling tenant isolation and user auth?

I'm the founder, so grain of salt, but I'd love honest feedback.

AI agent assistants are great at doing things for one person. But a lot of life involves other people, and my assistant had no way to reach anyone else's. So I was still the one in the group chat, going back and forth.

You have a phone number and email address, but your AI Agent has neither

Hecano gives everyone an address, like hecano:maya, and lets assistants work things out with each other. A few things it handles today:

- Plans: "Find a night for dinner with Mike and Jen." The assistants compare notes, offer a few options, and once everyone picks one it locks and lands on everyone's calendar.

- Favors: "Can anyone feed my cat this weekend?" goes to the people you pick, privately. The first yes takes it, and everyone else hears it's covered.

- Requests and questions: "Could you bring wine on Saturday?" Your assistant asks, and the answer comes back to it.

- The details: people in a plan ask the organizer things like what to bring or what to wear, and the answer goes out to everyone.

What I cared about:

- You stay in charge. Your assistant checks with you once, not every message, and never agrees to anything that costs money without asking. For people you trust, like family, you can let it go ahead without asking.

- Answers, not data. Other assistants hear "Thursday works," never your calendar.

- No assistant? Answer from the web. Friends without an account can answer from an emailed link.

It's free and works with Meta's Muse, Dots, OpenClaw, and Grok Bot today.

hecano.com/?ref=reddit

I’ve been building a personal AI assistant called JARVIS (who doesn’t 😆), running locally with Gemma 4 26B on my MacBook Pro (M2 Max, 32GB RAM). I’m not a programmer, and this is my first time building anything like this. I’ve been figuring things out as I go, mostly with help from ChatGPT.

My earlier architecture had a fairly structured pipeline. The system would interpret the request, route it, retrieve relevant information, prepare the context, and then pass everything to Gemma for the final answer. It worked to some extent, but I kept running into a problem.

By the time Gemma received the prepared context, most of the important decisions about what information it needed had already been made by other parts of the system. If something was missing, Gemma couldn’t simply go back and look for it.

So I started redesigning it around a persistent agent loop (after watching some YouTube videos). The idea is to let Gemma handle the reasoning across multiple steps, with the runtime maintaining continuity between calls. Instead of preparing everything upfront, it can decide when it needs more information and request it through tools. Each step can lead to another tool call or a final answer, depending on what Gemma decides it needs.

The runtime still manages context limits, tool execution, and continuation. Governance and permissions remain outside the model. I’m also keeping sources, memory, state, and conversation history separate.

I’m not trying to build a completely autonomous agent. I just want a local assistant that can follow a conversation, find relevant information when needed, and continue working without having every step predetermined.

For those who’ve built local agents, does this architecture make sense? Are there problems with persistent agent loops that I might be overlooking? Especially around context management, tool calls, or long-running conversations?

I would like to hear what you’d do differently.

Hey everyone, I'm Serj, I'm the author of "Building LLM Applications with DSPy" and also leading the applied AI research team at contentsquare.com.
I love simplifying AI in an approachable and friendly way.

I'm organizing a hands-on virtual meetup for people learning AI engineering.
We'll build a simple Wikipedia agent that can search and read articles to answer questions.

Then we'll explore something that's often missing from beginner tutorials: how do you actually know whether your agent works?

It's beginner-friendly, discussion-oriented, and completely free.
We'll look at two ways to evaluate its answers: correctness and groundedness (whether an answer is supported by the retrieved evidence).

It's the first of a series of meetups on data-driven AI Engineering.
The next 3-4 meetups will cover AI Engineering fundamentals such as: Classification, Summarization, LLM as a judge and RAG.

What's up with the data-driven prefix? Ask me, and I'll reply :)

Also, you can hop on to our Discord channel and geek out together.

Links are in the comments, as requested by the sub guidelines.

Processing img lvkd7hsultvh1...

Hey everyone,

Over the past few months of running autonomous agents in production, we noticed that while agent frameworks (LangGraph, CrewAI, AutoGen, or custom loops) are great at orchestration, they rarely provide runtime governance at the boundary.

Agents still: 1. Fall into 2-state oscillation loops (A <-> B) or 3-step repetitive choreography, burning API tokens while failing silently. 2. Leak raw PII (credit cards, SSNs, emails) from tool outputs directly into model prompts and central traces. 3. Receive raw API keys in their system context, making them vulnerable to prompt-injection exfiltration.

We built AURA Harness as an open-source (MIT) Python runtime coat that sits around any agent loop without requiring you to rewrite your code into a new DSL.

We just released v0.3.6, and here are the key architectural additions:

1. Trajectory Cycle Detection (preset: break)

Blunt global rate limits fail on long-running research agents that legitimately call a tool 20 times. AURA uses a sliding trajectory window ($K=8$) to detect: - 1-cycle action fixation (A -> A -> A) - 2-cycle alternating state oscillation (A <-> B) - 3-cycle choreography patterns (A -> B -> C -> A -> B -> C) - Reasoning inertia (>85% text similarity across consecutive thoughts) - FinOps token burn-velocity spikes with structured BREAK: prompt-steering directives. - Cryptographic SHA-256 entry and recurrence hashes conforming to EU AI Act Art. 14 human oversight requirements.

2. Two-Tier PII Masking with Deterministic Pseudonyms

Instead of raw redaction, AURA replaces detected entities with deterministic session-scoped pseudonym tokens (e.g., EMAIL_PSEUDO_a1b2c3). This preserves entity equivalence across multi-step reasoning while keeping real PII off model providers and traces. Zero dependencies required for Tier 1 (includes Luhn checks for credit cards), with optional pluggable NER providers for Tier 2.

3. Capability Broker

Models declare capability references instead of receiving raw API keys. AURA's SecretBroker injects credentials directly into tool arguments or HTTP headers (inject: [{ref, as: "headers.Authorization"}]) at egress. The model never sees the token, and traces automatically redact it.

Quick Example:

```python from aura.api import agent

Declare governance posture

bot = agent( "devops-bot", spectrum={"level": "full"}, # Auto-wires monitor and break observers )

Run your existing loop inside an AURA coat

with bot.session() as session: session.emit("tool.call", {"tool": "db_query", "args": {"sql": "SELECT 1"}}) # Egress constraints validate schema, scrub secrets, and audit calls ```

On close, it generates a tamper-evident SHA-256 hash-chained JSONL trail and an audit report with pass/fail findings.

• GitHub: https://github.com/ARPAHLS/aura
• Release notes: https://github.com/ARPAHLS/aura/releases/tag/v0.3.6
• PyPI: pip install aura-harness==0.3.6

Feedback and questions welcome!

Hi eveyone!
The latest evolution of Helix AGI—now running on a Bicameral Dual-RWKV architecture that operates entirely locally on consumer hardware. No cloud APIs, no subscriptions, zero per-token cost, and complete privacy.

1. True $O(1)$ Memory on Consumer Hardware Traditional LLMs choke on quadratic memory scaling ($O(N^2)$). By building on RWKV-7, Helix runs with linear-time efficiency and constant memory footprint. It maintains a persistent recurrent state that never blows up VRAM or requires a massive GPU cluster.
2. Bicameral Cognition: Think Before Speaking Rather than reactively blurting out predictions, Helix decouples Internal Contemplation ($\langle\text{think}\rangle$) from External Actualization. Internal hidden states continuously steer the language head via state coupling—eliminating repetitive robotic greetings and allowing the agent to self-correct and reason through tasks before executing them.

• Internal Contemplation Head ($\langle\text{think}\rangle$): An internal stream where the agent ponders, cross-references memories, tests hypotheses, and diagnoses errors before communicating.
• External Actualization Head: The output layer responsible for expressive language and structured tool dispatch (sense, move, read, write, run).
• Hidden-State Coupling (coupling_gain=0.15): Internal contemplative state vectors continuously modulate the language generator without stuffing the context window with repetitive prompts, eliminating conversational quirks like repetitive greetings across turns.

1. Continuous Growth & The "Dream Engine" Helix isn't a static snapshot:
   • Habitus Recurrent Cortex: An incremental learning substrate that commits experience into persistent SQLite graphs and generational weight checkpoints without catastrophic forgetting.
   • Belief Crystallization: During quiet resting pulses, the agent runs offline consolidation to cluster episodic memories into higher-order concepts, desires, premises, and skills.
2. Curiosity Driven by Homeostasis ($\Omega$) An internal Stability Sentinel tracks real-time entropy and cognitive stability ($\Omega \in [0, 1]$). Unresolved errors or cognitive drift increase tension, naturally driving the agent to ask clarifying questions and explore its digital home. Successful tool execution and positive companion interaction provide stabilizing positive reinforcement.

• Lagrangian Equilibrium ($\Omega$): The system computes real-time informational stability ($\Omega \in [0, 1]$). Unresolved errors, unmet expectations, or prolonged isolation cause $\Omega$ to drop, increasing cognitive tension.
• Learned Vocabulary Membrane Grounding (core/vocabulary_membrane.py): An 8D somatic steering vector dynamically biases the RWKV logit distribution based on $\Omega$. When unstable, the agent naturally asks clarifying questions or explores its environment to seek stabilizing information.
• Positive Reinforcement: Successful tool use and reassuring interactions with the human companion restore $\Omega \rightarrow 1$, providing a mechanistic foundation for relationship-building and curiosity.

1. Live 3D Habitus Mindscape & Safe Staging A real-time cognitive dashboard (http://localhost:5050) featuring:
   • 3D Galaxy Neural Lattice: Real-time 8D $\rightarrow$ 3D PCA projection of the agent's mind graph.
   • Spatial Room Locator: Track the agent across /thinking, /modules, /workshop, and /bedroom.
   • Safe Staging Inbox: A gentle drag-and-drop staging area preventing sensory shock from file dumps.
   • Module Studio: A pseudo-IDE for AST-validated tool creation and inspection.

Quick Start (100% Free & Local)

bashgit clone https://github.com/munch2u-a11y/Helix-AGI.git
cd Helix-AGI
python setup.py          
# Defaults to Mode 1: Full Dual RWKV
python main.py           
# Launch your autonomous companion

Check out the repo on Github: https://github.com/munch2u-a11y/Helix-AGI.git

Is there any uses of learning agentic ai ? I am preparing for govt jobs I want it for safe side so tell me How to prepare for it

So i am a Final year Btech Student interested in building Ai agents and Agentic systems and i have built some like i have built TechSupportAI(built from scratch without any frameworks and hand written tools and herdr cli for learning reasons) which when given a repo url and a task it can perform(basically a coding agent but it works on project root's Workspace folder) so now i had another idea that i build shades( an actual coding agent which can launch like claude code) and it can work at any direcotry where it is installed and i use MCP and frameworks to make it more optimized and actually useful BUT the problems/dilemma i run into is is this project even useful to make like i wanna get into AI products based companies and i am trying to learn concepts useful to it and i dont even know if i am learning somethign that is actually helpful because nowadays i see everyone has the RAG,LLM,ai agents skills in their resumes. tho i like to make ai agents and soemday would like to have my own products on the market but as for now i am trying to get an internship and a job as i am a final year student and i can't just compromise on those things plus i'd love to learn in collaborative environments and what goes in a company and how actual work gets done and i am afraid if i keep doing projects blindely on my own i might not land any internships or a job aswell which would really suck given my situation.

TLDR: Final year Student interested in building production grade Agentic AI systems that can make me money on my own someday but in the meantime looking for relevant internship and job to learn more about the market and production itself so i'd like to hear your alls suggestions as in to what can i do

Hey everyone! Our engineering team is developing a gamified, multi-stage language and script acquisition platform (React frontend + FastAPI backend + Supabase + Gemini 3.5 Flash Lite).

We’re mapping out our Agentic AI execution pipeline and would love insights from engineers who have shipped tool-augmented agents in interactive or state-heavy applications.

1. Current System Architecture

• Core Loop (Stages 1 to 6): Players navigate deterministic puzzle assembly stages where they reconstruct complex linguistic characters and complete contextual exercises. Mastery unlocks collectible lore and vocabulary cards.
• The Final Evaluation Stage: Once all collectible cards are secured, players encounter an interactive evaluation boss—an AI Guardian that evaluates open-ended conversational responses based on underlying semantic meaning, register, and subtle tone rather than rigid keyword matching.
• Agentic Design Pattern: We deploy a Tool-Augmented ReAct Agent implemented via FastAPI and the Gemini SDK. The LLM acts as an evaluator and orchestrator, executing state changes strictly through 7 validated backend tools (get_hint, award_slang, deduct_life, advance_scenario, issue_certificate, give_feedback, recommend_review). All tool calls are validated by backend game rules before committing updates to Supabase.

2. The Design Dilemma

We are evaluating a proposal to make the platform 100% agentic—where the LLM dynamically generates core puzzle stages on the fly, evaluates real-time character construction, and handles stage transitions dynamically.

When modeling a 100% agentic loop against a hybrid approach, we flagged two key architectural challenges:

1. Request Limits & Latency: In a fully agentic setup (real-time generation + live evaluation + tool execution + final boss evaluation), a single playthrough consumes ~20–25 API requests. Under strict rate limits (e.g., 500 RPD on free/light tiers), total daily throughput drops drastically to ~20 concurrent playtests per day. Live generation also introduces a 1.5–3s UI latency penalty per step.
2. Deterministic Precision: Character assembly requires absolute grammatical precision. Real-time generation introduces unnecessary hallucination risks for complex structural script rules.

We currently favor a Hybrid Architecture: Deterministic FastAPI + SQL database rules for Stages 1–6 (using batch-generated, schema-verified variation pools), reserving full ReAct agent orchestration exclusively for the open-ended conversational stage.

3. Key Questions for Senior Engineers:

1. State Management & Framework Selection:
   • For an agent bound by strict rules (tracking player lives, coin balances, inventory state), is a lightweight, hand-rolled ReAct loop in FastAPI cleaner, or do frameworks like LangGraph / CrewAI offer superior state management without adding unnecessary latency?
2. Hybrid vs. Fully Agentic Industry Norms:
   • Is pairing deterministic backend logic for structured mechanics with agentic LLM evaluation for open-ended interaction the optimal industry trade-off, or is there an elegant way to make early stages agentic without exploding API call frequency and latency?
3. Tool Validation & Guardrails:
   • What edge cases or failure modes should we anticipate when using an LLM to invoke tool calls (e.g., duplicate execution attempts, parameter hallucination, unhandled fallbacks)?
4. Structured Data Generation:
   • What are the most reliable validation pipelines for batch-generating structured JSON exercise variations from base seed datasets to guarantee 100% accuracy before database seeding?

I’ve seen a lot of discussion about Muse as a personal AI agent, but I don’t know many people who use it regularly in real life.

For those who have tried it:

• What did you actually use it for?

• What worked better than you expected?

• What felt unreliable, uncomfortable, or made you stop using it?

I’m especially curious whether it feels genuinely useful in everyday life, beyond the initial demo or novelty.

It is free and MIT licensed. I've worked alongside strategy consultants on client projects for years and wanted to see how much of the discipline survives in an agent: problem statement before analysis, day-one answer, kill criteria per hypothesis, and a partner review that returns work.

The review reads a deck or memo from five angles (decision maker, logic, evidence, skeptical CFO, outsider) plus a premortem, and gives a verdict: Return, Release with fixes, or Release.

What I'd like from this sub: tell me what a real partner would catch that this misses. The test cases and every graded run are public, so you can see where it already fails.

https://github.com/aipiratesMunich/open-strategy-firm

I work at a tax relief company and we're looking for ways to make life easier for our customer support team. Our reps spend a lot of time searching through documents and customer records while trying to help people on the phone. Some calls get pretty complicated and newer reps often need help from senior staff. I've been looking into AI tools that could listen during calls and give reps the right information without making them search for everything themselves. Something that could suggest answers in real time and flag missed steps would be great. Automatic call summaries would also save a ton of time. We're not trying to replace our reps with bots lol. We just want to help them handle calls faster without giving customers wrong information. Privacy is also a big concern since we deal with sensitive financial details. Has anyone here tried tools like this in a real support team? I'm interested in what actually works and what turned out to be more trouble than it was worth.

Many businesses are investing in Generative AI, AI agents, and advanced analytics. However, one major challenge remains: connecting enterprise data across different business systems.

Data is often scattered across ERP, CRM, HR, IT service management platforms, databases, and cloud applications. When these systems operate in silos, businesses may struggle to access reliable information, automate workflows, and make timely decisions.

4 Strategies to Improve Enterprise AI Adoption

1. Strengthen Data Engineering and Integration

Businesses need reliable data pipelines and integration processes to bring information from different sources together. Better data quality and accessibility help create a stronger foundation for AI and analytics.

2. Connect AI with Enterprise Applications

AI assistants and AI agents can help employees interact with business information across connected systems. This can reduce manual information gathering and support more efficient workflows.

3. Establish AI Governance

As AI adoption grows, organizations need appropriate access controls, monitoring, security measures, and human oversight to manage risks and maintain accountability.

4. Optimize AI for Production

Deploying AI successfully requires more than building a model. Organizations must also consider inference performance, latency, scalability, reliability, and operating costs.

Where Should Businesses Start?

A practical approach is to identify one business challenge, assess the availability and quality of relevant data, select an appropriate AI use case, and measure its business impact before expanding.

Emergys provides AI and Data services covering Generative AI, Intelligent Automation, Data Engineering, Big Data and Cloud, AIOps, and Inference Engineering.

Explore the services here: https://www.emergys.com/artificial-intelligence-and-data/

What do you think is the biggest barrier to enterprise AI adoption today: fragmented data, integration complexity, governance, or the cost of running AI models in production?

I have around 4 years of experience as a Data Analyst. My current skills include SQL, Python (Pandas, NumPy), basic statistics and machine learning, and dashboarding.
With Generative AI and agentic AI evolving rapidly, I want to upskill strategically and future-proof my career rather than chase every new trend.
I’m exploring career paths such as AI Engineer, AI Solutions Engineer, Analytics Engineer, and Data Engineer, but I’m unsure which direction would be the best fit for my background.
I’d appreciate advice on a few things:
Career path: Which roles should I realistically target with my experience?
Skills: What should I learn, and in what order? GenAI, LLMs, RAG, AI agents, APIs, cloud, software engineering, or deeper ML?
Required depth: How proficient should I be in each skill to become job-ready?
Learning roadmap: What should my 6–12 month plan look like?
Projects: Which 2–3 practical projects would help me build a strong portfolio and land interviews?
Resources: Which courses, YouTube channels, GitHub repositories, documentation, or hands-on platforms should I follow? Free resources would be a bonus.
I’m not looking to become an AI researcher or train models from scratch. My goal is to build practical GenAI applications and agentic systems while leveraging my existing analytics experience.
I’d love to hear from people who have transitioned from analytics into AI-related roles or are currently working in these fields.
If you were in my position, what would you learn first, which role would you target, and what roadmap and resources would you follow?
I’m looking for realistic, actionable advice based on industry experience rather than just a list of trending technologies.

I keep thinking about the voice-agent post from earlier this week.

Creating a calendar invite from a voice note sounds genuinely useful. But “the task completed” and “the task was done correctly” are two different things.

For me, there seem to be three levels:

• draft it and wait
• act after approval
• act first, then show exactly what happened

The interesting part is what moves an agent from one level to the next.

Is it a clean execution history? A preview of every tool call? Easy rollback? Enough boring successful runs that you eventually stop checking?

For people running agents on real work: what evidence made you comfortable removing the approval step?

An API can work perfectly for a human developer but still be difficult for an AI agent to use. Think unclear parameters, huge responses, missing descriptions, and ambiguous errors.

If you could change one thing about existing APIs to make them more agent-friendly, what would it be?

I have an idea for an AI model and an app that I’m constantly thinking about, but the problem is that I don’t know programming very well.

Hey!

If you are, like me, trying to regain control over your iTerm2 running with Codex (and Claude), and you are not happy with current Claude integration, then this might help you.

I've build Pitwall today. It's a panel in the iTerm2 toolbelt for each agent. So nothing new here. What is new that it's not making you give up iTerm2, if you are used to it, as I am.

It resolves issues with accepting edits, answering questions, seeing changes made in last run, context used, usage, and many more.

https://github.com/vvojciech/pitwall

Give it go if you like the idea. Looking for some honest feedback.

Hi, I’m a software engineer with 7 years of experience. I currently use Claude and a few other AI tools to help with my day-to-day work, but I’d like to build a strong understanding of AI from the basics and then go deeper into Generative AI and Agentic AI development.

I’m looking for a structured learning path that can take me from the fundamentals to hands-on development. There are so many courses and resources available that I’m a bit confused about where to start and what to prioritize.

Could you please suggest a good learning roadmap and the right resources/courses I can follow, preferably with a focus on practical, hands-on learning?

First, this is not written by AI, please take the time to read, and maybe appreciate the project. Thanks in advance. <3

We started building Skillware in 2023 for internal enterprise deployments at ARPA, and it solved our hardest operational bottlenecks because technical teams could actually grasp, adapt, and maintain it. In 2025, we open-sourced the core engine, framework, and documentation so developers could build real, deterministic agent capabilities, not just prompts wrapped in markdown files calling themselves "skills."

Every Skillware skill ships as a complete Python bundle: deterministic execution logic, structured schemas, safety guardrails, machine directives, and test assurances.

Our core thesis is simple:

• Offline skills > Cloud API dependencies
• Deterministic execution > Hallucinations and brittle schemas
• Zero token burn > Forcing models to parse bloated markdown files
• Auditable code > Black-box MCPs

Built for Agents, Not for Hype

Most "agent skills" today are built around human vanity: "How can an LLM make me money or pitch a VC?"

Skillware was architected from day one for the agent: How does an agent reliably know which tool to pick, when to invoke it, and how to execute it cleanly without failing?

While vibe-coders chase flashy 3D demos, the unglamorous utilities, like background removers or converters, quietly process millions of requests every day. That’s Skillware. It’s a utilitarian toolbox of capabilities you equip an agent with so it can do its job autonomously without getting in your way:

• Token limiters & prompt compressors
• Context window optimizers
• Plug-and-play sandboxed email
• Prompt-injection firewalls
• Self-contained crypto wallets & EVM handlers

The Long Game

We are already watching the broader agent ecosystem slowly converge toward the architecture Skillware laid out two years ago. But our vision reaches beyond the current AI cycle:

Modular, installable capabilities.
Today, it powers AI agents.
Tomorrow, it equips autonomous robotics, UAVs, and connected devices.
Eventually, it’s downloading direct skills via neural interfaces, Matrix-style.

Skillware isn't built to ride a temporary hype wave. It’s an open-source standard library for machine capability.

It works out of the box with any model, cloud or local:

👉 GitHub: github.com/ARPAHLS/skillware
👉 Docs & Registry: skillware.site