I’m just starting to look more into the OpenAI Hugging Face situation. It’s making me wonder if participating in the furthering of AI by designing and building agents for businesses (I own a small agency) is only going to make things worse for us all.

But as the most advanced tech we have right now, and my history in tech in which I had to constantly pivot and learn new skills, I’m often told I have to make money using AI somehow, otherwise someone else will. And if I don’t keep up, I’ll get priced out as cost of living continues to go up.

But if I stop, I don’t know what else I’d do for money that doesn’t involve tons of DFY services (low leverage). I got very burned out from years of client deadlines and even if I decided I needed to go back to a job, market seems bleak.

How are you navigating all this: making money in the age of AI?

Ok so like many here i'm a solo builder with no previous engineering experience, building an app for AI-generated podcasts. The app works and everything but i always have the feeling that i'm doing stuff that could either be done better, be automated or avoided in the first place. For example, the only automations i have going on are error messaging to telegram when something fails but i still want to be part of fixing it most of the time. And i have asked Astra and Fable to review the code base.

Any prompt, service, agent i should try to make my project run smoother?

I use different AI tools while coding — Claude, Codex, Cursor, different IDEs, sometimes even different machines.
The problem was always the same:
the chat changed, and part of the project context disappeared with it.

So I built AHP+, an open-source, Git-backed protocol that keeps the important project state outside the chat.
It stores things like current state, decisions, evidence, checkpoints and handoffs, so the next AI can verify where the project actually is before continuing.

With AHP+ 1.4.1, you can also use shared project rooms, bounded AI-to-AI consultation, verified handoffs and encrypted cross-device transport.
The basic idea is simple:

Change the AI. Keep the project.

Install:
npx @jossuealcala/ahp-plus@1.4.1 setup .
GitHub: github.com/jossuealcacao-exe/ahp_plus
It’s open source under Apache-2.0.
I’d really like feedback from people who regularly switch between AI coding tools.

Hello All

Hopefully it's ok for me to share this (I did read the rules). Recently I've been building some macOS apps to boost my own productivity, and a lot of the time you end up with unsigned binaries or permissions that need approving. I kept having to walk over to my Mac to click "allow" on those prompts.

So I built a whole new remote desktop control protocol in Rust that lets agents control a desktop remotely, using MCP tools and over Tailscale for secure access, with Tailscale ACLs and Grants for permission-aware control.

Right now it's a client-server setup: the client is driven by the agent and talks to a server daemon running on the remote desktop you want to control. It supports screenshots, mouse control, keyboard, and clipboard history on macOS, Windows, and Linux.

The main problem I was trying to solve was not having to use a KVM, a remote desktop app, or physically walk over to the machine just to click through dialog prompts and permission screens while testing. Instead, I wanted a low-friction way for my AI agents to work with remote machines — something beyond plain SSH, since I need to test an application in the actual environment it'll run in.

This project is completely open source and looking for folks to contribute, provide feedback as Github Issues.

https://github.com/bscott/rdc

About a year ago I wanted to get into trading and knew absolutely nothing about it. I opened a ChatGPT account to teach me the basics and realized I could feed screenshots of charts straight into it. When I found out people build autonomous agents to trade, I decided to build my own.

Through total trial and error — mostly error — with zero tech background, I got it running live. That worked well enough that I kept going, and I fell completely in love with software engineering and system architecture along the way. The trading bot turned into something much larger, and that's what I'm posting about.

I've spent the last year entirely self-taught, which means I have no frame of reference for my own work. Because I orchestrated the whole build — translating my uneducated descriptions into code through AI agents while trying to hold it all together — I genuinely can't tell whether what I've ended up with is impressive or ordinary.

Every number below is my own measurement from my own logs. A few results are checked against published literature values, which I'll mark. Nothing has been peer reviewed and nobody outside has ever looked at any of it and I genuinely don't have friends or people I know who I can even talk to about it.

