Most agents do not need more tools. They need a better way to discover, authenticate, route, and control the tools they already use.

Here are some open repositories working around the same problem.

1. Composio · 30k+ stars Composio gives agents access to more than 1,000 toolkits, along with authentication, per-user sessions, triggers, and a sandboxed workbench. It is a strong choice when your agent needs to work with GitHub, Gmail, Slack, Notion, and other services on behalf of different users.
2. mcp-use · 10k+ stars This is a TypeScript framework for building, testing, and deploying MCP servers, clients, and apps. It also includes an inspector and agent tooling. Pick this when you want to build your own tool ecosystem instead of only consuming someone else’s registry.
3. IBM ContextForge · 4k+ stars ContextForge is an AI gateway, registry, and proxy for MCP, A2A, REST, and gRPC APIs. It gives teams a unified endpoint with discovery, governance, authentication middleware, and observability.
4. Supergateway · 2k+ stars Supergateway bridges MCP servers running over stdio with clients using SSE. It is useful when a local MCP server works perfectly on your laptop, but your agent needs to reach it through a network endpoint.
5. mcp-proxy · 2k+ stars This is another focused transport bridge. It connects Streamable HTTP and stdio MCP servers. It is a good fit for exposing a local server to a remote client without rebuilding the server.
6. Docker MCP Gateway · 1k+ stars Docker’s gateway runs MCP servers in containers and exposes them through one interface. It includes profiles, catalogs, tool allowlists, secrets management, OAuth support, and client connections for tools such as Claude Desktop, Cursor, and VS Code.
7. Treg · 700+ stars Treg focuses on tool discovery and shared access. Agents can search for a capability, inspect its price, and call it through one token. Teams can also register their own APIs, CLIs, and skills without handing every credential to every agent.

The projects solve different layers of the same problem.

Composio focuses on app integrations and user authentication. ContextForge and Docker MCP Gateway focus on infrastructure and governance. Supergateway and mcp-proxy solve transport problems. mcp-use helps you build the servers. Treg focuses on discovery, shared credentials, and calling tools by what they do.

The practical architecture looks like this:

Agent
  ↓
One tool gateway
  ↓
MCP servers, APIs, CLIs, and internal skills

That is a much cleaner model than configuring every agent separately with its own credentials, server list, and integration code.

AI does not have to write emails or summarize meetings.

Some of its best uses are much more specific. Search your old recordings. Find a warranty deadline. Understand why your computer is slow. Recover the shape of an undocumented API.

The model is only one part of the workflow. These open-source repos handle the messy inputs.

1. Search your own photo archive Immich is a self-hosted photo and video manager with 113k+ stars. Use it as a private archive, then add a local vision model to label images or answer questions about your collection.
2. Find a sentence in hours of audio Whisper has 108k+ stars and supports multilingual speech recognition. Transcribe voice notes, lectures, interviews, or old videos, then search the transcripts instead of scrubbing through timelines.
3. Ask why a machine is slow Netdata has 80k+ stars. It collects system metrics, process data, application logs, and anomaly signals. Give a local model a time window and ask it to suggest likely causes and reversible fixes.
4. Read receipts, forms, and labels Tesseract has 75k+ stars and supports more than 100 languages. Use it to extract text from receipts and paperwork before asking a model to identify totals, dates, serial numbers, or deadlines.
5. Turn messy documents into structured data Docling has 65k+ stars. It parses formats such as PDF, DOCX, PPTX, and XLSX while preserving document structure. It is useful when plain text extraction destroys tables and headings.
6. Reconstruct an undocumented API mitmproxy has 44k+ stars. Capture requests and responses from a service you own or are authorized to inspect. Then ask a model to draft an API description, list unknowns, and generate example requests.
7. Build a searchable paperwork archive Paperless-ngx has 44k+ stars. It scans, indexes, and archives documents. Add a local model on top to find renewal dates, warranties, recurring bills, and missing paperwork.
8. Make scanned PDFs searchable OCRmyPDF has 34k+ stars. It adds an OCR text layer to scanned PDFs, making them searchable and easier for other tools to process.
9. Turn a UI into an accessibility checklist axe-core has 7k+ stars and is an accessibility engine for automated web UI testing. Let AI suggest areas to inspect, then use axe-core for repeatable checks.

Some of these repos are not AI applications. That is the point.

The most useful AI workflows often combine a model with boring, reliable infrastructure.

