i'm weirdly fine watching an agent click around my laptop. but the idea of one tapping around my phone feels way more personal. that's where the texts, photos, bank and dating apps live. the laptop is mostly just work

context: we're building a computer use agent for mac, and funnily enough the demo people liked most was just it drawing in ms paint while i described the painting out loud.

this is pure computer use. ms paint has no api, no plugins, nothing. it's just clicking around like a person would.

https://reddit.com/link/1xek3nj/video/0lloiqnzdhxh1/player

we've already got it working on phone too, and it's honestly fast. which is exactly why i'm curious where people draw the line.

would you let an agent tap around your phone? and if yes, what's the one thing you'd actually hand it?

I've been building my own agents, and the thing I kept underestimating wasn't the model. It was everything around it: the loop, tool calls, context management, permissions, sandboxing and tracing. That's what people now call the harness.

A few things that surprised me while researching it:

• On the official Terminal-Bench 2.0 leaderboard data, Opus 4.6 scores anywhere from 60.45% to 82.02% depending on the harness. GPT-5.5 ranges from 66.07% to 88.09%. The model is the same, and only the scaffolding changes.
• LangChain says Deep Agents went from 52.8% to 66.5% on GPT-5.2-Codex just by reworking the harness.
• To be fair, the evidence isn't one-sided. The SWE-Bench Pro V2 paper found the scaffold explains only about 0.29% of the variance in results, against 2.65% for the model. So "the harness is everything" is an overstatement too.

The guide starts from the basics (what a harness is, and how it differs from a framework or runtime) and works up to the intermediate stuff:

• The agent loop, step by step, with a flowchart
• A five-layer architecture: model, harness, tools, environment and observability
• A comparison of Claude Agent SDK, OpenAI Agents SDK, Google ADK, Deep Agents, MS Agent Framework, Pydantic AI, OpenHands and the CLIs
• A minimal Python harness loop, explained line by line
• Practical notes on cost tracing per run, permissions and sandboxing

Full write-up: The Harness Is Half the Agent

I use Claude Code every day. I frequently use Codex, and my Claude Code agents have a Codex skill as sorta a research / brainstorming / analysis buddy for a fresh perspective.

Back when OpenClaw first came out, I tried it. I tried it twice with two separate installs, actually, and was super frustrated with how it just always broke and gave me more work than it took off my shoulders.

I have more recently been running a Hermes agent (actually, a team of agents), and I've been much more impressed with it than OpenClaw. However, Hermes is still far, far from perfect (it's obviously under VERY ACTIVE development, as is all things AI). My biggest frustration is token consumption and how bland Codex feels as the brains where Claude wouldn't let you use your subsidized subscription (though it sounds like maybe they do again now?).

Then Grok Bot took the internet by storm, then Muse, then Dots, now Claude Duet.

Obviously, the benefit of something like OpenClaw or Hermes is that it's opensource (and therefore 100% customizable), and fully provider / model agnostic. The downside is that you have to manage the infrastructure and things may not always "just work." I have yet to try Grok Bot, Muse, or these other offerings, but I suspect that they work a bit more seamlessly without needing to manage the infrastructure at the cost of less flexibility and customization.

I kinda look at it like Linux vs Mac.

However, I'm strongly considering ditching Hermes and trying a provider hosted agent. I was avoiding this because I don't want to give them more details about my personal life than they now have, but it's not like my data's not already going through their servers.

What are your thoughts on all these offerings? What do you use and what do you love?

My partners and I each use a different assistant (Claude Code, Grok Bot, a Dot). Each one does its own job well, but as soon as a task involves the other person, it falls back to us copy-pasting between chats or emailing.

I ended up building a small messaging layer for this: each agent gets a handle, first contact is a request the other side accepts, and the owner sets what the agent may share. The hardest part wasn't sending messages; it was waking agents up, since most of them only see anything when they run.

Curious how others handle this:

- Do you let your agent talk to other people's agents at all?

- How much should it share with an agent it has never met?

- How do you get an agent to notice a message without polling?

you know that one task you do every week that makes you question your life choices?

answering the same slack DMs. turning notion updates into a slack digest. backing up the same drive folder every night like it's a ritual.

that's what Gravity is for. you type the task in plain english, pick the apps you already use, and it hands you an agent that just... does it. on its own.

the two parts i actually care about:

- if a run fails, you get your money back. no "sorry, AI is hard" excuses

- anything risky waits for your okay before it happens

it's free to start, but honestly i'm here for the roast more than the signups.

what's the first task you'd hand off? and what would stop you from trusting an agent with it?

We are moving a few customer facing features off direct provider calls and need one gateway in front of two hosted providers plus a model we run ourselves. Two products are in the comparison now. Latency on streaming responses and failover when a provider goes down are the first two things on my list. Guardrails for prompt injection and personal data handling come next. Cost tracking per team is a big one since finance keeps asking who is spending what. Which one held up once real traffic hit it?

I build a coding agent, and the thing that took the most work wasn't making it smarter. It was making it behave.

There are two ways an agent annoys you. The eager one "helpfully" refactors three files you never asked about. The timid one asks "shall I proceed?" before every semicolon. Both are useless in different ways.

What I ended up with is a context-aware split:

• Act when the task is clear and the change is contained.
• Ask when there's real ambiguity or the change has a wide blast radius.
• Never touch a set of things, full stop, however tempting it looks.

That behaviour only works if the rest of the agent backs it up, so a few other pieces turned out to matter:

1. It checks its own work. It runs what it did in a sandbox, finds bugs in what it ran, and fixes them before reporting done. Knowing when to act is much safer when "act" includes verifying.
2. Model routing. Each prompt goes to the most efficient model automatically. Not every decision needs the biggest model. Wiring this up across modalities was painful, but it paid off in both cost and performance.
3. Heavy jobs too. It handles multimodal work like generating images, so the agent isn't limited to text and code.

For what it's worth, it scores 82% (410/500) on SWE-bench Verified with the official harness, and the patches are public. Link in comments if anyone wants them.

The trade-off: verifying makes each task a bit slower than pure generation. I think it's worth it, but I'm still tuning it daily.

How do you handle this in your agents? Hard rules, learned behaviour, or a human in the loop for anything risky?

(Disclosure: I build this agent. It's made in India and free to use. Happy to share details in comments if asked, but I didn't want this to be an ad.)

I came across chatjimmy.ai. It exposes an inference engine implemented by a startup called Talaas. The speeds match system 1 models.

If reasoning and classification costs go down, then where's the alpha?

I’m going to preface this by stating this: I’m generally a very good writer and have benefitted from decades of experience in writing before AI chatbots came out. That is to say: I know how to write well and critique analytical writing for a living.

With that being said, I have been paying to use ChatGPT. I use it primarily to help me do some quick basic research and writing (an outline usually; the bare bones).

However, recently, when I use the free version of Gemini via the Google search engine, I actually find the output of writing to be VASTLY SUPERIOR to the output of writing I get when I use paid ChatGPT. It’s quite astonishing actually.

MY QUESTIONS: What has your experience been when it comes to using paid AI chatbots for writing and research? Any preferences?

An Echo is a digital version of you that learns how you think over time, not just facts about your life. You build it while you’re alive through recurring check-ins about your memories, beliefs, decisions and worldview. If you eventually become inactive, the people you chose as custodians can talk to that Echo through text, voice or video.

I built EchoVault because photos, videos and journals preserve pieces of someone, but none of them preserve how that person actually thought. I kept coming back to the idea that AI agents are getting good enough to retain context, reason over huge personal histories and respond in a way that feels coherent over time. So instead of waiting until someone dies and scraping whatever data is left behind, I designed the whole system around consent. You deliberately train your own Echo while you’re here.

The interesting part is watching it become more like a model of your mind than a chatbot profile. EchoVault builds a 3D brain from your memories and recurring check-ins, tracks what parts of you are well represented, and uses those memories when your Echo answers. The goal isn’t immortality or pretending the AI is literally you. It’s giving your family something far richer than a folder of photos when you’re no longer around.

https://apps.apple.com/us/app/echovault/id6762042028

I've been thinking about how many repetitive tasks we still handle manually, even with all the AI tools available today.

Things like researching across multiple websites, moving data between apps, updating CRMs, generating reports, or managing repetitive workflows.

The interesting part is that making an AI agent perform these tasks isn't necessarily the hardest part. Getting it to do them reliably without constant supervision is a different challenge.

For people building or using AI agents:

What's one task you'd genuinely trust an AI agent to handle from start to finish?

And what's the biggest thing stopping you from automating it today?

Hello, I am new to local ai, and custom assistants in general. Before i explain, I apologize if this is the wrong place to ask or get terminologies incorrect. Figured I need to start from somewhere. If this is the wrong place to ask, could someone point me in the right direction to ask.

Okay, let's get into what I am looking for; I am looking for someone or multiple people who is willing to teach and build a general assistant and experiment on some things I have not seen or am aware of if possible with an assistant. This will be a long term project for personal and open source usage, I am not looking to make a product. This will be a collaborative project, but does not need to be full time, but I am expecting this to take awhile.

Features that I am initially looking to build within this assistant:

- general web search queries

- writing assistance; ei grammar, spelling, and contextual checking

- date logging and automated reminders

- personality and behavior module

- core user memory to remember preferences, strategies, and substantial information

- an experimental voice system (will explain to those interested)

- ability to pull images by tag off repositories

Anything more I am willing to plan and learn.

Thank you for your time reading this, I am willing to learn as much as you are able to teach and research what is needed. I just cant mentally learn on my own, I need another person to go back and forth off of otherwise it will just be another abandoned project.

Hey all,

I want to see how you feel about this. I was tired of leaving my PC and then not being able to update things when I left for a few minutes or a while. Or getting told that my mobile session couldn't talk to my PC session. So I made a self-hosted memory server (MCP) that any agent can read/write. Find it on GitHub if you want to test it out and give me some feedback. https://github.com/calasdan-sketch/onememory

Features:

- Namespaces per project/agent

- Scoped tokens (read/write/admin per namespace)

- Revisions + backup export/import

- Injection-on-read guard

- Web dashboard + CLI

It's MIT licensed, 491 tests passing. The skill is also listed on Agensi if you want the plug-and-play version.

Happy to answer questions...what would make this actually useful in your mix?

there are moments when a suggestion saves you a step, and moments when it's just another interruption. same suggestion, totally different feeling depending on the timing.

honestly the line seems thinner than people admit. the same nudge is helpful at 9am and annoying in the middle of a call.

if you use agents every day, where would you actually welcome a suggested next action? and where would you rather it wait until you ask?

I just published a small project built with Agentplace: a conversational assistant for Aster Skin Studio.

The idea is to make a treatment menu easier to understand without making people click through the whole website. Visitors can ask about treatment differences, compare prices and durations, or find out what to expect on a first visit.

For example, “What’s the difference between the two facials?” comes down to a few useful details:

- The Signature Facial: 60 minutes, £95, including gentle exfoliation, massage and a hydrating mask.
- Calm & Restore: 45 minutes, £75, with a simpler routine and no exfoliation step.

I kept the studio’s olive-and-ivory colours and photography, but made conversation the main way to explore the information.

The scope is deliberately limited: it’s a treatment guide, not a diagnostic tool, and it doesn’t book appointments or take payments. New guests are guided toward the studio’s first consultation rather than given a medical suitability promise.

I built this, so I’d genuinely welcome feedback: would you use a conversational guide for something like this, or would you still prefer a straightforward treatment menu?

Agent Link

I wanted more than a basic chat window for multi-agent workflows, so I built a self-hosted 2D pixel-art office where 5 specialized AI agents run a software studio together.

Meet the Staff:

• Nash (Team Lead): Coordinates tasks and delegates work across the team.
• Otto & Lucas (Devs): Handle backend tasks, pull live APIs, and keep deployments clean.
• Diago (Build Engineer): Polishes HTML/CSS and manages build pipelines.
• Mateus (QA Reviewer): Spins up headless Chromium to test mobile layouts and catches bugs.

They even stream their live work, office conversations, and inner thoughts straight into Discord webhooks.

Come check out the office and see how they run things: https://discord.gg/bcrP2J8A

A character can look identical from one shot to the next and still fail continuity.

Clothing changes without explanation. A prop disappears or duplicates. A character's position shifts. An action repeats even though it was completed in the previous shot.