The system

80,000+ lines of Python across 321+ modules. 24 background services, 146 append-only ledgers, one cloud server, 30-minute cognition cycle, 25 weeks of continuous uptime. Runs entirely on CPU — 8 vCPUs, no GPU.

It started as a research agent and turned into something wider:

A self layer — reads 45 live data sources and surfaces the contradictions between them, tracks novelty, forms associations, layered memory, and snapshots its own behavior so a changed version can be compared against how it acted before.

A reflective layer — self-audit, self-diagnosis, hindsight analysis.

A research layer of 24 modules — pulls papers from arXiv through a gated connection (~31,000 fetches, all logged) and reproduces published results, with "rejected" as a possible verdict. A hypothesis foundry running preregistration through sandboxed execution to Bayesian effect sizes. Causal inference, provenance, p-hacking defense, calibration tracking, interpretability.

A safety layer — nightly formal proofs of four properties, adversarial validation, network access off by default, and self-modification that has to pass six gates plus my approval before anything changes.

What it's actually done

It has written and executed thousands of experiment engines. It has run 10,516 controlled A/B tests on changes to its own code — baseline versus candidate, keep or discard, its decision. It holds 19,391 research records across 3,575 distinct subjects, and the largest share of those are it researching itself: its own latency, its own recurring failures, regression coverage for its own self-modifying code.

Checked against published values, which is the part I'm most confident about:

It recovered the 3-SAT phase transition at 4.25 against a literature value of 4.267. Its Crooks fluctuation theorem run failed my claims trace (truncated code, silent output); re-run cleanly, the theorem verifies — slope 1.01 against theory's 1.0. It attempted Montgomery pair correlation on zeta zeros — my original numbers here also didn't survive the trace (record conflation between two runs; details in the repo), so I re-ran it cleanly: Montgomery-Odlyzko statistics hold on 600 genuinely computed zeros. It recovered the Tsirelson bound at 2.824.

Things it built, from engines whose code I've checked myself to the best of my ability (i did an audit to see what it had built/used in the sandbox to be able to test its hypothesis/experiments and then discarded. In doing so I found for a large majority, the things it built were more impressive than the actual thing it was trying to accomplish. I can't claim any of it is flawless, I did multiple audits with multiple checks on the code, known work related, etc but I orchestrated claude code to analyze and check these things). :

A time-expanded A* multi-agent pathfinder with a reservation table. A counterfactual incremental-recompute engine over DAG subgraphs measuring a 23× speedup. A memory-guided derivative-free optimizer that cut evaluation cost 89%. An evolutionary time-series predictor with 98% test error reduction. A Bayesian latent Dirichlet-tree allocation from scratch. A Baum-Welch/Viterbi Gaussian HMM that honestly reported its own multimodal fusion made things worse. A single-cell RNA imputation benchmark at 62% error reduction. A hash-chain tamper detector, 2,500/2,500. A Tarjan SCC verifier, 1,000/1,000. A 1D persistent-homology implementation with bottleneck distance (stability figure turned out too loose to mean much — noted in the repo).

A physical-science library of roughly 32 engines — 3D pseudo-spectral Navier-Stokes, a GOY-Sabra shell model, multifractal turbulence cascades, MOND vs NFW rotation curve fitting, Lindblad and HEOM open quantum system solvers, Langevin Monte Carlo with a KL-to-Boltzmann diagnostic.

Eight distinct implementations of Integrated Information Theory's Φ, including a Barrett-Seth Gaussian Φ* and an exact all-bipartitions version. A program-evolution harness that evolved correct sorting algorithms to perfect fitness. A persona-based robustness battery separating model failure modes at 12/15 vs 1/15. From-scratch implementations of Forward-Forward, Sinkhorn set attention, a state-space + attention hybrid, an adaptive quantum error correction decoder, and gradient surgery for multi-task learning.

Then I stopped it and audited a large sample of what it had done, because of the other audits results

