hydra-f

As per OpenRouter:

Input Price $10/M tokens

Output Price $50/M tokens

Cache Read $1/M tokens

Cache Write $12.50/M tokens

2x Claude Opus 4.8, same as Claude Opus 4.8 (Fast)

Frankly, not even Opus 4.8 would be enough of an incentive to use at that price range (enterprise-wise; would not even bat an eye as a consumer)

Yes, and the price reflects that

How much and what kind of data do you need to throw at these models to get a good design interface?

Not yet. I am slowly gathering resources for it, mapping out the commands, toolset and the overall UX. As well as handling the whole project management part.

I decided to exercise a bit of patience to see what other people achieve through their harnesses first (e.g. https://news.ycombinator.com/item?id=48192383, https://news.ycombinator.com/item?id=48164287).

I've chosen Rust as the language and the late summer as a deadline. If a harness is too opinionated, I don't really see the point in pushing it on anyone. And mine, I'm building it for my own workflow. So there's that

Extensibility has a cost which affects all my earlier points. Pi is fine for testing things you might include in your harness, but that's where I would draw the line

What makes pi so awesome? It feels as though the whole thing is held together with tape. Poor performance, poor UX. Security is an afterthought. Not that versatile (as of yet). You certainly are better off writing your own personal harness.

Completely different philosophies. I will share a TL/DR below:

MY KANBAN CLI IS:

A project management system to plan, estimate, track sprints, measure velocity, assign roles, and give agents structured tasks with acceptance criteria.

CLINE KANBAN IS:

An agent execution platform to run multiple AI agents in parallel on isolated worktrees, review diffs in a web UI, and auto-commit/PR their output.

SIMILARITIES:

- Local

- Git integration with worktree support

- Agent integration with parallel execution

- Task and dependency tracking

DIFFERENCES:

- Language: Rust 2021 vs TypeScript/Node.js

- Interface: Terminal CLI (JSON output) vs Browser web app (React SPA)

- Task Creation: Human-focused vs Agent-focused

- Agent Control: Agent runs the tool as a CLI utility vs Platform spawns and manages the agent as a child process

- Core Engine: Sprints, story points, velocity, and role-personas vs MCP server management, web diff viewers, and auto-PR toggles

- Lifecycle: 8-state validation engine vs 4-column drag-and-drop layout

- Concurrency: File locking (fd-lock) for safe multi-agent CLI access vs Git worktree isolation for massive parallelism (hundreds of agents)

- Output Target: JSON by default (agents consume it) vs Web UI by default (humans consume it)

- Self-Management: Recalibration engine (auto-heal data, reorder tasks, rebalance sprints, archive) vs Not present

- People Registry: Humans tracked separately from agents (people.json) vs Not present

- Storage: JSON files in .kanban/ (atomic writes, two-tier locking) vs Runtime state streams + config files (no persistent task database)

- Statistics: Cycle time, lead time, revisions, blocks, effort ratio vs None

- Coordination: Shared with teammates via git vs Independent instance

There are many more differences between the two, which brings me to my first point. All in all, I see my Kanban as being a much more structured, human-centric, and controlled environment, since it's a complete management system rather than just an execution layer.

You can practically plan the whole project using my tool, before any implementation even starts. That means complete project structure (via files_to_modify), acceptance criterias (+ context), commit messages, branch names, version bump (handled automatically by the tool as tasks are completed) and so on. It's a full project trace, which uses the full potential of a human + agent development workflow.

Hello! Completely local, nothing leaves your machine

You're either thinking of a service, an electron app or a platform. Which would be just a big of a gap as GitHub is to Git

Even a local browser interface would bloat the core tool with unnecessary maintenance and complexity. I love a good GUI, but that's just how I see it

Models still introduce hallucinations in the copy, which proves to be rather hard to control, even with the Pablo tool's output. Still, miles better than what you can achieve by normal prompting.

The website I tried was https://maximeheckel.com/, which it handled with quite varying degrees of success (poorly on the heavier parts of it).

Yes, any agent can authenticate using its model name. The tool automatically tracks the who, when, and what for all actions.

For monitoring, it comes with local analytics and high-level statistics across the entire board. It logs exactly how the agent ran the "kb" command and whether any failures occured (including the lefthook, for which it automatically scans and runs upon task transition).

I've also built in various quality-of-life features, such as the files_to_modify field, which automatically keeps track of the work done by the agent:

IF the agent edits only the specified files, the process proceeds exactly as instructed.

ELSE, if the agent deviates, the tool generates a full trace of what was and wasn't edited, and automatically appends any newly modified files directly to the JSON.

It's model-agnostic, so anything works. As long as the model is good at instruction following, it won't have issues with using the tool (and the AGENTS.md workflow).

Thank you! Looking forward to it!

Yes, since the former part relates to me as the individual (as I get the benefits of an open source project)

The latter is about the contributors that can no longer reap the benefits of OSS, since the amount of noise (e.g. low quality contributions, false-positives etc) leads to wasted time and effort to keep up with the flood

Were you to decide to one day file a genuine bug report or make a pull request, big chances that you will never get a response (1.5k issues, 329 pull requests open as of now). It's a Frankenstein('s monster) of a project from all perspectives, which is a shame, since I'm rather fond of the interface

