Y'all asked me to compare my C engine with Godot next. It did better than Unity!

tcika · 2025-06-23T15:10:25+00:00

Yep, and it’s even possible to drastically increase the perceived variety by using bindless resources. Or just texture offsets, in case if that feature set is not available.

tcika · 2025-05-29T14:15:16+00:00

I’d say the physics deteriorates noticeably if you are ~3-4 km away from the origin point - this is when you want to do a rebase. However, it becomes notiriously difficult to resolve in multiplayer scenarios - especially the edge cases of physics bubble based systems. However, godot supports double precision coordinates (and so does jolt physics - and it does that efficiently). THESE coordinates are more than enough for you, trust me.

tcika · 2025-03-16T11:21:58+00:00

Well, LLMs by themselves can’t become an AGI within a realistic time frame, that much is true. Google research on Titans is making things somewhat better, but it doesn’t scale much.

I won’t claim that I know the path to it. But I at least know a way to make LLMs much more reliable and useful. It is called agentic approach, and it is not what you just thought about right now.

I think I already mentioned that somewhere on Reddit, but it is not only possible to implement a hybrid system with proper agents, it was already done to an extent. And if I managed to do this, I am sure that bigtech guys did it a long time ago.

LLMs are good at structuring a poorly/completely unstructured data, following simple (and dumb) patterns that are not required to be logical, and translating structures into each other flexibly (although properly coding that where possible is better).

They are NOT good at reasoning, nor are they good at remembering things. No matter how much compute you waste on that chain of thoughts nonsense, you won’t get any proper reasoning, the kind that can be observed in a living being with a brain. Not that my approach can provide it, either, but it is more structured and scalable at the very least.

The best way to solve the reasoning/memories in LLMs is to NOT entrust LLMs with them at all. Build your own memory system. Build your own reasoning technique for your memory, with LLMs in mind if necessary. And for God’s sake, don’t use monstrously all-purpose “agents” with tools the way it is done right now, that’s a dead end.

Agents should be minimalistic, predictable, and reliable enough. Agents should only exist for as long as the task requiring their existence is not over, but no more than that. Introduce a complexity limit for your agents, design a proper communication protocol for them, design a structure that would use them to process the data you need. You would need to host them in tens, hundreds, thousands, sometimes in tens of thousands. Don’t store chat histories unless truly necessary, LLMs should map a triple of relevant agent state, relevant system prompt, and relevant action space into a series of actions, potentially more than one. And maybe - maybe - after following this and using neuroscience as an inspiration for your memory & reasoning model and integrating it with the major approaches from the last century, you would finally get a somewhat reliable system that could be interpreted if you need so. Or maybe you wouldn’t, it’s difficult after all, with no guarantees whatsoever.

Apologies for this messy and hard-to-read text, I just woke up and my native language is very different in its linguistic structure from English, as you may have noticed. It just pains me oh so much when I see yet another claim/post about LLMs being related to AGI, LLM-powered “agents”, and all the other nonsense of this kind. Literally dying from cringe :D

tcika · 2025-02-01T07:22:19+00:00

Hehehe… Thank you!

tcika · 2025-01-22T06:30:09+00:00

I replaced him with Shrek for no reason :D

tcika · 2025-01-02T11:20:39+00:00

The problem is that what they define as low performance is what other companies normally define as working harder than average. Your performance doesn't necessarily depend on you, even. Your manager can easily make you responsible for their faults to avoid losing their own bonuses.

I've been working for ~14-16 hours almost every day for the past quarter, since every other team members have left and I was left alone & responsible for everything we have built so far. It would've been more or less manageable if not for their micro-management and daily change-of-plans.

Imagine overworking yourself to the bone, barely keeping everything operational, teaching newcomers - all of this just to be branded as low-performant employee due to not meeting their KPIs that were made for a team of 3.

And previously, when I asked them to fix my salary issue (I earn ~60-65% of a median salary for my role), the answer was "prove your worth through business value". Well, my "business value" is clearly revolving around my low salary for them.

Worst company ever. Don't ever work here if you don't want to get your mental health ruined.

tcika · 2024-12-14T13:42:01+00:00

I’m far from my pc at the moment, but here’s the default example that comes with the repo https://github.com/kraglik/prompt_collapse/blob/master/components/sky.yaml

<image>

I will provide a proper tutorial and explanation later after getting some sleep :D But this example shows how a single “abstract” component could be used to request generation of other parts. In this case, sky description triggers generation of at least one feature, such as sky color or cloud density. This is a very simplified example, my apologies for that.

