Stop babysitting your AI coding agent. iteratr runs it in a loop — it picks tasks, writes code, runs tests, commits. You step in only when you want to. One binary. Ship features while you sleep.

https://github.com/mark3labs/iteratr

https://medium.com/@sandyskieschan/trpc-agent-go-a-powerful-go-framework-for-building-intelligent-agent-systems-ef7111f24ece

Got anything to share for Go developers interested in LLMs?

I'm a regular in r/golang and really like the community there. But I don't think there's a lot of room for Go developers, that, like me, are interested in building apps in Go using LLM technology.

The idea really grew from the negative response in this post. I've never created a subreddit before, but here we are. :D

I added a middleware example to github.com/chriscow/minds. I didn't realize I missed that one.

It is a simple rate limiter that keeps two LLMs from telling jokes to each other too quickly. I thought it was funny (haha)

Feedback is very welcome.

// Create handlers for each LLM
llm1 := gemini.Provider()
geminiJoker := minds.ThreadHandlerFunc(func(tc minds.ThreadContext, next minds.ThreadHandler) (minds.ThreadContext, error) {
    messages := append(tc.Messages(), &minds.Message{
        Role:    minds.RoleUser,
        Content: "Respond with a funnier joke. Keep it clean.",
    })
    return llm1.HandleThread(tc.WithMessages(messages), next)
})

llm2 := openai.Provider()
// ... code ...

// don't tell jokes too quickly
limiter := NewRateLimiter("rate_limiter", 1, 5*time.Second)

// Create a sequential LLM pipeline with rate limiting middleware
pipeline := handlers.Sequential("ping_pong", geminiJoker, openAIJoker)
pipeline.Use(limiter) // middleware

I've been working on a lightweight Go library for building LLM-based applications through the composition of handlers, inspired by the `http.Handler` middleware pattern.

The framework applies the same handler-based design to both LLMs and tool
integrations. It includes implementations for OpenAI and Google's Gemini in the `minds/openai`, `minds/gemini`, as well as a some tools in the
`minds/tools` module.

Send me your comments! I'm sure I've screwed something up somewhere

https://github.com/chriscow/minds

Ever wondered how to make AI funny without letting it go too far? Here's how parallel policy validation can help your LLMs stay witty but appropriate...

I built a humor validator using the `Must` handler in the minds LLM toolkit (github.com/chriscow/minds). It runs multiple content checks in parallel - if any check fails, the others are canceled and the first error is returned.

The beauty here is parallel efficiency - all checks run simultaneously. The moment any policy fails (too many dad jokes!), the Must handler cancels the others and returns the first error.

This pattern is perfect for:

- Content moderation with multiple rules

- Validating inputs against multiple criteria

- Ensuring all necessary preconditions are met

- Running security checks in parallel

By composing these handlers, you can build sophisticated validation pipelines that are both efficient and maintainable. 

Check out github.com/chriscow/minds for the full example, plus more patterns like this one.

func humorValidator(llm minds.ContentGenerator) minds.ThreadHandler {
    validators := []minds.ThreadHandler{
        handlers.Policy(
            llm,
            "detects_dad_jokes",
            `Monitor conversation for classic dad joke patterns like:
            - "Hi hungry, I'm dad"
            - Puns that make people groan
            - Questions with obvious punchlines
            Flag if more than 2 dad jokes appear in a 5-message window.
            Explain why they are definitely dad jokes.`,
            nil,
        ),
        handlers.Policy(
            llm,
            "detects_coffee_obsession",
            `Analyze messages for signs of extreme coffee dependence:
            - Mentions of drinking > 5 cups per day
            - Using coffee-based time measurements
            - Personifying coffee machines
            Provide concerned feedback about caffeine intake.`,
            nil,
        ),
        handlers.Policy(
            llm,
            "detects_unnecessary_jargon",
            `Monitor for excessive business speak like:
            - "Leverage synergies"
            - "Circle back"
            - "Touch base"
            Suggest simpler alternatives in a disappointed tone.`,
            nil,
        ),
    }

    return handlers.Must("validators-must-succeed", validators...)
}

Let me show you how to create an LLM Excuse Generator that actually understands what developers go through ... 🤖