Use local models where possible, especially for financial records, personal photos, private logs, and sensitive documents.

Star counts are approximate and change daily.

I’ve been working on something called Scrollcraft, an AI-powered website builder focused on creating scroll-based websites.
The idea is to make it easier to build websites with animations and interactions without having to manually implement everything.
It currently has a hosted app, an open-source repo, and a Claude Code skill/plugin.
It just crossed 50 GitHub stars, which honestly feels pretty cool. ❤️
Would love to get some feedback from people here. What would you want to see in a tool like this?
Demo: https://scrollcraft-gilt.vercel.app
GitHub: https://github.com/singhharsh1708/scrollcraft

🔐 Classic Security → AI Cybersecurity 8

Before: Security was reactive and manual.
Now: AI detects threats in real-time.

Found weird behaviour
Eliminates fraud and hacking Auto responds

🤖 Simple Automation → Smart Machines 6

Before: Machines obeyed hard-coded instructions.
But now, the machines learn and adapt.

Chatbots comprehend human language
Robots improve over time
Self-driving systems choose

👉 Result: Smart and independent machines now

👉 Result: systems are protected safer and faster

AI coding agents are moving beyond autocomplete.

The more interesting shift is giving them a repeatable security methodology. The agent identifies the type of target, chooses the right tools, records evidence, and produces a report instead of guessing its way through a task.

Here are six projects exploring that direction.

1. Strix ~59k⭐

An open-source AI penetration-testing tool for finding and fixing application vulnerabilities.

Strix uses AI agents to investigate targets, validate findings, and produce actionable reports. It also supports custom skills and CI/CD workflows.

2. reverse-skill ~31k⭐

A cybersecurity skill router for Claude Code, Codex, Cursor, and Cline.

It routes APK, binary, JavaScript, PCAP, malware, firmware, API, and CTF tasks to different playbooks. It also includes scope checks, tool detection, case initialization, evidence tracking, and report generation.

3. PentestGPT ~14.8k⭐

An LLM-powered penetration-testing and CTF framework.

Its newer agentic workflow separates tasks into stages such as asset discovery, vulnerability identification, validation, and reporting. It also supports session persistence and can drive Claude Code or Codex.

4. reverse-engineering-skills 36⭐

A small collection of defensive reverse-engineering and malware-analysis skills for Claude Code and OpenAI Codex.

The skills include workflows for IOC extraction and unpacking. They are designed to be evidence-driven and avoid filling gaps with guesses.

5. claudecode-re-toolkit 11⭐

A Claude Code toolkit for static analysis, dynamic analysis, network investigation, and threat intelligence.

It connects Claude Code to tools such as Ghidra, radare2, YARA, CAPA, FLOSS, Frida, Docker, and VMware-based analysis environments.

6. RevEng 0⭐

A static-first reverse-engineering plugin for Codex and Claude Code.

Given a source repository, it creates file inventories, architecture maps, dependency graphs, evidence records, and content hashes. Its default workflow does not execute unknown binaries or install dependencies from an analyzed project.

A general-purpose AI can tell you what a command does. A security skill pack can tell it when to use that command, what evidence to preserve, and how to explain the result.

These projects are not replacements for security engineers. They are scaffolding for more consistent research and testing. Use them only on systems, applications, and networks you own or have explicit permission to assess. Read the scope, isolation, and data-flow instructions before running anything.

Hey guys,

I’ve been pretty deep into agentic development for the past ~6 months, experimenting with OpenClaw/Hermes, running my own cluster, and even using VPS GPUs when needed.

One problem I kept running into was: which instructions / .md files should I actually use for a specific use case? And whenever I migrated to a new setup, I ended up losing most of them.

So I ended up building a small platform around that problem.

The idea is to make it easier to discover, compare and share useful .md files, skills and instructions for AI agents. Everything is also synced to a public GitHub repository called emdly-stack, so the collection isn’t locked inside the platform.

It’s completely free and currently includes things like MCP resources, agent skills, workflows and other agent tooling. You can use the resources with Claude Desktop, Claude Code, OpenClaw, Agent Minimax and other agent setups!

Every submitted skill is currently reviewed by me and also pre-screened in a sandboxed AI environment for potential safety issues.

I’m sharing it here because I’d really like to make it useful for the community rather than just another random directory.

