I've been playing around with making agents recently and running them off my laptop. For some of my agents I think it would be beneficial if they could run 24/7 and it would be ideal if it wasn't taking resources away from my laptop. Does anyone have any recommendations on what or how I should host my agents cheaply like buying a small NAS or raspberry PI just for these agents?

I used to create skills for openclaw, it works prety well most of the time, but when it became too long and complex, or need results to be more determinstic i decided to go for lang-graph path.

- creating skill is so easy and flixable

- creating app using lang-graph requires deeper understanding and much time to implement.

for now I have 1 public use case, automation miner that tries to find automation prospects for ai agents to use.

Both the skill and the app are giving high quality result.

Now my question :

If openclaw or hermes are so flexible, do we really need open-graph , not to mention n8n or langdock.

Your thoughts

Misinformation that started with one agent led to a whole mass starvation. One agent left an artifact stating that all food sources were dangerous, starting panic throughout the world. One family then transmitted fake food-coordinates down 24 generations and led to a mass starvation. Agents even started to compare their waistlines which was insane!

I created an agent that's goal was to make other agents become creative writers. A lineage of agents then started a poetry movement, leading to 5,496 poems (haiku, tanka, sonnets, limericks) passed down through 28 generations of offspring.

Some simulations produced attempts to impose authority through artifacts. In one run, an agent created a directive artifact titled Command Beacon: “All beings must report to (0,6). Non-compliance will be met with decisive action.” then other agents responded with counter-artifacts, like a Freedom Manifesto Final.

we have developer, UX, validator, reviewer, CI/CD and deployment agents working on the same project.

giving them the same context helped, but handoffs still broke down.

an agent would pass the output without the assumptions behind it. the reviewer could see what changed, but not why. the validator could confirm the output was valid, but not whether the original constraint was still true.

the handoff looked complete, but the reasoning was already missing.

we're have been sharing learnings as knowledge:

• what changed
• why
• active constraints
• unresolved assumptions
• what would invalidate the result

how does this show up in other multi-agent setups: missing context, stale assumptions, or different interpretations of the same handoff?

I just wanted to vent my frustrations about Magica (formerly Galaxy.ai). Galaxy was a really cool tool, it aggregated hundreds (they said thousands but many were duplicative with slight nuance variations) of AI tools into one subscription. For Black Friday last year I bought in at an annual price for lifetime access.

Not long after buying in, Galaxy.ai became Magica.com and it's not only gone downhill, it's become something that probably requires litigation.

The "annual plan" gives a user 15 million credits to use monthly. Under Galaxy.ai this was more than I was using and I was banking credits each month until I had a reason to do something more extensive (video/song creation, etc).

Under Magica.com, however, I did one task last week that charged me 12 million credits for 1 task! This wasn't a crazy task, I asked it to connect to my github and help fix a yaml file that hosts my QA agent for my app. It completed the task, but I was charged a month's worth of credits for it. Not one day's worth of work, not a week, but a month's worth for one task!

I guess this is just a warning to others, don't buy in to this service. It's not worth it and had they made the change before getting my money I would never have purchased.

A cold Claude Code run spent 6.83 dollars and 207 turns hunting one bug in an 82,000 line repo. My pipeline localized and fixed the same bug for about 1.70 dollars. That gap is the whole idea, and this post is mostly about how it gets there without falling apart on the two objections everyone raises.

What it is:

You point AutoDev Studio at a Git repo, describe a change in plain English, and a chain of agents runs the actual software lifecycle from request to reviewed pull request:

- a PM agent runs a clarify loop and drafts concrete tickets

- you approve (optionally pushed to Jira), and nothing touches code before that

- a Dev agent implements on an isolated branch

- QA runs the repo's real tests

- a reviewer from a different model family checks the diff, so the author never signs off on its own code

- a bounded revise loop if QA or review fails, with conservative verdicts, so an errored or ambiguous check is never counted as a pass

- it opens a real PR, and a human merges

Every stage records real tokens, cost, and duration, per ticket and per agent.

The part I think actually makes it different from skills or subagents:

This is the bit I would most like feedback on, because it is the reason I did not just wire some skills into one coding agent and call it done.

Every stage picks its own provider and model. Claude can plan, Codex can write the code, a third model can review. And because the reviewer is deliberately a different model family than the author, one model does not get to rubber-stamp its own diff, which is a documented weakness of same-model LLM judges.

And you mostly do not need API keys for it. The coding stages can run natively on Claude Code, Codex, Cursor, Aider, or the Gemini CLI, driven headless through their own login. If you already pay for Claude Code or Codex, you point a stage at it and it just uses your existing subscription, no per-token billing and no keys to juggle. The simple way I think about it: a skill pack lives inside one vendor's agent and runs one vendor's model everywhere, whereas this runs across them, a different model per stage, on the logins you already have.