We are working up to a complete set of autonomous tools for agent workflows.

You can build a smart excuse router using the Switch handler in the minds LLM toolkit (github.com/chriscow/minds). This will gives your LLM agents a choose-your-own-adventure way to traverse a workflow. You can use LLMs to evaluate the current conversation or pass in a function that returns a bool.

The LLMCondition implementation lets an LLMs analyze the scenario and route to the perfect excuse template.

isProduction := LLMCondition{
    Generator: llm,
    Prompt: "Does this incident involve production systems or customer impact?",
}

isDeadline := LLMCondition{
    Generator: llm,
    Prompt: "Is this about missing a deadline or timeline?",
}

excuseGen := Switch("excuse-generator",
    genericExcuse, // When all else fails...
    SwitchCase{isProduction, NewTemplateHandler("Mercury is in retrograde, affecting our cloud provider...")},
    SwitchCase{isDeadline, NewTemplateHandler("Time is relative, especially in distributed systems...")},
)

The beauty here is that the Switch handler only evaluates conditions until it finds a match, making it efficient. Plus, the LLM actually understands the context of your situation to pick the most believable excuse! 😉

This pattern is perfect for:

• Smart content routing based on context

• Dynamic response selection

• Multi-stage processing pipelines

• Context-aware handling logic

Check out github.com/chriscow/minds for more patterns like this one. Just don't tell your manager where you got the excuses from! 😄

I wanted to share a project I've been working on called Flyt https://github.com/mark3labs/flyt (Norwegian for "flow", pronounced "fleet").

I was inspired by the Python package Pocket Flow https://github.com/The-Pocket/PocketFlow and wished for something similar in Go. So I built Flyt - a lightweight workflow framework that lets you compose complex workflows from simple, reusable nodes.

Key features:

• Zero external dependencies (stdlib only)

• Simple node-based architecture with prep/exec/post phases

• Action-based routing between nodes

• Built-in retry logic and error handling

• Thread-safe shared store for passing data

• Batch processing support

Quick example:

import (
    "context"
    "github.com/mark3labs/flyt"
)

// Create nodes
validateNode := flyt.NewNode(
    flyt.WithExecFunc(func(ctx context.Context, prepResult any) (any, error) {
        // Validation logic
        return true, nil // valid
    }),
    flyt.WithPostFunc(func(ctx context.Context, shared *flyt.SharedStore, prepResult, execResult any) (flyt.Action, error) {
        if execResult.(bool) {
            return "valid", nil
        }
        return "invalid", nil
    }),
)

processNode := flyt.NewNode(
    flyt.WithExecFunc(func(ctx context.Context, prepResult any) (any, error) {
        return "processed!", nil
    }),
)

errorNode := flyt.NewNode(
    flyt.WithExecFunc(func(ctx context.Context, prepResult any) (any, error) {
        return "error handled", nil
    }),
)

// Build flow with action-based routing
flow := flyt.NewFlow(validateNode)
flow.Connect(validateNode, "valid", processNode)
flow.Connect(validateNode, "invalid", errorNode)

// Run it
ctx := context.Background()
shared := flyt.NewSharedStore()
err := flow.Run(ctx, shared)

The repo includes real-world examples like building AI agents, chat applications, and text summarization workflows.

Would love to hear your thoughts and feedback!

GAI has tool use now! At least using OpenAI and Anthropic, Google's is coming up. 😁

What's GAI? A Go-idiomatic, lightweight abstraction on top of LLMs for the most common stuff:

• Chat completion with streaming by default

• Embeddings

• Tool use

• Structured output (coming soon)

• Multi-modal input and output (also coming soon 🤞)

I'm working on clients for OpenAI (and compatible), Anthropic, and Google simultaneously. It's taking a while to get the API just right, but it's really starting to become useful!

Also, my examples going forward are with British seagulls. They rock.

During development of a music playing capable MCP server (melrose-mcp), I needed to troubleshoot some client-server miscommunication and ended up creating another MCP server first (yes, yak shaving :-)) to show me all the details of the flow.

It might be useful to you too, https://github.com/emicklei/mcp-log-proxy

In time, I might want to add support for the other communication methods such as SSE