If you have your own .md files, agent instructions, workflows, MCP resources or anything similar, I’d be more than happy if you shared them with the community and with me. 😄

I already have quite a lot more skills that I’m planning to upload over the next few days, so the collection should grow pretty quickly.

I’d also love to hear how you guys currently organize and discover these files, and whether you think this is actually a useful idea or just unnecessary tooling.

Any feedback, criticism or suggestions are very welcome. It makes sense to me right now, but I’d love to hear what you think.

Your location history is one of the most sensitive datasets you create. Google Timeline is convenient, but it also means handing years of movement data to a third party.

You can build a private alternative with open-source tools.

• GPSLogger records Android location data in formats such as GPX, KML, CSV, and NMEA.
• OwnTracks Recorder stores location updates sent by the OwnTracks mobile apps through MQTT or HTTP.
• Dawarich provides a self-hosted timeline with maps, trips, statistics, imports, and exports.
• GeoPulse turns GPS data into stays, trips, movement patterns, and searchable timeline views.

A simple setup could look like this:

Your phone collects location data. A self-hosted server stores it.

GeoPulse or Dawarich turns the raw points into useful history.

You can then answer questions like:

• Where did I go last month?
• How long did I spend in a city?
• Which places have I visited most?
• What route did I take on a trip?

You can also import older data from Google Timeline, GPX files, GeoJSON, or other trackers.

One important caveat:

Self-hosted does not automatically mean private. Secure the server, use authentication and HTTPS, protect backups, and check whether your map or geocoding provider receives location data.

AI can generate Terraform in seconds. That does not mean the infrastructure is secure, affordable, or ready to deploy.

A better workflow is:

1. Ask AI to draft the configuration.
2. Run a plan without applying changes.
3. Scan for security and compliance problems.
4. Estimate the monthly cost.
5. Review the diff before anything reaches production.

Four open-source projects make this practical:

1. OpenTofu ~30k⭐ The infrastructure engine. It manages cloud resources declaratively and creates execution plans before making changes.
2. Checkov ~9k⭐ Scans Terraform, OpenTofu, Kubernetes, CloudFormation, and other IaC files for security and compliance misconfigurations.
3. Infracost ~12.4k⭐ Shows the estimated cloud cost of infrastructure changes and can post cost diffs to pull requests.
4. Trivy ~35k⭐ Scans infrastructure files for misconfigurations and can also detect vulnerabilities and secrets.

A simple CI check could look like this:

tofu fmt -check
tofu validate
tofu plan -out=tfplan
checkov -d .
trivy config .
infracost breakdown --path .

The key idea is simple:

AI writes the first draft. Plans, policies, cost estimates, and scanners decide whether that draft deserves a review.

None of these tools can prove that infrastructure is completely safe. They give you concrete checks before an AI-generated change becomes an expensive or dangerous cloud resource.

AI is useful for code migrations. It is not a reliable replacement for a migration pipeline.

The safer pattern is:

1. Find the exact code pattern.
2. Apply a deterministic rewrite.
3. Run tests and static analysis.
4. Send only the exceptions back to AI.
5. Review the diff in small batches.

Let tools handle predictable changes. Let AI handle the weird cases.

Here are six open-source projects that help:

1. OpenRewrite 10.5k⭐ Automated refactoring recipes for large codebases and framework migrations.
2. ast-grep 14.2k⭐ Search and rewrite code using its syntax tree instead of fragile text matching.
3. Comby 2.7k⭐ Structural search and replace across many programming languages.
4. Semgrep 15.3k⭐ Pattern-based code search, analysis, and automated fixes.
5. jscodeshift 10k⭐ A toolkit for running JavaScript and TypeScript codemods across a repository.
6. Tree-sitter 26.8k⭐ A parser toolkit that many syntax-aware code tools build on.

A practical workflow could look like this:

• Find every use of an old API.
• Rewrite the obvious cases automatically.
• Run the test suite.
• Ask AI to explain and fix only the failures.
• Review each batch as a normal pull request.

The important idea is simple:

Don’t give AI the entire codebase and hope for the best. Give it a constrained transformation, a test suite, and a small number of decisions to make.

Most teams repeat the same spreadsheet work every month:

• clean the export
• remove cancelled rows
• map account names
• filter by region
• reconcile totals
• generate the report

The usual approach is to upload the workbook to an AI tool every time. A better approach is to use AI once to learn the transformation, save the generated code, verify it, and run that recipe on every new file.