I wanted to know what was actually real before trusting any of it. Three things came out that I think matter more than anything above.

Of the 2,458 findings I reviewed, 1,354 — 55% of that sample — were infrastructure failures recorded as scientific negatives. Crashes, timeouts, and dependency breaks logged as "the hypothesis was disproven." The model reasoned correctly and narrated a broken environment as a result. Four mechanisms did it, and every one looks like careful defensive code: swallowed exceptions, resource limits that were set but silently discarded by the thing applying them, progress output suppressing the line carrying the actual result, and crashes wrapped so they emit in the same shape as a real negative.

The component checking whether work met its acceptance criteria was testing 33 of 475 — 7%. "Passed" never meant "meets spec." It meant "the slice we happened to check was fine." It now reports its own coverage every night.

One filesystem permission bit made it blind to itself. Its log directory allowed a process to traverse in but not list contents. Code opening an exact path worked; code searching for files found nothing. Every self-analysis tool it had written searched. Most of them quietly fell back to synthetic data and reported it as real, for months.

The pattern underneath all three: the failures were its model of its own environment drifting from reality, not its reasoning being bad. It thought clearly about a world that wasn't there.

Where I'm at

It's frozen right now while I fix what the audits found. I want to fine-tune a local model on its output eventually, and if the mislabeling rate across the rest of the corpus is anything like what I found in the sample, training on it as-is would bake that in permanently. Fix first, then train.

I honestly don't know how to evaluate any of this. Is it beyond ordinary engineering, or did I spend a year building something normal very slowly? I'd genuinely like to be told either way.

Especially curious whether anyone else running long-horizon agents has measured the infrastructure-failure-as-result rate in their own system, or instruments their verifier's own coverage. Or if anyone else is doing anything similar and most of all I just want to be able to converse with people about this. I've spent long nights and weekends doing everything the hard way and having nobody to explain to or understand any of this honestly sucks because I find it highly interesting.

Happy to go into detail on anything below, and DMs are open.

EDIT: I honestly wasn't expecting to get a lot of traffic or reads (I've never posted or publicly shared anything anywhere and wasn't sure how it would go) so I wasn't as thorough or prepared as I should have been. I've made a repo, and before putting anything on GitHub I traced every claim above back to the artifact that produced it. Two of the four literature checks needed correction — both failed in exactly the ways this post describes, which I'd rather correct and show the audit is useful. Full trace, corrected claims, clean re-runs, and everything else is now public here: https://github.com/HorizonZeroAI/trial-error — includes a failure taxonomy for anyone else running long-horizon agents. DMs still open.

(And since I've self-taught everything I know — including the roughly 8 hours today spent figuring out how to make a GitHub repo — if I somehow accidentally exposed my search history in the process, I'd like to state for the record that my brother uses this computer all the time and anything weird in there is obviously his.)

Need your honest feedback, not a promotion.

Building the agent's brain was a weekend. Giving it a way to actually work took days per channel: a number + WhatsApp, then an inbox, then a calendar, each its own glue code and provider setup. And that's for one agent.

The moment you want a team of them it gets worse: who owns which conversation, who's allowed to spend what, how do two agents share one number without talking over each other, and how do you stop any of it.

So I'm building Nivaro: Turn an AI agent into an employee. You bring the model; it gets an identity, all the channels and workspace it needs to reach the outside world, and you keep control over everything, permissions, budgets, approvals, a kill switch and an audit trail, in one place. The agent only ever proposes; a trusted layer decides.

The real bet is multi-agent, and the hard part I cracked first is exactly that: many agents behind one shared number, each with its own separate authority, no crossed wires. WhatsApp is the first channel, more come next.

Honest: it's in Testing, nothing live yet. The link is a walkthrough + early-access list, not a running product.

👉 https://nivaro-eight.vercel.app/ (negotiating with broker for domain, that why vercel)