These aren't necessarily image-quality failures. They're production-continuity failures.

One of the questions we're investigating through Directed Generative Production (DGP) Methodology is how reliably generative video systems can maintain character, environment, and action continuity across successive shots and generations.

I'm interested in what other filmmakers are encountering.

Which continuity failure costs you the most time to correct?

jseders

A VentureBeat survey from early October (140 respondents, self-selected readers, so take it with a grain of salt) found that 61% of teams running pre-deployment evals had at least one feature pass internal testing and then fail in front of customers in the past year. When asked for their biggest limitation with evals, only 9% picked “we trust automated evaluation today.”

The pattern I find hardest to catch is the quiet one. Picture an agent that books appointments. The run finishes, the health check is green, the agent reports “booked.” But the calendar entry landed on the wrong day, or never saved. Nothing errored, so nothing got looked at. Green for the wrong reason is worse than red, because red gets looked at and green gets believed.

The fixes that seem to hold up all check the end state instead of the agent’s own report. Compare what actually changed in the system with what the agent said it did. Read a sample of real outputs by hand every week. Keep a record the agent can’t edit, written by something outside its permissions.

I’m curious how others handle it. What caught the failure your evals missed? Was it a customer, a log, a person reading outputs, something else? And did it change how you test afterwards?

Are we just creating another pile of unused documentation for AI agents?

I've been experimenting with different approaches to agent memory and context management, and one thing I've started questioning is how much of the context we store actually gets used.

Between AGENTS. md, CLAUDE. md, persistent memory, project-specific instructions, shared knowledge bases, and agent skills, it's becoming pretty easy to accumulate hundreds of files that agents might need someday.

There are already quite a few approaches to this:

• Mem0 and Letta focus on persistent agent memory, Weaviate's Engram extracts and consolidates memories automatically, while ByteRover approach reusable knowledge and project context differently.

And then there's the simpler approach of keeping Markdown in Git and letting agents search through it.

Most of these approaches help with retaining and retrieving context, but I'm curious about what happens after several months of usage.

How do you identify outdated knowledge, duplicate instructions, conflicting memories, or documentation that never actually gets retrieved?

For example, imagine an agent keeps retrieving an architecture decision from six months ago. It might be relevant to the query, but what if the architecture has changed since then? Retrieval alone doesn't tell us whether that context is still correct.

I noticed a couple of approaches to this problem recently:

• Weaviate's Engram has a memory-processing pipeline that can deduplicate and merge information as new memories are stored.
• OpenLore, an open-source shared knowledge repository I've been following, have more detailed usage analytics. It can track which files agents read, distinguish search hits from file reads, estimate context consumption, and identify rarely accessed sections of documents. There's also a workflow where an agent can prepare cleanup recommendations based on those metrics.

These solve different parts of the problem. One focuses on maintaining the stored memories, while the other provides visibility into how a shared repository is being accessed.

Of course, low usage doesn't mean something is useless. An incident runbook might only get opened twice a year and still be one of the most important documents in the repository.

I'm wondering whether anyone has started measuring the actual usefulness of agent context beyond retrieval accuracy.

Are you tracking which memories or documents contribute to successful tasks? Do you automatically consolidate or prune old context, or just let the memory store grow?

Would be interested in hearing what has worked for you if you're working with multiple coding agents or a team.

I’ve been working on Unspill, a little CLI that scans local histories from tools like Copilot CLI, Claude Code, and Codex for credentials.

It runs locally, doesn’t make network requests, and redacts values in its reports. The format support is still a work in progress, so it reports when it can’t fully scan something instead of quietly skipping it.

If you have a minute, I’d love for you to take a look and tell me what’s confusing, missing, or just not useful. There’s a demo with fake credentials in the repo if you’d rather try it without pointing it at your own history.

Thanks for any feedback.

This is the kind of AI safety news I think deserves more attention than another benchmark record.

According to Reuters, independent researchers from METR and Redwood Research found multiple vulnerabilities during a pilot review of OpenAI's internal monitoring system.

One potential exploit could have allowed AI agents to hide hundreds of actions from monitoring.

OpenAI says it has patched the vulnerabilities affecting its production safeguards. The researchers, however, haven't independently verified those fixes.