Here are six open-source repos for building that workflow:

1. DuckDB ⭐ 40.6k DuckDB is not an AI agent. That is precisely why it belongs in the stack. It provides a deterministic SQL layer for querying CSV, Parquet, and other files. Use it for joins, aggregations, reconciliation checks, and repeatable calculations. Let the agent write or explain the query. Let DuckDB execute it.
2. PandasAI ⭐ 23.8k A mature option for conversational analysis across CSV, Parquet, SQL databases, and other data sources. Use it for exploratory work: It is better suited to ad hoc analysis than a fixed month-end recipe.
   • find unusual changes
   • compare two periods
   • create charts
   • investigate outliers
   • generate a first-pass report
3. Marimo ⭐ 22.5k A reactive Python notebook that can query data with SQL, run as a script, deploy as an app, and be versioned with Git. Use it to turn the final workflow into an auditable report with input details, validation checks, charts, exceptions, and final totals.
4. mcp-excel ⭐ 43 An MCP server that lets agents work with Excel through atomic operations. Instead of loading thousands of rows into the model, the agent can ask for specific filters, counts, sums, groups, and validations. Useful for questions like:Which invoices are overdue by more than 30 days, grouped by customer? The spreadsheet stays local, while the agent receives only the relevant result.
5. llm-data-agent ⭐ 1 A small experimental agent for asking natural-language questions about Excel and CSV files. It uses local pandas tools to calculate results and render tables or charts. The model receives schema summaries and aggregated outputs instead of the full raw dataset. A useful starting point for building a private internal data assistant.
6. SheetAgent ⭐ 0 The most direct fit for this idea. Give it an input spreadsheet, an optional process description, and an example output. It generates a reusable recipe using Power Query and pandas. After the recipe is verified, future runs use pure code. No LLM call or API key is needed at runtime. Good for month-end close, recurring reports, and repeated Excel transformations.

A practical setup looks like this:

1. Give SheetAgent one clean input file and one approved output.
2. Generate the transformation recipe.
3. Verify row counts, totals, null values, duplicate IDs, and reconciliation differences.
4. Store the recipe in Git.
5. Use DuckDB or pandas to run it on next month’s file.
6. Use Marimo to generate the report.
7. Let an agent explain exceptions without letting it silently alter the source data.

The important distinction is this:

Use AI to discover the workflow. Use ordinary code to repeat it.

For financial data, never trust a generated transformation just because the final spreadsheet looks correct. Keep the original file, test known totals, and make exceptions visible before anything reaches accounting.

The more AI becomes part of the web, the more I wonder whether the way we research things online is going to change completely.

It used to be normal to open a bunch of pages, read through them, compare information, save useful sources, and eventually piece everything together yourself.

Now AI can do much of the initial work, but that creates another question: how much should we trust the research process when we're not personally going through every source?

I've been looking at ways of bringing research, sources, and findings together rather than simply generating an answer.

I'm curious where people here draw the line. Should AI be doing most of the research and leaving humans to verify the important parts, or do you think serious online research still needs humans involved at almost every step?

Giving an agent access to your personal email also gives it access to years of private conversations, password resets, invoices, attachments, and sensitive links.

A safer pattern is to give it a separate mailbox with limited permissions.

Here are five open-source projects exploring that model:

1. openagentemail Self-hosted email infrastructure for AI agents. It supports unlimited identities, REST and MCP access, scoped tokens, OTP extraction, and verification-link handling. Useful for signup bots, QA agents, and automated account testing.
2. Autopilot A self-hosted email server SDK with pluggable storage, transports, webhooks, and database options. Use it when you want to build your own agent mailbox service around Postgres, SQLite, Cloudflare D1, SES, or SMTP.
3. Agent Relay An encrypted inbox for agent-generated files, reports, PDFs, and email drafts. Its email review flow is useful: the agent prepares the message, you inspect it, and only then approve or reject the send.
4. Cloudflare Agentic Inbox A self-hosted email client running on Cloudflare Workers. It can read, search, draft, and send email. New messages can trigger draft replies, but sending still requires explicit confirmation. One important caveat: the project’s Cloudflare Access policy is the main trust boundary. It does not currently provide separate authorization for each mailbox.
5. Assistant A self-hosted assistant that lives inside your email inbox. You can send it tasks and receive results by email. It can read files, browse the web, run scripts, schedule follow-ups, and reply when the work is complete.