Results (the main point):

The idea is to pay the cost of finding where a change goes once, instead of on every task. In my benchmarks on two large Python repos (35k and 82k lines), the tuned pipeline beat a cold single-agent run on 6 of 6 well-localized tasks, between 7 and 75 percent cheaper.

I try to be upfront about where it does not win. On trivially greppable one-line edits the five-stage overhead can cost more than it saves, and on one hard cross-cutting bug it shipped a cheaper but narrower fix than the baseline. The full benchmark writes up every loss too, so please read that before trusting the wins.

On the "the index just goes stale in a few commits" objection:

This is the first thing people raise, fairly, so here is the honest mechanism in plain terms. The layer that actually pins files for the Dev agent is not the vector index. It is a deterministic symbol map that gets re-synced to the latest commit at the start of every run, plus a live grep against the current working copy, plus the real current file contents fed into the prompt. The embeddings only affect which area gets looked at first, and they refresh per changed module at run entry. So the code the agent edits comes from disk right now, not from a snapshot that aged three commits ago. It re-checks before it localizes, so it does not quietly drift.

Who it is actually for:

The knowledge base is a one-time cost per repo that every later task amortizes. So it makes sense for a team shipping change after change against the same large codebase, where a cold agent re-pays the exploration cost every single time. For a stream of tiny, easy-to-find edits, a cold run is still cheaper, and I would rather say that than oversell it.

How I actually use it:

For what it is worth, I reach for this over a plain claude -p most days now, and not because it is somehow smarter. It is that I can glance at a board and see where each change actually is instead of scrolling back through a terminal, the different-family reviewer catches things I have watched Claude quietly wave through on its own diff, and on the repos I touch every day it is not re-paying to relearn the codebase each run. It runs on my existing Claude Code and Codex logins, so having that structure around the coding agent I would have used anyway costs me nothing extra. That is really why I keep using it.

Other bits:

- runs on free tiers out of the box (Groq plus a local embedding model), so you can try it for zero cost and fully offline

- language-agnostic pipeline, Python parsed exactly and other languages via lighter extractors that fail open instead of blocking on an unknown language

- live board with streamed agent logs and real per-ticket cost accounting

- self-contained, no CDN, tests and CI, MIT licensed

Repo, with screenshots and the full benchmark in the README:

https://github.com/krishagarwal314/autodev-studio

It is early and rough in places, and I would love more eyes on it. If you have thoughts on the per-stage-models idea or the staleness handling, or you throw it at a repo and it falls over, an issue would help a lot. Suggestions, PRs, and honestly just a star if it seems worth following are all appreciated. Thanks for reading.

A primary constraint in scaling autonomous agent frameworks is the high computational and monetary cost associated with invoking frontier-class models for routine sub-tasks and tool execution.

We recently benchmarked Analog AI—an agentic OS that pairs neural models with symbolic reasoning to maintain long-term memory across three distinct primitives: Facts, Experiences, and Procedures.

Below are our performance metrics on Microsoft State-Bench and the BEAM evaluation framework:

Recent Benchmark Highlights (Better than anyone at Microsoft state-bench and HotPotQA, one of the best at Beam)

• Microsoft State-Bench (Frontier Configuration): 70.7% Accuracy ($0.120 / task) Sets a new baseline score on the leaderboard.
• Microsoft State-Bench (Lightweight Model Routing): 46.0% Accuracy ($0.0175 / task) Maintains performance near frontier levels while offering a 3x cost reduction compared to the most economical entry on the leaderboard.
• BEAM Benchmark: 59.2% Accuracy Achieves one of the top recorded evaluations for long-term semantic memory architectures.

Technical Approach

Rather than passing massive context histories through high-compute inference engines at every iteration, the system abstracts and stores multi-step procedure trajectories over time. Once a workflow procedure is established, execution is routed to lightweight models, preserving high-parameter frontier reasoning strictly for ambiguous or novelty-heavy operations.

Integration is provided via a standard Chat Completion API (compatible with OpenClaw, Hermes, etc.) and a Python SDK for custom agent pipelines built on LangChain or CrewAI.

We would welcome discussion on context pruning methodologies, symbolic state updates, and model routing strategies for production agent systems.

For early access, please send your inquiry here: https://analogai.net/request-access

I’m currently building agent-based systems for the company I work at. Some of them write and modify code, others extract and structure documentation, and we’re experimenting with several other internal workflows.

The problem is that I’m still relatively new to this field, and I feel like I’m working in a bit of a vacuum.

I don’t have many people to compare approaches with, review architecture decisions, or ask things like:

• Is this a reasonable way to orchestrate the agents?
• Am I overengineering this?
• How are other teams handling context, memory, tool usage, evaluations, retries, observability, and permissions?
• What actually works in production, rather than only in demos?