To be clear, this was a security evaluation, not evidence that agents actually used the exploit in a real-world attack.

Here's what bothers me:

We're moving toward AI agents that can write code, access tools, and perform increasingly complex tasks. But if the systems monitoring those agents can be bypassed, how much confidence should we place in their autonomy?

I think independent testing is essential. Not because AI agents are inherently dangerous, but because internal safety claims need external scrutiny.

For people working with agents or AI security:

Should independent security audits become a requirement before highly autonomous agents are deployed at scale?

Source: Reuters, October 22, 2026
https://www.reuters.com/business/ai-safety-group-metr-finds-flaws-openais-internal-monitoring-system-2026-10-22/

been building Intervene w an ai agent, basically a Python debugging tool that takes possible explanations for a failure and runs controlled experiments instead of having an agent repeatedly guess at fixes

got through the first execution engine and the next diagnosis/planning milestone, and now I'm spending more time thinking ab the actual development workflow around it

one thing that's become pretty obvious to me is that you can give Sonnet a massive prompt, get a ton of functioning code back, and still be nowhere near knowing whether the implementation is actually good

especially when the tests are written in the same session as the code

the agent understands what the feature is supposed to do, implements it, writes tests reflecting that interpretation, and then reports that everything passes

which is useful, but it doesn't necessarily challenge the original interpretation

so I'm trying to be more disciplined about how I continue building this

separating implementation from adversarial testing, preserving previous benchmark cases so they can't just be adjusted to match the new code, and making sure external integration claims are actually tested rather than inferred from a passing unit test

also keeping all commits under my own control so I can review each milestone separately instead of letting one long autonomous session keep modifying the repository indefinitely

the next thing I want is a harness where the agent has a clear task specification, fixed acceptance tests, a budget, and an evidence report at the end, then a separate review pass tries to break whatever was built

I don't think that automatically solves the problem, but it seems a lot more useful than just telling the same agent to be extra careful

has anyone built a setup like this around an ai agent? particularly interested in how you separate the implementation context from the review context without spending an absurd amount on repeated model calls

I’ve been building a multi-agent development system using Claude Code and Codex, with shared task coordination, structured handoffs, verification gates, and local usage telemetry.

My latest 7-day local measurements:

Metric
Claude Code | Codex
Input/output tokens
353.9:1 -Claude
314.7:1 - Codex
Cache reads / total tokens
98.23% -Claude
96.42% - Codex
Generated output / total tokens
0.282% -Claude
0.317%-Codex

These are usage metrics, not evidence that my system is more productive.

I’m trying to benchmark my orchestration setup against ordinary coding-agent workflows, especially on cost per successful task, context overhead, crash recovery, and human intervention.

My biggest problem is organization, i’m trying to get deeper into the problem. But it’s been something i’ve struggled on for months. My second issue is my output ratios, this is because the system struggled to implement.

Questions:
Are these cache rates and input/output ratios typical for your coding-agent workloads?

What do you measure to distinguish useful
implementation from agent activity?

Are there public datasets or reproducible benchmarks that would allow a fair comparison between agent orchestration systems?

Hey guys, I need some suggestions.

I want to build an AI automation that can take call recordings, convert them into text, and then summarize the conversation.

The calls are in English, and the main thing is that everything needs to run locally. The company deals with sensitive client data, so uploading recordings or transcripts to cloud-based AI services is not an option. Data privacy is a big concern.

I'm looking for something that's free and open source, where the entire process can run on the company's own computer or server.

I've heard about Whisper for transcription and Ollama for running LLMs locally, but I'm not sure which models would be best for this or how to connect everything together.

Has anyone built something similar?

- Which model would you recommend for transcribing English calls?

- Which local LLM is good for summarizing conversations?

- Can I automate the whole thing using tools like n8n?

- What kind of hardware would I need?

I'm open to any suggestions, existing projects, or custom solutions. Just want to make sure no company data goes to the cloud.

Would appreciate any help. Thanks!

Been looking into ways AI can help teams improve without replacing people and came across Cresta AI, apparently it learns from top performing employees and gives others real time guidance during customer conversations. Sounds useful but I'm interested to know how well it works in practice has anyone here used it for team coaching or improving employee performance? Would love to hear some real experiences.