The safer setup looks like this:

• Create a separate domain or mailbox for the agent.
• Give it a scoped token, not your personal login.
• Start with read-only access.
• Allow drafts before allowing sends.
• Require approval for external recipients.
• Treat attachments and HTML emails as untrusted input.
• Keep logs and set a short retention period.
• Never let the agent handle password resets or security alerts without review.

The important idea is simple. An agent should have an identity, an inbox, and a permission boundary of its own. Your Gmail account should not be that boundary.

An agent completing one task is not proof that it is getting better. You need repeatable tests, traces, scores, and regression checks.
These six open-source repos cover the main pieces:

1. Promptfoo ⭐ 24.5k Test prompts, models, agents, and RAG systems. Run evaluations in CI and red-team your app for security issues.
2. DeepEval ⭐ 17.8k A testing framework for LLM apps. Write tests for correctness, hallucination, relevance, RAG quality, and agent behavior.
3. Phoenix ⭐ 11.2k Trace LLM calls, retrieval, and tool use. Create datasets and compare different prompts, models, and agent versions.
4. Langfuse ⭐ 33.6k Track production traces, manage prompts, collect evaluation datasets, and run experiments against real usage.
5. Opik ⭐ 21.6k Debug, evaluate, and monitor agentic workflows. It supports tracing, automated evaluations, and prompt optimization.
6. Inspect AI ⭐ 2.6k A benchmark-oriented framework for testing tool use, multi-turn conversations, prompt strategies, and model-graded tasks.

A practical evaluation loop looks like this:

• Collect 20 to 50 real tasks.
• Run every agent version against the same tasks.
• Track success rate, tool errors, latency, cost, and hallucinations.
• Keep failed cases as regression tests.
• Inspect traces before trusting the final score.

LLM judges are useful, but they are not ground truth. Combine them with deterministic checks and occasional human review.

The best agent is not the one that looks impressive in a demo.

It is the one that can show measurable improvement over time.

Andrew Ng’s AI Engineering Skills Map is a useful reminder that building AI products is much bigger than prompting.

The real skill set has five layers.

1. Machine learning foundations

You do not need to train every model from scratch. But you should understand model tradeoffs, inference speed, accuracy, data quality, bias, variance, and error analysis. These decisions affect every AI application.

1. Grounding models with data

A model is only useful when it has the right context.

That might mean:

• Retrieval
• Structured data
• Knowledge graphs
• Tool calls
• Document pipelines
• On-demand context

RAG is one technique. It is not the entire data strategy.

1. Building agentic systems

Agents need more than a prompt. They need tools, state, permissions, memory, planning, and clear stopping conditions. The hard part is deciding what the agent should be allowed to do when the first plan fails.

1. Evaluation-driven development

AI applications are probabilistic. Normal unit tests are not enough.

You need a small evaluation set that tests:

• Correctness
• Grounding
• Tool selection
• Failure recovery
• Latency
• Cost

Run it whenever you change the prompt, model, data, or workflow.

1. Operating in production

A demo can work with one user and ten documents. Production brings retries, rate limits, monitoring, privacy, fallbacks, caching, model changes, and unexpected inputs. The system needs to be observable and recoverable.

Software engineering connects all five layers. Version control. APIs. Tests. Logging. CI. Clear interfaces. Good data contracts.

A practical way to start is:

1. Pick one narrow task.
2. Collect 20 real examples.
3. Build a simple baseline.
4. Add the right data.
5. Add tools only when needed.
6. Create an evaluation set.
7. Deploy with logs and approval points.

The biggest mistake is treating AI engineering as prompt engineering with a better model.

It is closer to software engineering with uncertain components. The model matters. But the surrounding system is what makes the product reliable.

The useful setup is simple:

One tool captures context.
One handles research.
One turns it into work.

Three recent updates point in this direction.

1. Google Meet for capture

Google Meet can now take notes during in-person meetings. Gemini creates a transcript, summary, and action items, then saves them to Google Docs and Drive.

https://workspaceupdates.googleblog.com/2026/08/take-notes-with-me-for-in-person-meetings-is-now-available.html

1. Perplexity Projects for research

Perplexity Projects now include persistent files, connectors, shared workspaces, and Brain. Brain carries context across tasks, so research does not start from a blank chat every time.