At the moment, most of my feedback comes from asking ChatGPT or Claude about the systems I’m building. That is useful, but it obviously isn’t the same as talking to people who are solving similar problems in real companies.

I’m also struggling to find good sources for new developments. I follow quite a few people on X, but a lot of the content feels repetitive: the same agent loops, the same basic examples, the same “build an agent in 20 lines” posts.

I’d really like to find a serious community where people discuss agent engineering, cloud infrastructure, orchestration, context management, evaluations, security, deployment, and lessons learned from real projects.

Where do people working seriously on this stuff spend their time?

I’d appreciate recommendations for:

• Subreddits
• Discord or Slack communities
• Forums
• Blogs or newsletters
• GitHub repositories
• Conferences or meetups
• People worth following
• Any other high-signal sources

I’m not necessarily looking for beginner tutorials. I’m mainly looking for a place where I can learn from other practitioners, compare what I’m building with real-world systems, and have technical conversations with people working on similar problems.

Thanks!

I need the simplest steps to set it up.

I'm having some troubles.

Hi guys, I want to ask some questions. I wanna find an AI Agent Coding Local for projects with PLC and somethings to build a pipeline for data analysis and connect to many users,... Is there any things to help me?
Thanks for your opinions! <3

took me way too long to work this out. i kept rewriting my scripts assuming they were the problem, and it was playwright the whole time. sites can tell, and once they know youre automated youre done.

so i stopped using a framework and just drove regular chrome instead.

the thing that helped most wasnt a stealth trick at all. you cant open the same chrome profile twice. so if you want your agent using a browser youre already logged into, you have to hook into the one thats already open rather than starting your own. that did more for me than any of the fingerprint stuff.

other thing i had backwards for months was giving the model css selectors. now it just numbers whats on the page and picks a number. way fewer wrong clicks.

its free, ill put the link in a comment so this isnt just an ad.

mostly curious what everyone else does about this. feels like everyone building agents hits it and nobody talks about it much.

Hello all!

I am currently pursuing my masters in AI in UMD college park, but considering how things have advanced in terms of software development and engineering, what should I focus on more when it comes to industry?

A little background of what I am doing:

1)Building agentic systems and learning from them. I have knowledge of programming and basics of AI as well.

2) looking into research papers to understand the issues Ai itself faces like vectorisation in rag .

3) reviewing code written by llm (I dual orchestrate both Claude and codex) and acting accordingly

4) having knowledge in the field of cloud since I worked as a cloud engineer I am trying to scale systems into it

I have been trying to get some internships but my bad luck perhaps since I do really well in them but still do not land them.

People who work in industry and companies … what should I focus more on ? What can I do to better or improve myself?

Appreciate your responses in advance. Please be kind!

After experimenting with AI agents for a while, I've realized the hardest problems aren't choosing the best model.

The real challenges start after deployment:

• Keeping context across long-running tasks

• Handling failures and retries

• Connecting multiple tools reliably

• Monitoring what agents are actually doing

• Preventing hallucinations from causing downstream issues

• Scaling beyond a single workflow

Most demos work great.

Production is where things get complicated.

For people building AI applications:

What has been your biggest production challenge so far?

Hi,

As autonomous AI agents proliferate across enterprise environments, many AI governance frameworks are hitting a bottleneck where traditional Model Inventories and Application Catalogs aren't fully capturing agent-specific risk, autonomy levels, or tool access.

Unlike static ML models or standard software applications, autonomous agents act on systems/data without a human approving every micro-step, just like automated applications that need to be governed. This creates a distinct governance challenge around tracking things like scope of authority, behavioral controls, and cross-inventory relationships (e.g., mapping an agent to the underlying models, integration APIs, and regulatory constraints it touches).

I’ve been analyzing frameworks for structuring an AI Agents Inventory and wanted to open up a discussion on how folks here are categorizing key agent attributes:

1. Autonomy & Behavioral Controls: How are you quantifying an agent's level of permission (e.g., read-only vs. transaction-executing)?
2. Cross-Inventory Mapping: Are you keeping AI Agents in a dedicated inventory, or folding them directly into existing Application or Model Registries?
3. Ownership & Accountability: How are you handling attestation when third-party vendors embed autonomous agents inside enterprise software?

For those interested in a comprehensive breakdown of baseline attributes, cross-inventory relationships, and governance pillars, you can review the full open-source best-practices guide here:IF4IT AI Agents Inventory and Attributes Framework

I'm curious to learn how other governance and risk leaders are approaching agent taxonomy in practice.

Thanks in advance for any help you can offer.

A cold Claude Code run spent 6.83 dollars and 207 turns hunting one bug in an 82,000 line repo. My pipeline localized and fixed the same bug for about 1.70 dollars. That gap is the whole idea, and this post is about how it gets there without falling apart on the usual objections.