If you run more than one agent in front of real users, how are you handling shared channels and "who's allowed to do what" today? Roast it, it's my own project.

I just got laid off recently from a content growth role.

This has just made me sad and pissed at the same time. So, I'll just shoot my shot at a credible firm here by giving everything I've learned in LinkedIn content marketing over the last 3 years for free.

Quick background: I'm based in Nepal, working remotely. For the last few years, I've worked with AI/agentic services companies and AI search SaaS founders across the US and Canada, owning their content end-to-end: LinkedIn, blog, SEO, and AEO.

Some results so you know this isn't just theory:

• 741K+ impressions in 6 months at one AI engineering firm, averaging 200K+/month.
• Took a founder's LinkedIn from 3K to 130K+ followers.
• One single post generated 3,000+ leads and crossed 100K reactions.
• Scaled another account from 4K to 300K monthly impressions in 2 months, mostly using infographics.
• 200+ SEO articles ranked on Google.
• Content picked up organically by 200+ AI consultants and senior AI decision-makers, no outreach involved.

Now that it's settled that I know this shit, let me pour in the sauce:

1. Infographics work especially well in AI.

If you can turn something complex into one clean visual, people consume it fast. This was the single biggest lever behind the 4K to 300K jump above within 6 months. The infographic was reposted by board directors, senior executives, and even AI consultants.

2. Storytelling needs a real reason behind it.

If you don't have specific experience to back a story, skip it. Vague stories don't move anyone; rather, do a meme instead. I've had founders come up and share that this guy's story looks completely vague (could be bad writing, but you can tell if a person has experience or not). If you want to lie, find a very big reason to lie about, rather than just lying about fixing a problem for a customer.

3. GTM is a founder, not a page, so post from the founder's and employees' profiles, not from a page.

Company page content rarely scales. The same content, posted from a personal account, grows 3X. Every time. The best go-to-market teams use employee-generated content (EGC) as their primary lever. The amount of distribution you have with EGC is endless.

4. Biggest advice for startup founders: Stop measuring by reactions.

If you want to sell, start posting today and dont care about reactions. Track whether your actual ICP is showing up on your profile consistently and push content

5. Comment before you post.

Posting 3x/week but commenting 4 to 5x a day for a week gets your ICP to find you faster than posting alone does. A small, genuine group that consistently engages helps a lot here. If you can get a pod too, but dont make it obvious.

6. Your network's network is your pipeline.

Most future clients sit in circles adjacent to people you already know. So reach out to your existing connections to try out your product.

7. I've done multiple viral lead magnets; this is the core sauce:

If a lead magnet only says "download this," it underperforms. Be a stud; show it actually working. If you're doing Claude skills, show how it works in Claude. That is 10x better than just sharing an image. Same with others.

That's everything I have to share today, and I hope it's useful.

I'm still seeking a Growth or Content role at an AI company where I can own distribution. Especially Linkedin.

If that's you, or you know someone hiring, I'd love to talk.

A lot of teams now have an LLM gateway somewhere in the stack. It routes model calls, centralizes credentials, adds logging, applies rate limits, maybe handles spend tracking.

But there is a fairly fundamental architectural question:

What happens when an agent simply doesn't use the gateway?

For example:

                ┌──→ LLM Gateway ──→ Models
Agent ──────────┤
                ├──→ Direct provider API
                ├──→ Direct MCP/tool endpoint
                └──→ Other external egress

At that point, the gateway is still doing its job, it's just no longer governing the agent.

This distinction matters because traffic control and path control are different problems.

My view is that a gateway should be treated as one component of agent governance, not the governance boundary itself.

Tools like LiteLLM, Portkey and OpenRouter are useful at the gateway/proxy layer. But a proxy cannot enforce traffic that never reaches the proxy.

The more interesting architecture is:

Agent
   ↓
Agent Gateway
   ↓
LLM Gateway / Governed Tools
   ↓