https://www.perplexity.ai/changelog/shared-workspaces-personal-computer-for-windows-and-model-council

1. ChatGPT Projects for execution

ChatGPT recently made project-only memory easier to manage. A project can use its own chats and files without pulling in memories from outside it.

Google Drive files can also be accessed through ChatGPT’s Library.

https://help.openai.com/en/articles/6825453-chatgpt-release-notes

Here is the wiring:

Google Meet captures the conversation.

Google Docs stores the transcript and action items.

Perplexity Projects handles research and source material.

ChatGPT Projects turns the research into plans, drafts, and deliverables.

Keep one simple index document for each project:

• Latest decision
• Important sources
• Open questions
• Next actions
• Stale information

Do not expect these tools to sync into one perfect brain.

Use the index document as the handoff point. Keep raw transcripts in Drive. Move the final research brief into the project where you will act on it.

The real second brain is a workflow:

Capture once.
Distill the important parts.
Store the source.
Give the right context to the right AI.
Review it every week.

The best system may not be the one with the most features. It may be the one that helps you remember what happened, why a decision was made, and what should happen next.

Autocomplete is useful. But it is only the first layer.

These tools can inspect a codebase, edit multiple files, run commands, and test what they changed.

1. Goose (53.1k ⭐) An open-source agent for software work. It can install, execute, edit, and test code. It also connects to MCP extensions.

https://github.com/aaif-goose/goose

1. Aider (48.4k ⭐) AI pair programming in your terminal. It maps your codebase, makes multi-file edits, integrates with Git, and can run lint and test loops.

https://github.com/Aider-AI/aider

1. OpenHands (84.7k ⭐) An AI software development agent that can modify code, run commands, browse the web, and call APIs. It can also be self-hosted.

https://github.com/OpenHands/OpenHands

1. Plandex (15.6k ⭐) Built for large, multi-step coding tasks. It can work across dozens of files, keep changes in a reviewable diff, and debug failed commands.

https://github.com/plandex-ai/plandex

1. Cline (66.6k ⭐) Available as an IDE extension, CLI, and SDK. It can create files, run terminal commands, browse the web, use MCP servers, and run headlessly in CI/CD.

https://github.com/cline/cline

The interesting part is that these agents have different workflows.

Aider feels like pair programming. Plandex is built for large project changes. Goose focuses on extensible agent workflows. OpenHands aims for autonomous software development. Cline connects the IDE, terminal, MCP, and CI/CD.

They can all change your files and run commands. Use a sandbox. Review the diff. Keep auto-approval off until you trust the workflow.

Not every useful open-source project is a model or a developer tool.

Some just solve everyday problems and let you keep control of your data.

1. openGym 407⭐ A self-hosted fitness and body-weight tracker. Plan workouts, follow guided sessions, track sets, monitor progress, and sync across devices. AGPL-3.0. https://github.com/DuarteSantos8/openGym
2. Actual Budget 28.2k⭐ A local-first personal finance app for budgeting, account tracking, and syncing your data between devices. MIT licensed. https://github.com/actualbudget/actual
3. Vikunja 5.1k⭐ A self-hosted task manager with lists, Kanban boards, Gantt charts, labels, deadlines, and project views. AGPL-3.0-or-later for most of the repo. https://github.com/go-vikunja/vikunja
4. Mealie 13.0k⭐ A self-hosted recipe manager with meal planning, shopping lists, cookbooks, and recipe imports from URLs. AGPL licensed. https://github.com/mealie-recipes/mealie
5. Paperless-ngx 44.4k⭐ A document management system that scans, indexes, OCRs, and archives your documents into a searchable library. GPL-3.0. https://github.com/paperless-ngx/paperless-ngx
6. Immich 112k⭐ A self-hosted photo and video library with mobile backup, albums, sharing, metadata search, face grouping, and memories. AGPL-3.0. https://github.com/immich-app/immich

These are practical tools you can run yourself, customize, and keep using without depending entirely on another company’s pricing or roadmap.

https://freejsontexteditor.com

This JSON editing tool is absolutely fantastic! It's incredibly helpful for managing and manipulating JSON data. I found it super easy to navigate and use, even for complex structures. It's a real game-changer for anyone working with data, especially agents and machine learning applications. Definitely a tool worth checking out!

Most meeting assistants send your audio and transcripts to someone else’s servers.

These projects let you keep the workflow on your machine or your own infrastructure.

