Experimentation with Jev from @typesafeai and our harness @goose_oss Use Jev to take a prompt and JIT select a model just before the turn runs. Jev and models like it will be useful in many areas and this is just early prototype code on a first idea

I saw a colleague trying to bring in and use Claude Code at work. They struggled to connect Claude Code with a pre-configured LiteLLM endpoint in an air-gapped environment, and it ended up failing. In the end, they are currently using @goose_oss lol. He realized just how convenient it is. Goose offers compatibility with a truly wide variety of model providers.

Make goose work the way your team does 🪿 @onlydole walks through adding MCP tools and deciding when to change the agent itself, using lint checks as a practical example. Start small, customize what you need 👇

Most people live with agents — inside CLI, TUI, and Desktop UI. We need to learn to operate agents from outside the agent. Go headless, dive into the SDK, and wire it into CI/CD. Assign different LLMs based on the agent's role. Orchestrate sub-agents. @goose_oss can do all of this. Check it out: And look at what other harness users are building too. That's totally fine — they've documented so many use cases and it's super helpful. Using a great agent is good. But to develop an eye for what makes an agent actually good, you have to build one yourself. Only someone who has baked cookies knows how much sugar and butter goes in. Someone who has only eaten them never will.

The @ollama cloud subscription gives broad access to open-weight models, and usage vs. credits is fairly generous. However, if you run kimi-k3 or glm-5.3 as the main model, the allocation burns through fast. @goose_oss is the harness that fits this plan best. Keep the main agent on deepseek-v4.1-flash and define subagents as goose recipes. A recipe is the subagent config. Lock role, extensions, and model into the recipe, and the subagent spins up with that exact setup when invoked. Role split: • Hard, long-horizon reasoning / difficult coding: glm-5.3 • Document and external-repo analysis: glm-5.3-flash • Web search: a cheap recipe with search tools attached (deepseek-v4.1-flash or glm-5.3-flash) Put into .goosehints when to call which recipe and when the main agent should handle the work itself. As the task proceeds, the main agent only invokes the recipes it needs. Expensive models get used only for those segments, so you save tokens. Other harnesses often support per-subagent models too, but wiring Ollama Cloud’s open-weight models into reusable recipes is where goose fits best.

Let @goose_oss run your linter! You don't need to build an MCP server for that. I wrote about how to make Goose fit your project's workflow, inspired by @Stripe's Minions. You know you want to take a look 👀

Great use case for local AI for hybrid AI. I followed a very similar approach with on device AI agents powered by @goose_oss and @googlegemma 4 E4B on @Qualcomm_Dev devices using Llama cpp Having on device tools for privacy focused use cases and tools like web search through web:

It is important for an agent to know itself. Only then can it make full use of its underlying harness. @goose_oss uses the goose-doc-guide skill to reference what it is capable of. The problem, however, is that in air-gapped network environments like mine, it cannot access the outside. So I raised this issue with the goose team, and @alexjhancock took care of implementing a fix. I want to thank the goose team for developing responsibly as a standard agent of the @AgenticAIFdn . Thanks to them, goose now knows who it is and does its job well, even in air-gapped networks.

What will it take to make the agentic AI ecosystem work at scale? @techgirl1908, VP of the Agentic AI Foundation, joins @PracticalAIShow to explore the open standards and projects shaping the future of agents, including MCP, A2A, @agentgateway, and @goose_oss. The conversation covers enterprise adoption, neutral standards, global perspectives, and finding the right balance between what humans delegate to AI and what humans do best. Audio: Youtube:

built a lil app on a cores3 m5stack that the boys can talk to to get @goose_oss to draw pictures and auto-print them to a thermal printer highly recommend / very fun if you have little ones

The @goose_oss CLI offers a wide range of commands, and one of them is `goose review`. By default, it reviews the diff between your working tree and HEAD, but you can also specify a range like `main...HEAD`. Most agents provide code review through a slash command like `/review` inside their CLI or TUI. That's how I've been using it too. What sets goose apart is that this review feature can be invoked headlessly as an external process. That makes it easy to drop directly into a CI/CD pipeline. An example is `CodeGoose`, a sample project I built. It runs `goose review` inside a GitHub Actions workflow to review PR diffs and leave comments automatically. It works quite reliably, and since goose supports BYOK (Bring Your Own Key), you can build your own fully self-owned review agent. As GDK (Goose Development Kit), which is currently under active development, matures, I think it will be possible to build a much more lightweight yet specialized review agent.

Since we moved to "issues are the new PRs" in @goose_oss, we are having an easier time keeping pace with our backlog But I've also noticed submission quality has improved, and we're merging more of what the community opens seems to work

As I’ve mentioned before, work in a company follows established workflows. Delegating tasks to an agent in a company means that the agent must work as a member of that organization. @goose_oss recipes allow us to define such internal workflows and carry out a consistent work process every time. It carries out tasks with astonishing consistency each time. Through recipes, we can delegate our work to agents with much greater confidence.

Goose recipes let you save and share reusable workflows. Subrecipes split larger workflows into smaller steps. Adriana Villela explains both with a Kubernetes example and shares the issues she hit along the way.

Multi-cloud Kubernetes inventory sounds simple… until you add an AI agent to the mix. 🪿 @pavanmadduri27 shares a reference design for using goose to collect Kubernetes inventory from OKE and AKS. The design uses read-only cloud credentials and human approval, so the model can coordinate the work without controlling access.

A Goose walks into an enterprise Java stack… 🪿☕ In Part 1 of this new tutorial, @danieloh30 shows how to build cloud-native MCP tool services with Quarkus LangChain4j, add Jakarta Bean Validation, and connect them to Goose over HTTP. Honk responsibly: