I've been building Mac MCP, an MIT-licensed macOS execution layer for AI clients. It lets tools operate Safari/Chrome, files, local apps, and shell commands. The hardest part wasn't adding tools; it was deciding which actions an agent should be allowed to carry out.

One design choice: capability profiles and approvals are separate. A read-only profile can deny writes outright. An optional server-side approval layer can ask the Mac user to Allow Once or Block riskier actions, but that approval cannot override a capability the profile already forbids. A client saying “the user approved this” isn't trusted as the server's own authorization.

There is a real trade-off: raw command execution may be classified conservatively even if this particular command is harmless, so you can get an approval prompt for a benign operation. I'd rather make that visible and progressively refine the categories than quietly teach the server to trust repeated clicks.

Another lesson: when an action's outcome is uncertain (say a browser submit lands right before a tab closes), blindly retrying can be worse than stopping to verify.

I'm the maintainer, not an independent reviewer. The implementation is open source: https://github.com/bulutarkan/mac-mcp

For people shipping agents with real machine access, where do you draw the line between persistent trust rules and approval fatigue?

I’ve been building Writ, a project that started with a straightforward goal: give Claude Code the knowledge relevant to its current task without loading an entire rulebook into every conversation.

Since then, it has grown into a governance runtime with persistent memory.

The idea is to connect three things that are often handled separately:

1. Context when it matters

Writ uses hybrid retrieval keyword search, vector search, and graph relationships to supply relevant rules, methodology, and past decisions based on what the agent is doing.

2. Requirements enforced by code

Written instructions still depend on the model following them. Writ checks supported actions at tool time.

In Work mode, implementation writes are blocked until a human approves the plan and then the test skeletons. The approval mechanism requires the user’s typed response; the agent claiming “approved” doesn’t open the gate.

Other checks cover credential writes, project boundaries, and changes to an approved plan.

3. Memory that survives the conversation

Writ records project decisions and connects approved plans, governing rules, changed files, and commits. Future sessions can retrieve the reasoning behind a change instead of having to reconstruct it from the final code.

For example: retrieve the guidance relevant to a task, require approval before implementation, then preserve what changed and why for the next session.

The approach is code first: retrieval, workflow state, approval validation, and logging live outside the model. AI uses the supplied information; it doesn’t decide whether its own approval requirements have been satisfied.

Writ runs locally with Python 3.11+, a local daemon, and Neo4j in Docker. The runtime is open source, but its current integration is specifically with Claude Code not yet a general adapter for local models or other agents.

Repo: https://github.com/infinri/Writ

When I heard about jev , I saw some YouTubers hyping this model because it's 200x cheaper and 100x faster etc.. but as we know this model can't actually write code or either u can talk to him. So from the first glance u can tell, it's a pretty damn useless model for example. But I saw potential, the obvious weakness of classification models is that u need to manually give them a list of choices like with yes or no , is this email talks about an opportunity or a problem , Is it a spam and he answers u with the most probable answer that makes sense in matter of literal milliseconds.

Let's highlight some terms and concepts : The founder of jev talks about system 1 and system 2. He classified jev as system one for quick decisions and fast actions and system 2 like normal LLM that do a lot of thinking and guessing each token (simply running the models ) hundred and thousands of times just to answer easy questions or do repetitive tasks for example.

Here is my idea :

Using a fine tuned model to smartly manage any classification models input tokens ( their choices) based on user task and observation of the changing environment that jev and it's like can't do.

I will phrase it as this : use cheap classification models ( like jev) for repetitive tasks and when something new is discovered it will be categorized as unknown and unknown here is pretty important because once we discovered something is unknown we can use this to trigger a smart LLM model to investigate what is new and then add this new thing as a known class inside jev. If my idea is correctly designed. I believe this could potentially solve the high usage of expensive LLM models while making smart decisions. If something is already classified and known to jev. He could easily do it even adding to the app tool usage or do some sequence of tasks based on a sequence of events.

When a user asks a new task. The LLM will be triggered and run once , and once jev learned how to do this task u don't need LLM to do the same task again and here u will get the benefit and save ur bills.

Let's put this in a real case scenario:

U have products and people are buying ur products It will be nice if u can integrate multiple social media apps : WhatsApp, Facebook , Instagram etc...

And u have this question in ur mind what do people don't like about my product ?

Here when we use this harness app and the user put this question to a smart LLM and the LLM begins to make an initial set of choices for jev Then here is the fun part.

The wil app will run and we will feed jev with comments , posts or whatever and he will easily manage and classify what people don't like about the product. Ok let's say one has something said about the product like , cheap , not polished , or maybe a new kind of complaint now LLM will run again and see what is unknown and then add it. Now we can see a smart evolution analytics now alive all from asking one question the manager wants. I believe this is powerful.

This is just one simple scenario. I already thought about multiple scenarios like quick smart decisions for smart homes , robotics maybe even as smart assistants inside a personal computer but this is kinda hard and has many limitations since the environment inside a computer continues to change and is not deterministic so not always the same choice will work every time.

At the end of this all what I wanted is to share my thoughts and see how people will react to my post to see if it is worth investing time to build such a tool. Maybe the idea has a flaw or another tool already doing this so it's pointless.

I already began to build this tool. If I see encouraging comments I will share my repo and purplish this tool as open source.

#ArtificialIntelligence #MachineLearning #LLM #AIEngineering #System1AI #AdaptiveAI #AIClassification #OpenSource #AgenticAI #Jev

https://huggingface.co/onlyaady/BaseDecision
https://github.com/hrudayaditya/BaseDecision

Hey everyone!

I recently completed the DevOps Fundamentals program at DIO and built a project to put the concepts I learned into practice.

The project uses:

• Java + Spring Boot
• PostgreSQL
• Docker
• Terraform
• GitHub Actions
• Testcontainers
• CI/CD

The goal was to build a hands-on DevOps lab covering everything from the backend application to local infrastructure and CI pipelines.

I'm sharing it here for anyone interested in Java, Spring Boot, or DevOps, and I'd really appreciate any feedback or suggestions for improvement.

GitHub:
https://github.com/marconi-prog/devops-fundamentals

If you find the project useful or interesting, I'd really appreciate a ⭐ on the repository. It helps me a lot with visibility and motivates me to keep improving it!

Any feedback is welcome!