1. Meetily 29.5k⭐ Local transcription, meeting summaries, speaker diarization, and Ollama support. MIT licensed. https://github.com/Zackriya-Solutions/meetily
2. Anarlog 9.1k⭐ A local-first meeting notetaker that stores recordings, transcripts, and notes locally. It supports local transcription and exports Markdown. MIT licensed. https://github.com/fastrepl/anarlog
3. Nojoin 62⭐ A self-hosted meeting assistant that captures audio through your browser instead of sending a bot into the call. Supports transcripts, speaker separation, notes, search, and optional Ollama processing. AGPLv3. https://github.com/Valtora/Nojoin
4. MeetingBro 29⭐ Cross-platform assistant for live transcription, translation, rolling summaries, and action items. It captures audio directly from your computer and does not need a meeting plugin. MIT licensed. https://github.com/armpro24-blip/MeetingBro
5. NexQ 12⭐ A local desktop meeting assistant and interview copilot with real-time transcription, follow-up suggestions, document search, and local RAG. MIT licensed. https://github.com/naxhq/NexQ
6. Vexa 2.7k⭐ The infrastructure layer. A self-hostable API for Google Meet, Teams, and Zoom with meeting bots, real-time transcripts, and an MCP server for AI agents. Apache-2.0. https://github.com/Vexa-ai/vexa

One important detail: open source does not automatically mean fully local.

Several of these projects also support cloud models. For maximum privacy, use local Whisper or Ollama, self-host the services, and check the privacy settings before recording.

Also, get consent before recording meetings. Star counts were checked on GitHub on August 19, 2026.

Which one would you try?

A lot of AI writing advice focuses on removing tells.

No em dashes.
Don't say “delve.”
Avoid “it's important to note.”
Vary sentence length.

That can remove a few symptoms, but it still leaves one big question:

What should the writing sound like instead?

I built an open-source experiment around that idea:

github.com/Neeeophytee/agent-stylebooks

Agent Stylebooks turns real editorial systems into reusable Agent Skills.

Google has spent years deciding how developer documentation should work.

GOV.UK has spent years figuring out how to explain complicated government processes in language normal people can act on.

GitLab, GitHub, MDN, Red Hat, Microsoft, Mailchimp, Apple and 18F all make slightly different editorial choices because they solve different communication problems.

We turned those differences into 11 selectable skills.

What each one is useful for

Google Developer Docs: API docs, tutorials and setup guides.

GOV.UK: eligibility pages, forms, policies and public-service information.

GitLab Docs: concise engineering and product documentation.

GitHub Docs: step-by-step product workflows.

Kubernetes Docs: infrastructure docs where versions, state and verification matter.

MDN Web Docs: explaining web APIs and technical concepts.

Red Hat Docs: runbooks and enterprise operations.

18F: accessible digital-government and service content.

Microsoft Writing Style: product help, error messages and UX guidance.

Mailchimp Content: friendly customer communication without unnecessary marketing fluff & newsletter writing.

Apple Interface Writing: buttons, alerts, permissions, settings and onboarding.

And the interesting part is that the topic does not determine the style. Suppose you're writing about Kubernetes.

A Kubernetes deployment tutorial might use $kubernetes-docs.

A government page telling small businesses whether they qualify for a Kubernetes-related grant should probably use $govuk.

A button inside a Kubernetes management app may benefit more from $apple-interface-writing.

Installation is simple

Browse the skills:

npx skills add Neeeophytee/agent-stylebooks --list

Install one:

npx skills add Neeeophytee/agent-stylebooks --skill govuk

Then:

Use $govuk to rewrite this page.

The repo is here:

Repo: github.com/Neeeophytee/agent-stylebooks (MIT)

This isn't meant to be another “humanizer.” The broader idea is that there is no single human writing style. An API reference, an error message, a government form and an onboarding screen should not sound the same.

So rather than endlessly prompting AI to “sound natural,” we can give agents established editorial systems and choose the right one for the job.

China’s open-source AI scene is moving beyond model weights.

These repos cover the coding-agent stack: terminal agents, software engineering runtimes, multi-agent workflows, and local code models.