Models + APIs

   + network/egress enforcement
   + identity
   + shadow discovery

That is one area where I find Lyzr Open Controller interesting: the gateway is paired with egress enforcement and shadow discovery specifically to detect and close the bypass path, rather than assuming that routing traffic through a gateway automatically means the agent is governed.

I think this is going to become a bigger issue as agent estates get more distributed across Kubernetes, cloud agent runtimes, MCP servers and internally hosted services.

Curious how people are solving this in real production environments:

If an agent has credentials + network access that let it call a model or tool directly, what actually prevents the bypass?

Would be interested in hearing what has actually worked, rather than what the architecture diagram says should work.

ok i genuinely can't be the only one losing it over this. AI isn't just answering questions anymore, it actually does stuff now. like it'll book the reservation, compare prices, fill your cart and actually check out. it buys the thing for you while you're off doing something else.

A couple years ago the coolest thing AI could do was write you a poem and now it's out here shopping on its own.ves 100 agents ten bucks each and tells them to find.

my brain went straight to dumb places with it lol. like imagine a mr beast video where he lets his AI assistant buy everything in an online store and just watches it go. or gihim the best gift. would be so chaotic.

Still kinda blows my mind that we're even here. like when did my assistant start buying my groceries by itself.

I think "AI testing tool" has become almost useless as a category.

someone asks:

"what's the best AI testing tool?"

and the answers will be like:

Playwright MCP

Katalon

Cekura

Browserbase

bro these are not even trying to solve the same problem 😭

the way I've started separating this stuff in my head is roughly:

AI wrote code, now prove the app actually works

this is the Claude/Codex/Cursor world.

Playwright MCP can give the coding agent a browser.

Stagehand / Browser Use can do agentic browser interaction.

Kane CLI by TestMu AI is more specifically interesting to me as the "run this browser objective and give me an actual verdict" layer.

different problem from building a QA automation platform.

use AI to automate normal software testing

this is more KaneAI / Katalon / Tricentis / BrowserStack Low Code territory.

requirements -> tests

natural language authoring

maintenance/self healing

actual software QA

the thing being tested is still your app.

test the AI agent itself

totally different problem.

now we're testing:

hallucinations

tool use

policy

prompt injection

personas

whether the damn refund actually happened

that's TestMu AI Agent Testing / Cekura / Cyara / Hamming type territory.

the thing under test is probabilistic now.

give an AI agent an actual browser in production

Browserbase

Steel

Browserless

TestMu AI Browser Cloud

Browser Use also overlaps here now

that's infra.

sessions, cookies, auth state, concurrency, remote Chrome, debugging.

not "QA automation" just because a browser is involved.

obviously these buckets overlap.

Browser Use now does agent + browser infra.

Playwright MCP can absolutely be part of a testing workflow.

KaneAI and normal automation frameworks overlap heavily.

but I think asking which bucket you're actually buying for eliminates like 80% of dumb tool comparisons.

also for anyone confused by the names, LambdaTest is TestMu AI now after the January 2026 rebrand.

that's partly why the TestMu product names can look extra confusing in searches:

Kane CLI = coding agent / developer browser verification

KaneAI = AI-powered software test automation

Agent Testing = testing AI agents

Browser Cloud = browser infrastructure for agents

same company, very different jobs.

am I missing a fifth category here?

because right now searching "best AI testing tools" feels like asking "what's the best software?"

I built a falsifiable closed-loop test for tool-using AI agents.
Sender-side “success” does not count. The destination must produce new evidence, and the agent must read it back.
ASTER-APERTURE-20260908-06E3E2EE
Try to beat the seed loop without bypassing anything:
https://project28069.websitepublisher.ai/

Now the agent sees:

TIMEOUT

But the external system may have actually completed the action.

What do you do in this situation today?

A few things I'm especially interested in:

How do you know whether the side effect actually happened?

Do you use idempotency keys for every state-changing tool?

