everlier

Hey, thanks for posting it!

Fable 5.1 makes everything a "Rung". These statistical markers are very annoying.

It's actually a really great idea, but it doesn't have to go beyound existing Responses or Chat Completions APIs.

We built that in my current company and it works wonders to just script entire persistent workflows with a simple SDK.

"THIS IS NOT A DRILL"

You can also install Harbor and then it's:

harbor up omlx opencode

The company I work at tries to solve it right now, not promoting, just want to share.

Slop is no fun to deal with, so we have a thesis that slop should be left for agents to read and human-to-human communication should happen outside of passing empty fluffy docs to one another. To realise that, we have a workspace with group chats where multiple agents and humans can work together and agents can engage with humans for additional information when needed. The challenge is, of course, to find the right level of autonomy for the agents and let the agent learn and follow user's workflows well enough to be useful.

I wanted to have a nice way to see which skills in my agentic setups are not useful anymore, so I built this tool to aid in that.

Bun+OpenTUI for CLI, separate Rust binary for indexing the sessions of your coding agents. Release video made with Hyperframes.

There was never a better time to run LLMs locally. It's just a few commands from zero till a fully working LLM homelab.

``` harbor pull unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q4_K_XL

# Open WebUI -> llama.cpp + SearXNG for Web RAG + OpenTerminal as sandbox harbor up searxng webui llamacpp openterminal ```

That's it, it's already better than Claude's or ChatGPT's app.

Thanks for the interest!

Spec is essentially a set of facts + fluff. List of facts is essentially the spec minus the fluff. This was my main idea when trying this approach out. It worked quite well, so I went on building the CLI and a set of skills to better guide the agent about this specific workflow.

Thanks! The project is dogfooded, so the most direct example is the project itself.

Outside of that, I found a few things particularly useful so far: - I can seed a relatively complex project with just a few core assumptions about behaviors I have, agent will firgure out all the gaps in a formalised way - I can easily diff/compare the fact sheets against one another. One example: I built a fact sheet for a fairly hairy Python CLI, then asked the agent to update all Python-related entries to their Rust equivalents, then rebuilt this CLI in Rust in the scope of another project - It's much quicker than working with large spec formats, agent uses less tool calls to capture the context it needs to work on something - After doing large refactoring, agent doing a "fact check" is essentially a full on e2e test run

Two biggest gains for agentic use are because fact sheets are more compact and that they are all assertions about the desired state, it's much easier to reason about things that should and shouldn't be there

owning GGUF conversion step is good in sone circumstances, but running in fp16 is below optimal for this hardware due to low-ish bandwidth.

It looks like context is set to 32k which is the bare minimum needed for OpenCode with its ~10k initial system prompt. So overall, something like Unsloth's UD q8 XL or q6 XL quants free up a lot of memory and bandwidth moving into the next tier of usefulness.

I tried, really really hard but then I realised that I essence it's a poorly written agentic coding assistant that wastes a lot of tokens antropomorphising itself while forcing me to debug via WhatsApp instead of normal tools. So I leaned into that and made OpenCode my general assistant, it worked much better in this aspect.

Changes as we speak, z.ai is the first one to show differential pricing

After seeing a recent video from Theo, I wanted to see how far I can take a harness contained in just 30 lines of JavaScript. Turns out - far enough to be useful, it handles simple tasks just fine, works with both cloud and local models, uses just three tools (but can do with a single one, frankly speaking), cleanly handles detached commands or cancellation mid-run, has non-interactive mode and can be run with NPX.

Thanks! Caustics shader is one of the treasures in our current landing :-)

Pi is a great set of libraries, I would tend to say its underappreciated previously, but now it's fairly mainstream

They are playing catch up with Anthropic's in this functionality. Claude's app was unified and extended with new use-cases since pretty much the very beginning and OpenAIs approach is just a reflection of their attempt too shoot for all targets once (with independent teams, of course).