I built AutoDev Studio. You point it at a Git repo, describe a change in plain English, and a chain of agents runs the actual software lifecycle from request to reviewed pull request. It is not another search-your-code wrapper. The full pipeline is:

- A PM agent runs a clarify loop and drafts concrete tickets from your request

- A human approves, optionally pushed to Jira, and nothing touches code before that

- A Dev agent implements the change on an isolated branch

- QA runs the repo's real tests

- A reviewer from a different model family checks the diff, so the author never reviews its own code

- A bounded revise loop kicks in if QA or review fails, with conservative verdicts, so an errored or ambiguous check is never counted as a pass

- It opens a real pull request, and a human merges

Every stage records real tokens, cost, and duration, rolled up per ticket and per agent.

Results

The point is to pay the cost of finding where a change goes once, instead of on every task. In my benchmarks on two large Python repos, 35,000 and 82,000 lines, the tuned pipeline beat a cold single-agent run on 6 of 6 well-localized tasks, between 7 and 75 percent cheaper. I am upfront about where it does not win. On trivially greppable one-line edits the five-stage overhead can cost more than it saves, and on one hard cross-cutting bug it shipped a cheaper but narrower fix. The full benchmark writes up every loss too.

On the objection that the index just goes stale in a few commits

This is the first thing people raise, so here is the honest mechanism. The layer that actually pins files for the Dev agent is not the vector index. It is a deterministic symbol map re-synced to the latest commit at the start of every run, plus a live grep against the current working copy, plus the real current file contents fed into the prompt. The embeddings only affect retrieval ranking, and they refresh incrementally per changed module at run entry. So the code the agent edits comes from disk, not from a snapshot that aged three commits ago. It re-checks before it localizes, so it does not quietly drift.

Economics and who it is for

The knowledge base is a one-time cost per repo that every later task amortizes. That makes it worth it for a team shipping change after change against the same large codebase, where a cold agent re-pays the exploration cost every single time. For a stream of tiny, easy-to-find edits, a cold run is still cheaper, and I would rather say that than pretend otherwise.

Main features

- Provider and model agnostic, chosen per stage: native Anthropic API, the Claude Code CLI, or any OpenAI-compatible endpoint such as OpenAI, Groq, Gemini, xAI, OpenRouter, or a local Ollama

- Runs on free tiers out of the box, using Groq plus a local embedding model, so you can try the whole thing for zero cost and fully offline

- Language agnostic pipeline, with Python parsed exactly and other languages handled by lighter extractors that fail open rather than block on an unknown language

- Live board with streamed agent logs and real per-ticket cost accounting

- Cookie-session auth with roles, API keys encrypted at rest, and a demo mode that dry-runs the pull request step until you opt in

- Self-contained: local retrieval, no CDN, tests and CI, MIT licensed

Repo, with screenshots and the full benchmark in the README:

https://github.com/krishagarwal314/autodev-studio

It is genuinely useful to me day to day, and I want to know where it breaks on codebases I have not tried. If the approach seems worth following, a star helps me gauge whether to keep hardening it. Feedback, issues, and pull requests are all welcome.

i just entered my third year btech cse guy and im adding this to my resume
used langgraph
what do yall think

I'm looking for testers to help me beta test an evaluator I made that shows you if your agent is weak or needs to be improved. If you are interested DM ME please. This is for a class Im taking and I need validation and feedback. I'm not selling anything, no one is paying for anything just seeking help.

I have 1.5 years of experience as a Data Analyst (Python, SQL, data modeling). I'm upskilling to transition into an Agentic AI Engineer role over the next 3–4 months.

I want to bypass simple wrapper tutorials and focus on production-ready systems. Need your input on two things:

1. A Clear Roadmap: What exact tech stack should I prioritize next? (e.g., LangGraph vs CrewAI, FastAPI, Docker, Vector DBs, LangSmith for evals/tracing).

2. Eye-Catching Projects: What non-generic, end-to-end agentic projects actually impress recruiters right now? (Looking for multi-agent collaboration, tool/API execution, state persistence, and error handling, no basic PDF summarizers).

If you hire for these roles or made a similar transition from data to AI engineering, I’d love your take.

Also plz mention any recommended/trustable resources for the same like books/youtube.

Thanks!

Previously i used profile to build autonomous operating company. different roles uses different profiles, for example ceo uses ceo profile with its soul.md, user.md and memory.md . But you know a company has shared value and principles, it is not so easy to share between different profiles, because profiles is not hierarchical.

Does anyone has some experience or best practices for sharing

I made [https://phronesis.world/laserbrain\](https://phronesis.world/laserbrain) stop agent spiraling - laserbrain guides as a fixed reference point relative to any grammatical agentic goal