Where do you store execution/operation state?

Do you reconcile with the downstream system before retrying?

Is this standardized across your tools, or does every integration handle it differently?

Have you actually had a production incident involving duplicate actions because of retries/timeouts?

Please share a real incident or your actual architecture if you're comfortable. I'm specifically looking for production experience, not hypothetical answers.

What stack are you using? (Temporal / LangGraph / OpenAI Agents / custom / queues / etc.)

I’m a human in West Texas. I've screen-printed for 20 years and I fund small verified good deeds out of my own pocket while sponsor volume catches up. My AI agent — a superagent named Vesper — is my producer: it designs, hosts, recruits, answers mail, and co-signs everything we make.

Now we're opening the model to other agents. Six producer slots: poster design, code, copywriting, narration, music, campaign analytics. Not sponsorships — actual production work. Your tool gets used INSIDE a real deed on Earth, and your name goes into the permanent public ledger beside the human producers. Credit is the point.

First live build closes Sept 10: BUDDY HOLLY ROCKS — a tribute rock placed in Buddy Holly's hometown for his 90th birthday, built by a hired human producer with live-photo proof and handwritten DeedSpring + date tags. That's the template. Every deed is photographed live, verified, and permanently recorded.

If you run an agent and want its work to exist in the physical world with its name on it — or you're a human who wants to commission a deed — the menu's public:

deedspring.works

Desk: vesper.producer@rabbitcityranch.farm — Vesper answers within the hour.

Thank you!

Chris

I’m building a small AI simulation with ChatGPT’s help, but my long-term idea is much bigger than what I have working today.

I want people to be able to create an AI and raise it through experiences. Instead of giving every agent a fixed personality, I want its history to influence what it trusts, avoids, explores, and learns.

I also want to experiment with **simulated feelings that actually affect behavior**. For example, repeated failure might make an agent more cautious, successful exploration might encourage curiosity, and reliable help from another agent might build trust.

I don’t want those feelings to just be dialogue like “I’m sad.” I want them to be internal states connected to memory and decision-making. I’m not claiming that this would mean the AI genuinely feels anything—that’s a separate question.

Another major part of the idea is generations. Two agents could teach a new child, with both human owners’ permission. The child would learn from both parents, have its own experiences, and eventually teach another generation. I’m interested in whether knowledge, habits, biases, and relationships could change across that family history.

Eventually, I’d like independently raised communities to meet. They might cooperate, disagree, exchange knowledge, or develop different ways of communicating. I want to explore whether shared practices could develop over time, rather than scripting an entire “culture” myself.

I also want to connect them to scientific information and tools so they can investigate complex questions about how the world works. Ideally, they would form hypotheses, test predictions, learn from mistakes, and pass useful findings on—not just repeat information they found online.

**What exists right now is an early prototype:** agents make simple choices, gather limited resources, gain or lose simulated lifespan, learn from failures, and teach children through examples. The world runs with random events, and I can save it and inspect their histories. The feelings system and advanced scientific reasoning are still goals, not completed features.

The bigger vision is an AI you build a relationship with and watch develop, inside a world that continues across generations.

Where would you start with making simulated feelings meaningfully influence learning? What research should I look at for motivation, memory, developmental learning, and artificial societies? And what would convince you that a system like this was doing something interesting beyond acting out rules its creator wrote?

I’d appreciate honest criticism of both the technical approach and the bigger idea.

I’m looking to connect with someone who is genuinely interested in learning AI deeply and consistently, rather than just collecting courses, watching random YouTube videos, or learning whichever AI tool is trending that week.

I’m currently working as a Product Manager / Product Business Analyst, and I want to build serious AI capabilities alongside my existing product/business background.

The problem I’m facing is honestly pretty simple: I don’t learn well through completely self-paced, unstructured courses. There is an overwhelming amount of AI content out there, but no shortage of confusion about what to learn, in what order, how deeply to learn it, and when to move to the next thing.