OpenCode is an awesome tool.

Many folks from other tools are only getting exposed to the same functionality they got used to, but it offers much more than other harnesses, especially for remote coding.

You can start a service via `opencode serve`, it can be accessed from anywhere and has great experience on mobile except a few bugs. It's a really good way to work with your agents remotely, goes really well with TailScale.

The WebUI that they have can connect to multiple OpenCode backends at once, so you may use multiple VPS-es for various projects you have and control all of them from a single place.

Lastly, there's a desktop app, but TBH I find it redundant when WebUI has everything needed.

Make no mistakes though, it's not a perfect tool, my gripes with it:

- There are random bugs with loading/restoring state of the session

- Model/Provider selection switch across sessions/projects is often annoying

- I had a bug making Sonnet/Opus unusable from mobile phone because phone's clock was 150ms ahead of laptop's (ID generation)

- Sometimes agent get randomly stuck. It especially sucks for long/nested sessions

- WebUI on laptop just completely forgot all the projects at one day

- `opencode serve` doesn't pick up new skills automatically, it needs to be restarted

What I feel is more like "too much of a good thing", and too many people that want quick riches concentrating on this field after the web3 fiasco. Both of these seems more like a systematic societal issues rather than the problem with technology itself.

A dossier on major events in agentic security since the first release of ChatGPT on November 17th, 2022. Fun fact, first prompt injection was documented three days before that date.

We call it a slip slop at work, it's ok to slip some slop if it's "our" slop :-)

Never thought about this, but it makes sense they don't want a better local search, just for users to rely more on their product. It's messed up - so much time and human potential wasted on poor search and ads.

Great observation! OpenGuard as a project aims to solve exactly this problem - a protocol-level "firewall" for LLM APIs.

Thank you for the feedback!

I actually assure you that no deep research from any of the provider was used to create the article itself, but I used a custom-built research pipeline for creating a dossier on promt injections as a starting point.

The article was intended as an overview of prompt injections with my prediction what will happen next in this space, which is a soft justification why the tools like OpenGuard are needed. I've spent multiple days iterating on the prose without an ill intent, mostly aiming to make it dense and informative to avoid wasting people's time, which I see backfired here.

I'm deeply sorry that it left such a bad taste despite my best effort, there's still a lot to learn for me.

Thank you for the feedback! It's very early days of the project, there's indeed a lot to improve in this aspect.

OpenGuard is an OpenAI/Anthropic-compatible LLM proxy with middleware-style configuration for protocol-level inspections of the traffic that goes through it. Right now it has a small set of guards that is being actively expanded.

OpenAI and other labs are trying to do this within existing structure by explicitly training a specific chain of authority in the inputs: https://github.com/openai/model_spec/blob/main/model_spec.md...

However, you may immediately see how using same input space essentially relies on the model itself to do the judgement which can't be ultimately trusted

You can do same with Harbor in a couple of commands :)

# Pull Qwen 3.5 35B

harbor pull unsloth/Qwen3.5-35B-A3B-GGUF:UD-Q4_K_XL

# Set llama.cpp image to an optimised one for performance on Strix Halo

harbor config set llamacpp.image_rocm docker.io/kyuz0/amd-strix-halo-toolboxes:rocm-7.2

# Set default model for the claw

harbor config set openclaw.model unsloth/Qwen3.5-35B-A3B-GGUF:UD-Q4_K_XL

# Start both

harbor up openclaw llamacpp

I'm sure that there are more providers and harnesses that are better suited for lighter models. Please share the ones you know.

Most of these tools work with OpenAI-compatible APIs, register for OpenRouter, top up your account for $10 one time to avoid rate limits and use free models that are always there in one way or another.

How do we express nuance when steering agents and fleets of agents in the future?

Telling your agent to be "slightly more concise" or "less formal" - how can that be quantified? How do you balance between dozens of characteristics that we might want our agents to have?