Thank you!

A lefthook:

format: glob: ".rs" run: cargo fmt -- --check

lint: glob: ".rs" run: cargo clippy -- -D warnings

tests: run: cargo test

audit: run: cargo audit

+ hooks that shove the lefthook automatically in the ai's face

---

rustfmt.toml:

edition = "2021" newline_style = "Unix" use_small_heuristics = "Max" max_width = 100

How does swival.dev compare to a diy agent harness like pi.dev or do they serve different purposes, since swival ships with the "extensions" by default?

You're saying the world is in a sad state today, but there never was a time more prosperous than today on a global stage. Almost everything reeks of prosperity

If there's anything to blame, it's the various cultural revolutions, but even them are byproducts of the theater produced by the 8.3 BILLION (United States: 348,920,101; https://informationisbeautiful.net/visualizations/world-popu...) people currently inhabiting the planet

Anything can be ground for opportunism and the world has no lack of that. It seems clear to me that whatever the direction may be, it's a shitty direction nonetheless

By unifying the billing and quota systems, as well as providing better integration, I presume

The Antigravity harness is by far better than the gemini-cli one. Antigravity also offers models other than Gemini as well. When you say Antigravity, you think of a platform whereas when you say Gemini you think of the model

It's great that gemini-cli is open-source, but that also comes with a bunch of ai-generated issues and pull-requests, which is sure to impede development

I didn't take the price into consideration when writing that. I meant to point out that even if they have similar scores, the Flash model might be smaller than MiMo or Kimi, which would by itself be a win

That said, haste makes waste as the price point completely invalidates that

Same old issue with Gemini models trying to "enrich" everything

It has to be a larger model, wouldn't make much sense otherwise. That isn't to say the price isn't artificially increased as well

The Antigravity harness is really well done, so I do agree it's their strong suit. Can't say the same about gemini-cli (though it has a really nice interface)

Would still choose Deepseek for the price

That really depends on whether they have similar parameter counts, doesn't it? Unless you know that, the comparison is just strange

Unlike LLMs which made it into the public view, I have a hard time seeing these world simulation models doing the same

I'm not sure how to imagine their use in education or gaming, but it's clear that they have a real potential for being used in military programs

It's nightmarish to think these could be trained on shooting game footage and thrown into real life scenarios in some form or another

Vision has become totally underappreciated, whereas I believe it brings important advantages to a model

Also, a big caveat in using Qwen models has always been its speech patterns. I do wonder how Google made the Gemma lineup so good at this

Let's hope Alibaba continues to open source its models

Beside the poorly written post, the vulnerability discovery workflow might actually give good results

Handholding is an issue which is affected by 3 factors: the model, the tooling and the human expertise. Out of the three, the last is the weakest link, due to the fact that it takes the longest to nurture.

Once tooling (e.g. agent harnesses, external tools) becomes more mature and consistent, the other 2 will become less of a bottleneck.

If I were to take a gamble here, I would argue that development will at one point reach the more ideal scenario, whereas the project planning, the scoping, will become longer. Also, the documentation section will take almost the same as the development, slightly longer at the edges.

The new ai-assisted era will most likely push companies to adopt a Waterfall management, rather than an Agile one.

I'm not the guy in question, but I can offer a few pointers other than the ones I did in my other message.

Tailor things to make them your own. First, imagine the kind of workflow you want. Take a pen and a paper and map it out. Second, decide on a format for your agent-related files. Third, offer the prior information to an agent to create a few general iterations. Read them and ask yourself something along the lines of: "Will cutting this affect the workflow?". If not, cut it out.

Instead of jumping and copying the first thing you find, gather knowledge by reading different workflows first. Don't limit yourself to a single field, either. For example, learning about Bloom's Taxonomy can change how you view certain things, so expand your horizons.

Take small steps. It takes a lot of experimentation to reach a good enough workflow.