Bill Maimone

Cloud cost uncertainty isn’t a fluke; it’s by design. Cloud providers profit from complexity: 💸 Granular billing 💸 Shifting discount programs 💸 Opaque pricing for AI workloads 💸 Exploding SaaS and shadow IT The result? Engineering and FinOps leaders are left scrambling to explain unpredictable cloud bills while innovation can’t slow down. Traditional dashboards and static budgets won’t save you. You need adaptive cloud cost management that embeds cost awareness into engineering workflows, detects anomalies early, and drives shared accountability. We break it all down in our latest post, including 5 steps to start leading through the chaos. Read it here: https://lnkd.in/ge4jadxr #FinOps #CloudCost #EngineeringLeadership #CloudComputing #AI #SaaS #Ternary

35

1 Comment

Today let's talk about Parallel Fan Out/ Concurrent Agentic Design pattern and when parallel agents go rouge What’s the Concurrent Orchestration Pattern? Imagine a scenario where multiple AI agents—each with its own lens or specialty—tackle the same task simultaneously. Instead of a single, step-by-step chain, tasks fan out to different agents in parallel. Then their outputs are merged or aggregated for the final answer. It’s the AI equivalent of a brainstorming session where everyone chips in together. This pattern thrives when you need diverse insights or speed—think ensemble reasoning or reaching a verdict faster. This pattern is commonly used in agentic RAG. Here’s how you can apply it in a Retrieval-Augmented Generation (RAG) system: Step 1: Break the user’s query into smaller sub-queries (e.g., “Define concept X,” “List use cases,” “Give examples”) and map out their dependencies. Step 2: Run those sub-queries in parallel—agents fetch context or process each in isolation (e.g., document retrieval, summarization, external tool usage). Step 3: Once all agents have results, aggregate the findings into a single, coherent response. This technique lets you parallelize independent parts, reducing latency while maintaining clarity—especially effective when sub-queries don’t depend on each other. Super Important : Try to avoid this pattern and use sequential execution even if it's slow, but it might yield a good result, below is the reason As Cognition [the company behind devin] warns in a famous blog post “Don’t Build Multi-Agents”, things can go sideways fast if agents don’t share context or coordination is weak. When agents operate in isolation—making decisions based solely on their own view—the final result might be fragmented, contradictory, or just plain incoherent. Think two agents building different puzzle pieces that don’t fit. The core issues: Context fragmentation: Each agent works in a silo, leading to mismatched assumptions. Implicit decisions: Agents’ outputs reflect unspoken choices that may clash when merged. Coordination complexity: Without strong orchestration, integration becomes error-prone. References : 1. Concurrent Execution Pattern : https://lnkd.in/gZybgm2s 2. LLM Compiler whitepaper : https://lnkd.in/gWwGJhbi 3. Coginition blog Don't build multi agents which shows parallel execution can yield agent drift : https://lnkd.in/gkDKC4TP

14

3 Comments

I made an explorable esoteric research environment with a Custodian named MERIDIAN that can launch its own agent swarms to solve problems. Does isopsephic arithmetic and lookup for any Neoplatonists :-) https://lnkd.in/gYzqVn7m

1

1 Comment

We’re excited to partner with Cognition, the stellar crew behind Devin 🤖 and Windsurf 🌊, to make SWE agents more effective. Here’s the workflow: ✨ CoreStory extracts the hidden business logic, requirements, and complex behaviors in legacy codebases into a persistent spec. ⚡ You pass that spec as context and tasks to Devin, Cognition's Autonomous AI Software Engineer. 🚀 With the spec to navigate, the AI agent gets more powerful. It can modernize entire systems, or use the spec to field even more tickets with higher confidence. This is what the future of software engineering looks like: Human devs + AI agents, working side by side, with CoreStory fueling the spec. #AI #Agents #SpecDrivenDevelopment #LegacyModernization #CoreStory #Cognition

17

There is a lot of AI doom-posting in the news right now with narratives focused on displacement and "doing more with less." At Addepar, we reject that premise. The investment industry doesn’t have a talent problem; it has a time problem. The global ecosystem is massive, fragmented, and increasingly complex. The "noise" of manual workflows and data silos shouldn't be the ceiling for what’s possible. Today, we are officially unveiling Addison. Addison is a native AI experience built to deliver actionable intelligence across investment workflows. We didn’t build it to replace the human element, we built it to accelerate it. In an industry built on trust and strategy, the human judgment remains irreplaceable. Our vision is simple: AI finds the patterns; you make the judgment calls. AI processes the "what"; you own the "why." We believe AI is the tool that finally allows investment professionals to get back to the high-value, high-impact work that actually moves the needle. The future of finance isn’t about automation for the sake of efficiency. It’s about empowerment for the sake of impact. Let’s go build the future. #Addepar #Addison #WealthTech #AI #Innovation #InvestmentManagement

102

3 Comments

Really proud of the work Harry Pierson and the team have done in releasing DBOS Java today! DBOS Java brings lightweight durable workflows to Java. Workflows make your program durable by checkpointing its state in Postgres. If your program ever fails, when it restarts all your workflows will automatically resume from the last completed step. Workflows are useful for solving many problems, such as: - Orchestrating business processes so they seamlessly recover from any failure - Operating an AI agent, or anything that connects to an unreliable or non-deterministic API. - Running reliable background jobs with no timeouts. - Processing incoming events (e.g. from Kafka) exactly once What’s unique about DBOS workflows is that they’re implemented entirely in a lightweight Postgres-backed library. All you have to do to use DBOS is install the library into your application and register workflows and steps. As your program runs, the library checkpoints your workflows and steps in Postgres. If your program ever fails, when it restarts it uses those checkpoints to resume all your workflows from the last completed step. There are no other dependencies you have to manage, no separate workflow orchestrator–just your program and Postgres. The big advantage of this approach is that you can incrementally add DBOS to any Java application–it’s just a library. You can add workflows to your application without rearchitecting it or adopting any new infrastructure. It works out of the box with frameworks like Spring. Also, because it’s all Postgres-backed, you get all the tooling you’re familiar with: backups, GUIs, CLI tools–it all just works. You can use Supabase, RDS, Neon, or any other Postgres provider. Check it out on GitHub, try it out, and give us a star!

49

6 Comments

This one is for all you out there running kafka at scale as part of the architecture for a complex, business-critical application. Check it out!

20

#RR25 is underway, and from Derk "if we don't connect best-of-breed systems AI agents will have as much trouble making progress as coordinators."

62

2 Comments