Agreed on SQL being the best exploratory interface for agents. I've been building Logchef[1], an open-source log viewer for ClickHouse, and found the same thing — when you give an LLM the table schema, it writes surprisingly good ClickHouse SQL. I support both a simpler DSL (LogchefQL, compiles to type-aware SQL on the backend) and raw SQL, and honestly raw SQL wins for the agent use case — more flexible, more training data in the corpus.
I took this a few steps further beyond the web UI's AI assistant. There's an MCP server[2] so any AI assistant (Claude Desktop, Cursor, etc.) can discover your log sources, introspect schemas, and query directly. And a Rust CLI[3] with syntax highlighting and `--output jsonl` for piping — which means you can write a skill[4] that teaches the agent to triage incidents by running `logchef query` and `logchef sql` in a structured investigation workflow (count → group → sample → pivot on trace_id).
The interesting bit is this ends up very similar to what OP describes — an agent that iteratively queries logs to narrow down root cause — except it's composable pieces you self-host rather than an integrated product.
It replaced both Filebeat and Logstash for us with a single binary that actually has sane resource usage (no more JVM nightmares). VRL turned out to be way more powerful than we could imagine - we do all our log parsing, metadata enrichment, and routing to different ClickHouse tables in one place. The agent/aggregator topology with disk buffering is pretty dope.
Genuinely one of my favorite pieces of infra software. Good luck with Tero.
I've landed on a similar philosophy but with a slightly different approach to orchestration. Instead of managing everything interactively, I built a lightweight bash-based deployment system that uses rsync + docker compose across multiple machines.
The structure is dead simple: `machines/<hostname>/stacks/<service>/` with a `config.sh` per machine defining SSH settings and optional pre/post deploy hooks. One command syncs files and runs `docker compose up -d`.
I could see Claude Code being useful for debugging compose files or generating new stack configs, but having the deployment itself be a single `./deploy.sh homeserver media` keeps the feedback loop tight and auditable.
I also quite like Localsend to quickly share files on the same network. Used to send photos/files to myself on Whatsapp/Telegram before but after discovering Localsend, stopped!
I've been working on LogChef (https://logchef.app) - a specialized log analytics UI for ClickHouse that focuses on powerful querying and exploration without the complexity of full observability platforms.
The core idea is to leverage ClickHouse's incredible columnar performance for log analytics while providing a schema-agnostic interface that works with any log table structure. It supports both simple search syntax for quick queries and full ClickHouse SQL for complex analytics. Also it has proper RBAC: Team-based access controls for multi-tenant environments.
Off late I have also added some AI features:
- AI-powered SQL generation - write queries in natural language
- MCP (Model Context Protocol) server integration for AI assistants to query your logs
It's open source (AGPLv3) and deliberately doesn't handle log collection - instead it integrates with existing tools like Vector, Fluentd, or OpenTelemetry Collector. The roadmap includes REST APIs, client libraries, visualizations, and alerting.
Built with Go + Vue.js + TypeScript. Currently handles millions of log entries daily in production environments at my org. The deployment is just a single binary deployment with a SQLite DB.
It's great to see Typst getting more visibility. We migrated a real-world workload to it a couple of years back: generating and e-mailing 1.5M+ PDFs daily at my org, Zerodha.
Our previous pipeline was LaTeX-based (first pdflatex, then lualatex), but we were constantly fighting cryptic memory errors on large documents and huge Docker image sizes that slowed down boot times of our ephemeral workers.
Switching to Typst was a massive win for us. The single static binary resulted in tiny images and faster boot times. More importantly, the performance gains were huge. Overall compile times were ~3–4× faster than LaTeX. On really large documents (2000+ pages, mostly tables), Typst compiles in ~1 minute vs. ~18 minutes with lualatex.
Beyond performance, the better developer experience and good error messages was a nice bonus too.
We wrote a detailed post about the entire architecture - from the job orchestration with Nomad to the S3 optimizations and the Typst migration in particular. If you're curious, you can read it here: https://zerodha.tech/blog/1-5-million-pdfs-in-25-minutes
It's an open-source (AGPLv3), purpose-built log analytics UI specifically for ClickHouse. I've been using ClickHouse for logs and love its power, but found the existing UIs either too heavy, too focused on ingestion (which we already have covered with tools like Vector/Promtail/Fluentbit/Logstash etc), or not ClickHouse-native enough.
Logchef aims to be a lightweight, powerful log explorer that sits on top of your existing ClickHouse setup.
Key things:
- Schema-agnostic: Works with your existing ClickHouse log tables. No need to change how you store things.
- Dual Query Modes: Simple search syntax (e.g., level=error service=api) for quick looks, and full SQL for complex analysis when you need to dig deep.
- Lightweight & Focused: Single binary, easy to deploy. It doesn't do ingestion, letting you use best-of-breed tools for that.
- Team-centric: Built with multi-tenancy for teams and access controls for different log sources from the get-go.
I've got a demo running at https://demo.logchef.app if you'd like to try it out. It's still evolving, so feedback (especially from other ClickHouse users) would be super valuable!
So, Logchef has a concept of "Source" which represents a ClickHouse table. You give the DSN (essentially host/port/user/password for now) and connect. In prod scenarios, usually you only `GRANT SELECT ON db_name.table_name TO user_name;`
Once you add the source, you can "connect" the source to a team. Only the members of the team will be allowed to query this source. So you can have multiple teams and add users accordingly. A source can be added to multiple teams as well.
What I don’t like about Claude Code is why can’t they give command line flags for this stuff? It’s better documented and people don’t have to discover this the hard way.
Similarly, I do miss an —add command line flag to manual specify the context (files) during the session. Right now I pretty much end up copy pasting the relative paths from VSCode and supply to Claude. Aider has much better semantics for such stuff.
I'm curious to understand the implications of the AGPL-3.0 license in the context of this project. It sounds like the author doesn't want big corps to offer a hosted version of this tool (because doing that would require them to release the source code of any modifications they make to the software, which many companies are reluctant to do) and it's also an OSI approved license (unlike the recently famous SSPL or BSL). What's so wrong about AGPL-3.0 then?
The intention is often to prevent companies from building proprietary services on top of open source software and I feel AGPL 3.0 is a sensible choice here.
Looks like a solid project, will be interested in giving it a shot
Aside: I built my own expense tracker [1] as well to categorise expenses using LLMs as I needed a quick way to log the entries. I’ve been meaning to export these to Actual budget for a detailed analysis but haven’t done that yet.
Never really caught on with the idea of integrating external I/O in something as fundamental as logging. More often that not a pull vs push approach is suited for logging. There are dozens of high performant log collectors/aggregators who can collect, transform, and push logs to N number of stores. What’s the advantage of doing this right inside the app? (Besides maybe serverless functions?)
> In addition, we have given out many sizeable grants to FOSS projects and organisations in India. While funding projects outside India involves significant paperwork and operational overhead, we have reached out to several small and large projects that we use at work and have managed to pay them. This highly ad hoc approach is something that has increasingly bugged me though.
1. Regarding the validation, this error seems to be related to the provenance check mechanism in the spec. This is to prove ownership of that project/domain. The wellKnown field is designed to handle cases where the webpageUrl doesn't match the manifest URL.
2. Will definitely be passing the feedback to our team and evaluate this further!