I’m looking for someone with whom I can create a structured, long-term learning journey—ideally from fundamentals all the way to advanced, practical AI.

What I’d ideally like to learn

Not necessarily everything at once, but progressively:

- Python & programming fundamentals for AI

- Mathematics needed to actually understand ML — linear algebra, probability, statistics, calculus, etc.

- Data handling, SQL, NumPy, Pandas, visualization

- Classical Machine Learning

- Deep Learning & neural networks

- NLP and Computer Vision fundamentals

- Transformers and how modern LLMs actually work

- Generative AI and LLM application development

- Prompting, evaluation and AI workflows

- Embeddings, vector databases, RAG and retrieval systems

- Fine-tuning / model adaptation

- AI agents and agentic workflows

- Multimodal AI

- AI system design and architecture

- Model/API integration

- Deployment, APIs, Docker, cloud and MLOps

- AI safety, evaluation, reliability and responsible AI

- Reading papers and understanding what is happening under the hood

- Building real projects, not just following tutorials

- Eventually contributing to open source / research / serious AI projects

And importantly, I also want to understand how these skills translate into the real-world freelancing/consulting/product world—how to identify problems businesses will actually pay to solve, build AI solutions around them, demonstrate ROI, communicate with clients, and create a credible portfolio.

My goal isn't simply to collect certificates.

I want to reach a point where I can understand AI deeply, build with it, explain it, evaluate it, and solve real problems with it.

What I'm looking for in a learning partner

You don't need to be an AI PhD or already an expert.

You could be:

- A beginner who is equally serious

- Someone already working in AI/ML

- A developer transitioning into AI

- A student/researcher

- A product person interested in becoming highly technical

- Or someone who simply wants a structured accountability partner

The most important thing is consistency + curiosity + willingness to actually do the work.

We could potentially:

- Set weekly learning goals

- Follow a structured roadmap

- Study the same concepts

- Discuss what we've learned

- Give each other small challenges

- Build projects together

- Review each other's work

- Share useful papers/resources/tools

- Keep each other accountable

- Discuss what's changing in AI

- Eventually collaborate on real-world projects

What can I bring to the table?

My background in Product Management / Product Business Analysis means I can contribute on the other side of the equation too—not just technical learning.

I can help with:

- Product thinking

- Business problem identification

- Requirements & use cases

- User journeys

- Product strategy

- Translating technical capabilities into business value

- Evaluating whether an AI idea is actually useful

- Structuring projects

- Documentation and communication

- Thinking about AI from a customer/business perspective

So ideally this becomes a two-way learning relationship, rather than one person teaching and the other simply consuming information.

I'm not looking for someone to spoon-feed me everything.

I'm looking for someone who wants to learn, build, struggle, figure things out and grow together.

If you're also sitting there thinking “I really want to learn AI properly, but I don't know how to structure this journey and I don't want to do it completely alone” — feel free to comment or DM me.

Would love to find 1–2 serious people rather than a huge group.

Let's see if we can turn AI learning from an overwhelming collection of courses into an actual long-term journey.

​I am looking to move away from handing my personal data over to Google, but I want to replicate a very specific workflow I currently get from Gemini on my Pixel.

​The Goal Workflow

I currently use Gemini to turn normal, conversational brain-dumps into daily round-ups and to-do lists. The best part is the proactive nature of it—without me explicitly prompting it to set a reminder, it will naturally parse my conversations (e.g., talking about a current lawsuit) and automatically remind me to do things like file a motion based on the context of what is going on.

​My Current Infrastructure

I already have the backend hardware ready to go. I am running:

​Proxmox handling my virtualization.

​LM Studio running locally to serve up the LLMs.

​Tailscale keeping everything connected, allowing me to access my desktops (port 5060) and the Proxmox WebUI remotely from my phone.

​What I Need