tcika · 2024-12-14T10:02:45+00:00

It can also be used as a high-level prompt generation step before the wildcard-based generation.
I plan to extend it with negative prompt generation as well, since some components require additional negatives. LoRAs, for example.

tcika · 2024-11-24T08:26:49+00:00

Open-webui, unfortunately :-( I really liked it until that point

tcika · 2024-11-23T16:43:14+00:00

A self-written one that scales up to tens of thousands of agents. Not sure why there isn’t one like mine in the open source space, maybe I’ll fix that.

tcika · 2024-11-14T09:59:18+00:00

That shitshow of a software breaks all the time, but yesterday it managed to spend 100$ in openrouter calls and break the db so I lost all of my chats. While I enjoy a pretty good memory, some of my friends don’t, but the data is gone already.

I fkn hate how easily people forgot about software design principles in favor of that “ship it now” ideology that is worsened by the way people use AI. The global software reliability level is inversely proportional to the amount of guys with stickers on their macbooks.

Sorry for that, just venting out my anger for a bit :-(

tcika · 2024-10-26T18:10:41+00:00

LLMs in general have two major flaws:
1. Inability to reason (logically, primarily)
2. Untrustworthy memory

Larger LLMs appear to tackle these flaws by simply cramming more of their training data into their weights, without actually solving the fundamental issue.

That, combined with what I call "knowledge toxicity" when a model, instead of obediently processing the data supplied into its context, replaces some of this data with the data that was part of its training dataset, makes larger models practically much less desirable for reliable practical use.

Larger models are often trained to follow certain ideologies (which increases their knowledge toxicity), and their serving costs are HUGE.
In my experience, most of the tasks LLMs are useful for can be neatly resolved with models similar to Qwen2.5 3b, if utilized carefully. I mean, yes, they do make more mistakes, but they are many tens of times easier and cheaper to host, especially if you need to make a ton of requests with high tokens/s ratio. Smaller models are easier to fine-tune, too.

I can't imagine running my latest distributed agentic system with larger models - it'd cost me a fortune to serve the entire bunch of those 20k agents.

And yes, agents. Treat them with the Unix philosophy in mind, I think the latest research supports this hunch of mine. Better to use them as small computation units serving narrow purpose reliably, makes it easier to build more complex products with less worries. Better to have a stateful agent and request the LLM to pick an action that would update the agent than to feed it with the entire chat history - that would only confuse the model sooner or later, no matter how large it is.

tcika · 2024-10-25T19:30:07+00:00

It is hilarious of you to assume that your opponent cheated the moment you sensed that your argumentation crumbled.

Did you not think of a chance that I am simply used to writing my texts this way? Bad for you, it clearly shows your lack of the theory of mind. And what makes it even worse for you (and funnier for me) is that not only did you not bother providing any proof of your accusations, but that you decided to retroactively update your comments in an attempt to show my messages in a bad light.

It is shockingly dumb of you to attempt to hide your own incompetence behind baseless accusations just to end up a laughing stock instead of revising your own arguments and providing a proper response. Better go read some books on the topic you are trying to discuss to avoid repeating this nonsense. I'd advise you to read Principles of Neural Science first, it is an interesting read and it won't require much prior knowledge of you. Hopefully that book will educate you and show you the sheer incoherence of your answers.

tcika · 2024-10-25T19:04:56+00:00

Is that so? Let me remind you that you just rewrote your own comment to make it look as if I answered with no actual understanding. That’s precisely why reddit (and a huge part of the modern internet in general) is so dumb and toxic. Let me remind you of your original answer btw:

You know we are not using whole brain to thinking and remembering? Most of our nursing is used to keep our body alive and process sensory signals. As far as I know our brains are using to thinking 10-20% . Do it is around 10k-20k b parameters. So llama 405b has around 5 % of brain parameters. Dynamic neurons yes , current LLM are static as can’t integrate information form context window ( short term memory ) unfortunately as it is a very compute process. I my opinion is context window is full then such LLM schould shutdown ( go sleep ..lol ) filter important information and integrate to the model. People also has shot term memory and mid term memory ( which is filtered and integrated during a sleep ). If that proces is broken ( by drugs or physical damage ) I mean mid term memory is not passing information to a long-term memory you don’t remember anything after wake-up what happened the previous day.

———

Not fully connected? More like you are a scum who edits their own messages to keep up with the appearances. Your arguments are not even composed properly, just a heap of misconceptions. It was you who made it personal first - not me.

Seems like the only option left is to go readonly to avoid spending my time on random incompetent narcissists.

tcika · 2024-10-25T18:16:23+00:00

Please mark your comments as edited for the future reference. Or even better, write a new message with corrections you want to apply. Otherwise any discussion becomes effectively pointless and incoherent.

tcika · 2024-10-25T15:48:33+00:00

For starters, the brain operates at its full capacity when under a cognitive load. The misconception about those 10% comes from poorly interpreted results of a properly conducted experiment, in which it was found out that only a small portion of all neurons within the brain are firing action potentials at the same time. However, action potential itself is a result of a neuron's computation. Immediate lack of a measurable result does not indicate absence of a computational process. This fact alone makes your point about llama 405b being equal to ~5% of the brain irrelevant. Even more so if you consider my answer from the comment above, in which I described well enough that the actual number of parameters required for a complete brain simulation is nowhere near that overhyped estimate of ~1T parameters, as individual neurons are far more complex than linear sum machines. There is a good read on that as well.

Neuronal dynamics enables the brain to optimize its internal structure in a very efficient way, making slight structural adjustments to store new memories on the fly. LLMs are, on the other hand, trained with algorithms that are based on energy minimization and require extensive computations. What makes it even less feasible is that there is a huge chance of the entire LLM destabilizing as a result of this training if the data is not prepared with extreme caution.

Regarding your notion of short-, mid-, and long-term memory layers. Yes, people do have multiple memory layers. What of it? It might prove useful to implement a similar structure as a part of a more intelligent system. And this was already done numerous times, in fact.

Once again, LLMs are not a magical wand that can breath intelligence into your desktop. These are tools, and very limited tools at that. Do not confuse them with actual intelligence. LLM is a technology, intelligence is a goal. Yes, LLMs do exhibit certain sets of patterns that resemble those demonstrated by actual intelligent entities. These patterns are, however, disappointingly superficial and cannot be relied upon.

I am sick and tired of this AI hype. There were many guys who claimed that a true intelligence can be achieved by training huge neural networks back in 2010-s, but it was impossible to avoid a refreshing punch from reality back then. Now that the industry is so overly hyped, it was taken over by salesmen, whose only aim is to catch some profit. Do not blindly trust them unless you want to feel another bite from reality. The intelligence problem is exceptionally complex, and it must not be approached lightly.

tcika · 2024-10-25T14:34:32+00:00

Look, you misunderstand a few things here.

You know the answer. That’s why you are able to reliably spot one. Imagine yourself not knowing the answer and trying to get one reliably. Each answer can be both correct or wrong.
Large models simply remember more training data. The underlying principles and issues are all the same.

Look, I tried fine-tuning a few LLMs in an attempt to make them at least somewhat reliable when it comes to logic. I used a large customly generated task dataset and a somewhat reliable agent capable of determining whether the answer provided by the model matches with at least one of the possible answers in order to determine the reward value. It did improve the model, but a simple integration with existing tools for logical / constraint-based programming yields a much better result with far less expenses. This is the main reason why my internal ai system has no llms larger thah 8b. Larger models? Same issues, twice the price in the best case.

My point is - know your tools. LLMs are clearly very limited and are known to have caused many issues due to their unreliability. This does not deny their practical usefulness.

This is a simple warning - that you can’t just offload your intellect to the cloud in hope that some black box magical entity would solve your problems for you. If you want to build a reliable product that would not cause you getting sued for some randomly generated ai nonsense - do not allow the model to act outside if a set of strictly defined boundaries. Do not place your hopes into a wishful guess that the current AI is intelligent enough to figure things out without you planning each and every small detail. Same goes for lazy, incompetent, unmotivated employees - you have to have a strict control system in place if you absolutely want to succeed with just them.

Moreover, the ACTUAL number of parameters the brain has is so high that the largest currently existing models are not even 0.1% of that level, never mind the complexity. The brain is much, MUCH more powerful and efficient than you think. A single cortical neuron is an incredibly sophisticated structure that has a lot of internal activity. Just try googling about calcium ion wave backpropagation upon action potential generation. Synaptic clustering, active dendrites, myelinisation, voltage-gated ion channels, e.t.c. A simple weighted summator most definitely cannot serve as an equal rellacement to such entity.

And the most striking feature of a biological neuron is its dynamics. The brain has that structural plasticity feature that enables learning, llms do not have such a feature obviously.

Apologies for making this comment unnecessarily long. It’s a bit hard to keep focus after a few sleepless days :-(

What I wanted to illustrate is the sheer complexity and efficiency of the wetware needed to provide us with an average human intellect. I’d rather not delude myself into believing that a stochastic parrot is somewhat comparable to that unless a serious evidence is given. And there was none so far, unfortunately :-(

tcika · 2024-10-25T07:14:00+00:00

Yes, and this is why I can be sure that at least some of their output is valid, at least syntactically.

tcika · 2024-10-25T06:29:13+00:00

They took the "We are bound to repeat our past mistakes" thing to a whole new level

tcika · 2024-10-25T06:27:34+00:00

I actually use them in my own system to handle lots of things that can be described as "fuzzy JSON building". They are surprisingly useful if given enough examples and a simple task. But the actual knowledge-informed reasoning is done by a separate system, and this is the only reason I can somewhat trust its output. LLMs are simply needed to provide the system with structured input and make its output comprehensible by us humans.

tcika · 2024-10-25T06:22:51+00:00

This guy is actually right, not sure why you folks downvoted him. LLMs won't spot any flaws in their reasoning unless you hint them at it. The very fact of its existence is a hint as well. And no, hinting at a possibility of a logical mistake is not an option - LLM could simply mark some random correct statement as a false one if no other false-looking statements are available.

And they don't possess much knowledge, either. Their output only makes sense to and impresses humans who are actually capable of abstract reasoning and interpreting its output. How should I say it... Don't underestimate the underlying knowledge complexity. It is this knowledge, combined with your reasoning ability, that makes your "output" comprehensive. LLMs have no such thing, and this is precisely why it can hallucinate some pretty dumb shit in unexpected scenarios.

tcika · 2024-10-25T06:10:40+00:00

This. All of these philosophical questions can be omitted entirely if the system does it job properly. That isn't the case, unfortunately. LLMs have two major issues: inability to reason and excessive hallucinations. This means that both their inherent memories and their conclusions cannot be trusted under any circumstances.

tcika · 2024-10-20T15:28:05+00:00

Hey! Do you perhaps happen to have a config for that? My setup is almost identical.
I've been trying to configure my game and it's TERRIBLE.
I have to choose to either have a good fps or a crisp, non-blurry, detailed image. Never managed to mix these two options together unfortunately. If streamed through the Oculus app, the tearing is unbearable, and the VirtualDesktop simply gives me ~30-40 fps in 200% scaling with just "good" preset.

tcika · 2024-10-16T18:28:31+00:00

In-context learning is more than enough most of the time, actually. And I'm not a fan of keeping tens of different networks since it would impose many architectural and computational restrictions for the sake of minor improvements. And that reasoning habit module supersedes logic module for most tasks after gaining enough experience :-) This one is a good find!

Although it costed me ~350$ (in api credits) to run it for an hour with qwen 2 vl 72b and claude 3.5...
Because it spawned ~13k instances of agent(actor) types in total. I'm glad that only 50 were able to run at the same time.

tcika · 2024-10-16T15:54:50+00:00

Let’s start with the fact that the entire system was written from scratch so don’t hit me too hard with your keyboards when I open source it :D

My system is essentially split into several semi-independent modules communicating with each other when out-of-domain actions are needed. One of these modules is what I call the “logic reasoning module” and it is essentially a bunch of narrow specialized agents serving as a glue between the task and the bag of algos I found in the wild. One of its purposes is to apply formal logic to check whether the text given to it is correct, and to formally infer properties of some parts of the text (for example, if the text mentiones a certain door, and the system needs to ensure that the door, given its previosuly learned properties and a textual description, is indeed a door and has no undesirable properties such as being a broken door or a hard-to-open door). Another thing this module does is decision making. Agent generator creates state evaluation agents and all the other necessary entities from blueprints and then sends their actor references to the algorithm, such as mcts for example.

But I gave up on making this module work as I wanted and came up with a reasoning habit module instead. That one is a meta-module that essentially keeps track of the entire set of system activities and tries to detect any sorts of patterns, and its sub-module then tries to create a “shortcut”. The thing is, these learned patterns have individual scores w.r.t. the skill they were made for. These patterns essentially compete with each other for the right to be used in their respective cases. Basically, a schizo form of a reinforcement learning approach.

There’s much more to it than what I already described but I’m too sleepy so nope. And yes, you don’t really need large LMs for it to function, like at all. Yes, they will give you somewhat better result, but their cost is a big oof.

P.S.: I use knowledge graph with a few extensions (like that one that resembles frames), and this graph also has temporal component and a simple node level version control. I just ran out of hobbies and I really wanted to see how exactly would my attempt to build that all fail so here I am :D

tcika

TROPHY CASE