AI · Agents & Infrastructure

Google’s agent kit, shipping an evaluation harness and Cloud Run deployment commands out of the box. The Agent2Agent protocol lets agents from different frameworks talk.

A video series building agents step by step, for people who would rather watch than read.

An agent framework with memory, tools and knowledge base built into the core. Unlike frameworks such as LangChain there is no extra abstraction layer: agent instantiation lands in the microsecond range, which keeps it light with many agents.

Runs a 70B model on a 4 GB GPU by loading one layer at a time and discarding it after use. Unlike quantisation it does not reduce weight precision; the cost is speed.

A research company building systems that model the physical world rather than language, aimed at robotics and industrial control.

An LLM tracing and evaluation tool that runs inside a notebook and renders traces locally. Unlike tracing tools that need a server, it stays local and visualises the embedding space, so you find the source of a retrieval failure by looking at clustering.

A resource list for Claude Code, Anthropic’s terminal-based coding assistant. Unlike the official docs, it gathers community-shared slash commands, hooks and CLAUDE.md examples.

A curated list of Claude skills — the place to check what already exists rather than writing the same thing twice from scratch.

A resource list of agents for Copilot, GitHub’s AI pair-programming assistant. Unlike general Copilot tips, it focuses on ready agent definitions and custom instruction files.

A resource list for Genkit, the open-source framework for building AI-powered features. Unlike frameworks such as LangChain, it integrates tightly with Firebase and Google Cloud and ships a local developer UI.

Curated directory of LLM API providers offering free tiers or trial credits, complete with rate limits and model lists; helps prototype without locking into a single paid provider.

A resource list for Gemini CLI, Google’s terminal-based coding assistant. Unlike Claude Code lists, it gathers extensions, MCP configurations and workflows specific to Google’s tool.

Agent definition, tool schema and knowledge base are configured in the AWS console, and AWS runs the runtime. Unlike self-operated frameworks such as LangGraph there is no infrastructure to run; the price is fitting the flow into AWS’s shape.

Content filters, denied-topic lists and PII redaction. Unlike libraries you run yourself such as NeMo Guardrails it is a managed service, and it can be applied as a standalone API to models outside Bedrock too.

AWS’s open-source agent SDK. Unlike frameworks such as LangGraph where you wire the flow, you hand the model a tool list and let it plan; less code to write, at the cost of harder tracing when you need to see where a decision came from.

A classifier scoring text and images across four harm categories with severity levels. You set the thresholds yourself — an alternative to training your own moderation model.

Model catalogue, agent service, evaluation and content filtering in one portal. Rather than assembling these from separate services, it offers a stack gathered for enterprise deployments that need compliance and region control.

OpenAI models with Azure’s region selection and private networking. Unlike OpenAI’s own API you gain that compliance; the price is that new model versions arrive here later.

An open-source governance layer for AI agents that enforces rules and limits on what agents may do. Unlike agent frameworks it is about control: it does not build the agent, it constrains a built agent’s actions with policy and logs them.

An inference framework reducing weights to 1.58 bits (three values); multiplications collapse into additions, so it runs at acceptable speed on CPU. Unlike llama.cpp’s 4–8-bit quantisation, it needs a model trained in this format from the start.

An agent that places phone calls from an API call, showing the speech-recognition → model → synthesis chain end to end. Unlike off-the-shelf voice-assistant services it is open source — a working reference for voice-agent architecture you can deploy in your own Azure account.

A research framework for societies of role-playing agents steering each other. Suited to scaled experiments and synthetic data generation, not to production plumbing.

A repo collecting what does and does not work when pairing with a coding agent — field notes rather than official docs.

Claude Code configuration pack providing multi-agent templates (design, programming, audio, QA) tailored for game development; sets up role-based studio workflows instead of single-prompt chats.

HKUDS framework that wraps desktop and web software into structured command-line interfaces callable by AI agents; produces deterministic tool calls compared to screenshot-based GUI automation.

Cloudflare agent skill that guides coding agents through contextual security audits and secret-leak checks across a codebase; performs semantic review unlike static regex linters.

Ships ready tool definitions and delegated OAuth for a thousand-odd apps. Instead of writing auth per SaaS, you hand the authorisation off to it.

You give each agent a role, goal and backstory; tasks are dispatched sequentially or hierarchically. Conceptually simple, but it gives less fine control over flow than LangGraph.

You do not write prompt text — you declare input/output signatures and supply examples, and an optimiser generates the prompts and few-shot demonstrations. Unlike prompt-template frameworks, it hands prompt tuning to a compiler.

A configuration bundle of skills, rules, memory layout and security settings for coding agents. The kind of thing you start from and prune, rather than assemble from scratch.

Decorate a function and it becomes an MCP tool, with the schema derived from type hints. Unlike the raw official SDK, it erases nearly all the boilerplate you would hand-write.

A spec-driven development system: it has the agent write a spec first and then generate code against it. Rather than asking for code directly, it anchors what the code should do to a written reference. The repository is archived (last update May 2026), so no new releases are coming.

The official server exposing repo, issue, PR and Actions operations as tools. Unlike community servers it is maintained by GitHub itself, with fine-grained permission scopes, so you can hand an assistant read-only access.

Runs output through a chain of schemas and validators, retrying or repairing on failure. Unlike NeMo Guardrails, which governs the dialogue flow, it polices the shape and content of the generated text.

Compresses tool output, logs and RAG chunks before they reach the model, running as a library, a proxy or an MCP server. Instead of a bigger context window it shrinks the content — the gain is largest on JSON-heavy payloads.

