Xx_crazy420_xX

I would be surprised if pelican svgs are not part of the training corpus rn

I might be wrong, but strongly suspect that Fable 5 is already something in this shape, considering long time to first token while having normal troughput.

I'm a huge fan of Ben. Have been tracking the OpenCog initiative for some itmem and think that moving concepts from latentspace to atomspace is best way to efficiently merge our current digital information infrastructure with LLM knowledge.

Regarding your book, I'm shocked that 'AI Agent' concept predates me. Have not read your book, but i think it would be interesting to compare your perspective with today's building blocks which were not available for that time.

Physical simulations seem like next step, but how do you simulate dynamics in complex systems im not sure. Stock market is a good example with many trying to simulate that, but at the end you have to make some tradeoffs in terms of abstraction level you are simulating.

For social backed simulations i guess some kind of grounding will be needed based on real examples, but then the out of distribution cases will need an other solution. As rate of changes in our civilization increases, the out of distribution cases will be more and more prominent.

I agree, for me it dreaming was always reprocessing. The resimulation of scenarios part i mentioned can be over-assumption and it might be wrong. One thing i noticed is that sometimes i reprocess motoric movements after martial arts lessons, that was my main clue.

sure: https://github.com/Srakai/bench-evolve/blob/76677b5066bafbab...

I think open-ended simulation for agents will be a key component for training and planning. Similar as human dreams simulate different scenarios in our head. Biggest challenge will be simulating more abstract and complex systems.

Few months ago I did experiment with an open-ended world simulation for AI agent, where the simulated world was progressively building itself based on each of agent actions in open-ended manner. The idea was to give an agent infinite possibility regarding tool calling, where the tool call would be approved by the adjudicator, and the world state would change. The key issues with the PoC were:

  - World decoherence (tried to solve that with a poor graph implementation)
  - World flatness - high abstraction did not account for small events that would compound in real world
  - Start with empty context was real issue to get the agent to explore the world
  

4 different databases when you could just postgres. Also seems that 'Think and Plan' and 'Reflect' phases are redundant, as stated: 'Think & Plan: Process Reflection'. Also more personal opinion is that LangGraph is unnecessary framework only slows you down by spiking up complexity.

Not sure how you manage to measure Faithfulness and Answer Relevancy on the live system, without the ground truth.

Good that you have evals in place, but the user satisfaction score might suggest running ablations on the system would be beneficial. I would start by reducing the iterations and unnecessary steps from the agent.

Then why not take a small loss and publish at least one example that is something beyond copying the frontend?

"Debugger attachment is blocked. Memory inspection is blocked." - reminds me old crackme challenges. Everything they mention can be bypassed, so determined person can start stealing data from the network. For me this is a killer of such distributed compute ideas, but who knows, maybe the non-enteprise users will be desperate enough for cheap compute to make this idea valid.

I think it would be valuable to list all interactions with the LLM by the dev team and transparently state what was induced by human steering the LLM, and what was actuall LLM decision, which was not biased by system instructions or dev team communicating with it

Why would you want to obfuscate payments if you can track how many ships entered the gulf using transponders? Regarding money laundering, you use Tornado Cash or Monero

Either we will be expecting the models to compress whole wikipedia and stale on the size reduction, or focus on the reasoning capabilities. My intuition is that by forcing models to remember everything we are wasting parameter space which can be allocated for more abstract thinking.

If i understand it correctly, the analogy could be:

Let's say we have a low level programmer expert and we try to teach him algebra either we:

  - (SFT): give him algebra book with new nomenclature, definitions, syntax
  - (RL): let him learn algebra using C syntax

Autoresearch is nothing new, big players are already in the game with more sophisticated solutions:

  - https://arxiv.org/abs/2602.02660 (MARS)
  - https://arxiv.org/abs/2601.14525 (Execution-grounded automated AI research)
  - https://arxiv.org/abs/2601.10402 (ML-Master 2.0)

I can't believe the solution is creating uncompatibile branch and forcing users to use cladue for resolving merge conflits. Why not bake in the dual compatibility?

Why create IDE without IDE features? Whats the benefit of this over using IDE with Codex plugin? I don't believe that you can review the code without code traversal by references, so looks like its directed towards toy projects/ noobs. And the agents are not yet near the autonomy that will omit the code review in complex systems.

Can either one be proved?

I think ai agents need to adapt to our software ecosystem not the other way around. Maybe form of wrapper that creates a skill from every binary would be more applicable

My thoughts:

- The cost function of the CEO is a deeply nested function, as for example revenue is dependent on multiple factors like customer growth, operational costs etc. In practice this function is nested to the lowest possible point in a tree of dependents. No coincidence that best CEOs know how they companies work on lowest levels and understand the constrains and incentives there.

- Where is the boundary of AI CEO? Should we make the boundaries? Human is restricted to 18h awake time, single threaded processing, thats why we need to divide the workload. Is same thing really needed with AI? (assuming all layers of the stack are AI managed already)

- How to validate that decomposed elements of the cost function, (like the customer growth and operational costs revenue) provide valid equation? The cost function should take into account things like reconstruction loss minimization, to ensure that model is not delusional and new dependencies are valid (problem discovery).

Look at https://github.com/vec2text/vec2text

This is really interesting! I've experimented with similar idea, but with time series forecasting on the sentence embeddings - https://github.com/Srakai/embcaster.

It turns out you can tokenise arbitrary information into constant vector which is really useful for later processing. The vec2text (https://github.com/vec2text/vec2text) is an excellent asset if you want to reverse the embeddings back to text. This allows you to encode arbitrary data into standarized vectors, and all the way back.

Maybe i was just too narrow focused on the comparison itself and did not get that point. Anyways, as a whole was a valuable read, along with hn comments made me reconsider current implementations details in my projects

The author (human or llm) flips between performance ("millions of vectors") and semantic accuracy ("only 3 match your filter") to push its point, depending on what needs to look worse. AI framing switch that was that was probably introduced by RLHF on humans that don't think critically but want somewhat convincing answers.

For pre-filtering "You’re still searching millions of vectors" isn't valid argument, because the author does not relate to any alternative, and post-filtering is even worse.

Nice, I did not know about that. I've built something similar (https://github.com/Srakai/aw-llm-worker) on top of ActivityWatch (https://github.com/ActivityWatch/activitywatch)

Why you assume it will provide more opportunities than 'random' selection? I think it will be opposite

There is some incentive to leave 0days in customer software, as it creates a commodity to be sold on gray 0day markets. On the other hand, securing your own garden brings less value then covering and deneing that your 'secure' cloud platform was whacked.

Did you try to ask it to provide data of the company, by explicitly invoking hallucination in the model?

Right now there is no real proof, untill you confirm that the data it provided cannot be hallucinated (which could be not feisable).

Also, acknowledging the response fron OpenAI staff dismissing it, would you mind sharing PoC?

The preference of shell history depends on the use case. In my case it's ever changing projects with different tech stacks that i need to remember set of commands to get SSO to get to container registry etc..

The solution for me was storing bash history separately for each vscode project - https://gist.github.com/Srakai/9f3788cdb07259d65d335ff150c38...

Scripts are cool, but imagine ever evolving script that is controlled by arrows and enter

It would be nice to compare all packets dumped by system and check if there are any unmatching packets running from your computer that were not sent by OS but a closed source hardware inside like Intel ME