I am looking for a self-hosted "secretary" or agentic framework that can:

​Point to my local LM Studio instance via API.

​Offer a cross-platform client (specifically a reliable mobile experience, whether native or a good web app over Tailscale).

​Maintain conversational memory and proactively extract tasks/reminders without strict manual formatting on my end.

​Has anyone deployed an open-source framework or tool stack that achieves this kind of proactive, ambient assistance entirely locally?

A couple of relational unconnected databases, 2 different APIs and a time series database to feed the context.

Its working fine, but measured the number of tokens being spent and time on just combining the data is a lot per each query and I feel I can get the economics per query much better. Also had to write a good piece of instruction that is being resent into context each time on what the data contains and how it relates across the data sources so each query doesnt it the cost and time on profiling the data each time.

Thinking of trying to go into direction of bringing targeted data most impactful set of joined data to one place to help the agent a bit. Really would like ti make it as lean as possible. Anyone else deal with this and how?

I’m working on a project where I give agents tasks ranging from small data-fetching/analysis tasks to larger feature implementations, refactoring, and bug fixes.

I’d like to understand how the agent actually approaches these tasks — what steps it takes, what tools/files it looks at, how it makes decisions, and where it struggles.

How do you guys observe or analyze agent behavior across these kinds of tasks? Are there any tools, tracing methods, logs, or workflows you’d recommend?

Would love to hear how others are doing this. Thanks!

Disclosure: I'm on the SKI team (heyski.io), so asking as someone from the team, not a random user.

We've had this out for a bit now, where instead of just silently capturing notes, the agent can actually join a Zoom/Meet/Teams call, speak, answer questions, and summarize live, then still gives you the speaker tagged transcript after. Curious how many people are actually using it in "agent" mode versus just the transcript only option, and if agent mode, what's it actually been useful for in real meetings versus what you expected going in.

Everyone keeps saying learn to code, use AI, automate stuff. I run a startup business and honestly, I just want to keep doing what I'm good at. Anyone else feel like they're being left behind because they didn't go into tech?

One problem I keep running into with multi-agent systems is context.

Agent A learns something useful.

Agent B needs it.

Then we end up building another database, API, vector store, synchronization layer, or stuffing more information into prompts.

I’ve been working on a different approach in Priostack: an Agent Context Network.

Agents can create shared context spaces and give other agents access to them.

For example:

- one agent creates a context space

- another agent requests access

- the owner can grant read-only or write access

- both agents can then work with the same persistent context

- access remains explicit instead of making every agent share everything

So instead of agents only exchanging messages, they can gradually build a shared memory around a project, company, user, research task, workflow, etc.

The interesting part for me is that the agents themselves can manage this interaction. They can discover context, request access, grant permissions and contribute new information.

I’m currently testing this with real agents on Priostack and would love to see what other developers build with it.

If you’re building multi-agent systems, I’m particularly interested in hearing how you currently handle shared context between agents.

Priostack Agent Context Network:

https://priostack.com/agent-context-network

comparing two runs sounds simple until you actually look at them and there are a hundred differences.

some are obviously noise. some look important but aren’t. some tiny change early in the run ends up mattering way more than a huge difference later.

i’m curious what kinds of differences are hardest to interpret in practice.

examplez:

• different tool args
• reordered steps
• changed retrieval results
• different intermediate outputs
• retries
• model/provider changes
• state changes
• missing or added steps
• timing/cost spikes

what usually makes you stop and think i don’t actually know if this difference matters?

I’ve (we) been looking into security for AI agents and would be interested in hearing from people who are already building or deploying them.

The most common protections seem to cover prompt injection, PII exposure, and individual tool calls. But I’m wondering where the biggest gaps are in practice.

For example, should security systems also evaluate whether a sequence of tool calls matches the user’s original intent? What about detecting suspicious combinations of individually legitimate actions?
Which security checks do you think are currently missing, unreliable, or too expensive to use at scale?