An LLM observability tool: change the base URL and requests are logged as they pass through. Unlike tracers that need SDK integration it works as a proxy, so it bolts onto an existing project without code changes.

A narrow skill stripping the tells of AI writing — over-parallel structure, filler transitions, uniform rhythm — from a text. Unlike general rewriting tools, it targets only those tells, not the content.

An API focused on prompt injection and jailbreak detection. Unlike general content filters, it is fed by real attack data harvested from its gamified Gandalf experiment.

Wraps model, vector store and tool providers behind common interfaces. Compared with thinner frameworks its strongest card is the integration count; the thickness of the abstraction layer is the most frequent complaint.

The official walkthrough of defining tools, binding a model and wiring the loop. Unlike conceptual explainers it proceeds in running code — the shortest way to see how the tool-calling protocol actually works.

The current docs drop the old chain vocabulary for a slimmer API built around create_agent. The LLMChain examples in older tutorials no longer apply.

Framework-agnostic LLM tracing and evaluation, OpenTelemetry-compatible. Unlike hosted services such as LangSmith you can self-host it, so prompt and response data never leaves your infrastructure.

You define agent flow as a state graph of nodes and edges. Unlike a flat LangChain chain, it supports loops, conditional branching and pausing for human approval (interrupts).

Shows input, output, latency and token count for every chain step separately. Not tied to LangChain, though that is where the integration is tightest.

A skill sweeping the last thirty days of Reddit, X and YouTube on a topic. Unlike a general web search it focuses only on recent community discussion — aimed at the gap between a model’s training cutoff and today.

An async runtime where steps emit and listen for events. Instead of building a graph you mark functions with @step, and parallel branches fall out naturally.

A community marketplace of skills and servers. Broader than the official registry but weakly vetted — read the source before installing.

The official MCP server registry. Rather than scattered GitHub lists, it offers one machine-readable source, which lets clients automate installation.

Reference MCP servers for tools such as filesystem, Git and fetch. Unlike third-party servers in the registry, these are written by the protocol’s authors as examples — a quick read before writing your own.

The new line merging AutoGen’s experimental side with Semantic Kernel’s enterprise side. Unlike either one alone it combines both, and arrives pre-wired to Azure identity and monitoring.

Agents solve tasks by talking in a group chat, with a manager agent deciding who speaks next. Unlike graph-based frameworks such as LangGraph the flow is a conversation; research-rooted, so the API can shift sharply between versions.

Detects and redacts personal data — national IDs, IBANs, emails — in text and images, with customisable recognisers. Unlike cloud PII services it is open source and runs locally — for the anonymisation step before data reaches a model.

An open protocol over JSON-RPC for exposing tools and data sources to models. Unlike writing a plugin per model, you write the server once and any MCP-speaking client can use it.

You declare permitted conversation flows in a DSL called Colang. The control sits in the dialogue’s trajectory rather than the output text, cutting topic drift at the entrance.

Keeps a coding agent’s memory as plain Markdown in an Obsidian vault. Unlike vector-database memory services there is nothing to run, and you can read and correct the notes yourself.

Routes one OpenAI-compatible endpoint to hundreds of providers, many with free tiers. Instead of a client per provider you use one address, and automatic failover when a provider drops breaks single-API dependence.

Settles for four concepts: agents, tools, handoffs and guardrails, with tracing built in. Compared with frameworks such as LangGraph, the learning curve is far shallower.

A management layer deciding which skill loads when. Selective loading instead of stuffing every skill into context is where the token saving comes from.

A skill that stops an agent inventing needless abstraction and premature generalisation. Unlike general coding skills that push towards more code, it restrains output in order to lower maintenance cost.

Scans model files for malicious payloads — because pickle deserialisation can execute arbitrary code, a downloaded checkpoint is a real attack surface. Unlike classic malware scanners it understands these model formats; Protect AI joined Palo Alto Networks in 2025 and the product now lives under Prisma AIRS.

A guide collecting prompt engineering techniques with academic citations: chain of thought, few-shot, RAG. Against blog posts each technique carries a paper reference, which separates claim from finding.

Surfaces which AI tools employees send what data to, and blocks by policy. Unlike guards placed on the model side, it watches the user side — for organisations that need to measure shadow AI use.

Runs prompts and models side by side against a test set declared in YAML. Unlike tools that watch production traces it catches problems before release — a model-version regression shows up in a CI step.

A platform for versioning, logging and evaluating LLM prompts, so you can trace which prompt produced which output. Unlike general APM tooling it treats the prompt as a first-class object, separating prompt changes from code deploys.

Validates model output against a Pydantic schema and sends it back for correction when it fails. What you get out is a type-guaranteed object, not free text.

CLI agent that inspects browser network captures (HAR files) and turns undocumented web API calls into reusable Python client code; extracts direct endpoints instead of relying on brittle DOM scraping.

An agent SDK exposing one API across C#, Python and Java. If you live in an enterprise .NET stack it creates far less friction than the Python-centric alternatives.

A skills framework imposing a stepwise development discipline instead of free-form prompting, separating planning, implementation and verification.

Alibaba’s open-source “deep research” agent model that runs multi-step web research on its own. Unlike chat LLMs it is an agent: rather than a single reply it calls tools and browses sources to carry a long research task from start to finish.

The LLM side of Weights & Biases. Rather than setting up a separate tracing tool, if you already track training in W&B the inference traces land under the same project.

A dependency-free C/C++ port of OpenAI’s Whisper speech recognition model that runs at a reasonable pace even on CPU. Against the Python original there is no install burden and it compiles to a single binary — small enough for embedded targets.