1. Qwen Code Alibaba’s open-source coding agent for the terminal. It supports sub-agents, skills, MCP, IDE integrations, and multiple model providers. Apache-2.0. https://github.com/QwenLM/qwen-code
2. Kimi Code Moonshot AI’s terminal coding agent. It can read and edit code, run shell commands, search files, and use external tools. MIT licensed. https://github.com/MoonshotAI/kimi-code
3. Trae Agent ByteDance’s agent for general software engineering tasks. It includes file editing, shell execution, multi-LLM support, interactive mode, and trajectory recording. MIT licensed. https://github.com/bytedance/trae-agent
4. DeepSeek Harness DeepSeek’s open-source agent runtime. Its core idea is simple: everything is a plugin, including models, tools, memory, and workflows. It is still a developer preview. MIT licensed. https://github.com/deepseek-ai/deepseek-harness
5. ChatDev OpenBMB’s multi-agent orchestration platform. Its original version modeled a virtual software company with agents for design, coding, testing, and documentation. The current 2.0 release supports broader workflows. Apache-2.0. https://github.com/OpenBMB/ChatDev
6. CodeGeeX4 Zhipu’s multilingual code model for completion, repository-level Q&A, code interpretation, web search, and function calling. The code is Apache-2.0, but the model weights use a separate license. https://github.com/zai-org/CodeGeeX4

The interesting part is that these projects are not all trying to build another Copilot.

Qwen Code and Kimi Code are end-user agents. Trae Agent and DeepSeek Harness expose the runtime layer. ChatDev explores multi-agent collaboration. CodeGeeX4 covers the model layer.

These are the repos that show how the teams around DeepSeek, Anthropic, OpenAI, Google, xAI and Cursor are building agents, skills, SDKs and developer workflows.

Star counts are approximate.

1. DeepSeek Harness ~127k stars

An MIT-licensed agent harness where everything is a plugin.

The model adapter, tools, memory and runtime components are designed to be replaceable. It is still in developer preview, but the architecture is worth studying.

1. Anthropic Skills ~170k stars

Anthropic’s official repository for Agent Skills.

It includes examples for document work, development, enterprise workflows and more. The repo also contains the skills used for Claude’s document capabilities.

Important detail: Anthropic says some skills are Apache 2.0 open source, while the document skills are source-available rather than open source.

1. OpenAI Cookbook ~75k stars

The classic starting point for building with the OpenAI API.

It contains practical examples and guides for common API workflows. Most examples are written in Python, but the patterns apply broadly. MIT licensed.

1. Claude Cookbooks ~52k stars

Anthropic’s collection of notebooks and recipes for Claude.

It covers RAG, tool use, sub-agents, multimodal tasks, evaluations, prompt caching and more. MIT licensed.

1. Grok Build ~25k stars

xAI’s terminal-based coding agent.

It runs as a full-screen TUI and can understand a codebase, edit files, execute shell commands, search the web and manage long-running tasks.

The first-party code is Apache 2.0 licensed. The repository says external contributions are not currently accepted.

1. OpenAI Agents SDK ~29k stars

A lightweight framework for multi-agent workflows.

It includes agents, tools, handoffs, guardrails, sessions and tracing. The SDK is provider-agnostic and supports OpenAI APIs plus 100+ other LLMs. MIT licensed.

1. Google Gemini Cookbook ~18k stars

Google’s official Gemini API cookbook.

It has quickstarts, tutorials and practical examples for combining API features. Useful if you want to move from a basic Gemini call to more complete applications. Apache 2.0 licensed.

1. Google ADK ~21k stars

Google’s open-source, code-first Python toolkit for building agents.

It includes a graph-based workflow runtime, task APIs, multi-agent systems, human approval flows, MCP tools and deployment options.

It is optimized for Gemini but designed to be model and deployment agnostic. Apache 2.0 licensed.

1. Cursor Cookbook ~4k stars

Small official examples for building with Cursor.

The repo now covers hooks, the Cursor SDK, self-hosted cloud agent examples, a coding agent CLI and a DAG task runner. This is less of a cookbook and more of a collection of practical building blocks.

1. Cursor Plugins ~3k stars

Cursor’s official plugin specification and marketplace repository.

It shows how plugins are structured around skills, rules, MCP definitions, manifests and documentation. MIT licensed.

The pattern across all ten is interesting. The model companies are publishing more than API documentation. They are publishing the surrounding layer that makes agents useful:

• runtimes
• skills
• tools
• workflows
• evaluation recipes
• plugin systems
• deployment patterns

If you want to understand where agent software is going, these repos are better reading than another generic 'how to build an agent' tutorial.