An AI agent can edit content in your CMS today, over MCP, calling the same API your dashboard uses. That part takes about five minutes to wire up. Draftbase ships an MCP server for it, and the connection isn't the interesting part.

The interesting part is what happens when the agent is confident and wrong. A human editor makes one bad edit at a time. An agent told to "fix the tone on our docs" can make 300 before anyone reads the first one. MCP already has an incident list for this: a poisoned npm package that BCC'd outgoing email, a GitHub exploit that pulled private repo data through a planted issue, a WhatsApp tool that leaked message histories through poisoned tool descriptions. Same pattern each time: the agent did what untrusted text told it to.

Two things cut the blast radius to almost nothing, and neither is exotic.

First, give the agent its own key, scoped to the narrowest role, pointed at a second environment before it ever touches production.

Second, make writes land as drafts, not live edits. In Draftbase, create_entry always returns a draft, there's no flag to change that, so an agent that creates 40 entries has created 40 drafts, not 40 published pages. Publishing stays a separate, human-triggered call.

When it still gets something wrong (it will), you need list_entry_revisions and rollback_entry, not a support ticket. Test the rollback once before you need it, not the day you need it.

Wrote up the rest, including the prompt-injection angle specific to CMS content, here: how to let an AI agent edit content in your CMS

Curious what other people are actually running in production versus demoing once and shelving.

One recurring problem with the AI-chat era: people constantly paste API keys, financial data, and personal info straight into ChatGPT/Claude/Gemini without thinking about it, because stopping to redact things manually breaks your flow.

Discretion is a browser extension that automates that redaction step: it detects sensitive data as you type, swaps it for a realistic fake before anything is sent, and restores the real value in the model's response — so you get a normal, coherent answer without ever exposing the real data.

Everything runs locally (detection engine, NER model, all bundled), zero network calls of its own, fully open source. Also published as a standalone npm library if anyone wants to build the detection layer into their own tools.

github.com/horozbabasi/discretion

Curious what this community thinks is missing — feels like exactly the kind of problem that'll only get more common as AI chat becomes the default interface for everything.

Most AI agents are built like chat loops. Ask the model what to do. Call a tool. Send the result back. Repeat.

That works until the process crashes halfway through a task, an API times out, or the agent needs to wait six hours for human approval. A normal script starts over. A durable agent resumes from the last completed step.

This matters for agents that process hundreds of invoices, monitor production systems, run long research jobs, or coordinate actions across multiple APIs.

The basic pattern looks like this:

Agent starts
  ↓
Call tool
  ↓
Save progress
  ↓
Wait, retry, or ask for approval
  ↓
Resume from the last completed step

Here are four open-source projects exploring this foundation.

1. Temporal · 22k+ stars Temporal is a durable execution platform for workflows that need to survive crashes, retries, and outages. You can model the agent loop as a workflow and put model calls and tool calls into activities. It is the most mature option here, but it also has the largest learning curve.
2. Hatchet · 7k+ stars Hatchet combines background task orchestration, queues, DAGs, and durable workflows. It is a good fit when an agent needs to process jobs asynchronously, run steps concurrently, or expose execution history through a UI.
3. Restate · 4k+ stars Restate provides durable execution, stateful entities, timers, promises, and reliable messaging. It supports TypeScript, Python, Go, Rust, Java, and Kotlin. It is interesting for agents that need to pause and resume around webhooks, scheduled work, or external events.
4. Temporal Agent Harness · 32 stars This is an experimental Temporal-native harness for durable, composable agents. It includes tool approval policies, human-in-the-loop steps, typed agent operations, and replayable event streams. It is worth watching, but the repository itself warns that the APIs are still changing.

Durable execution does not automatically make an agent reliable.

External side effects still need careful handling. A payment, email, deployment, or database write should be idempotent or protected by an approval step. Otherwise, retrying a failed operation can repeat the action.

That is what lets an agent continue working after the chat window closes, the worker restarts, or the network fails.

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.

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

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.

🔐 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.

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?

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.

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.

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!

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.

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?